# 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 mã nguồn mở dành cho dữ liệu nến tài chính, đượ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 để dự báo giá, khối lượng và dữ liệu thị trường trong Python, hoặc tinh chỉnh trên dữ liệu riêng. Cài đặt cơ bản khá rõ ràng, nhưng tinh chỉnh cần Qlib và nhiều GPU.

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

Kronos là mô hình nền tảng dùng chuỗi nến tài chính để dự báo các giai đoạn tiếp theo của thị trường. Mô hình nhận dữ liệu OHLCV, gồm giá mở cửa, cao nhất, thấp nhất, đóng cửa và khối lượng, rồi trả về một DataFrame chứa dự báo cho các khoảng thời gian tương lai.

Repo phù hợp với lập trình viên Python, người nghiên cứu định lượng, nhóm phân tích dữ liệu và chủ doanh nghiệp muốn thử xây dựng công cụ theo dõi thị trường. Điểm đáng giá là Kronos đã có sẵn tokenizer, mô hình dự huấn luyện và lớp predictor. Bạn không phải tự xây toàn bộ quy trình chuẩn hóa dữ liệu, dự báo rồi chuyển kết quả về thang giá ban đầu.

Repo hiện có khoảng 47724 sao và 7902 fork. Mã nguồn dùng giấy phép MIT. Tuy vậy, phần README cũng nói rõ pipeline tinh chỉnh và backtest chỉ là ví dụ minh họa, chưa phải một hệ thống giao dịch production. Repo đã lâu chưa cập nhật, nên bạn cần kiểm tra mã nguồn và môi trường trước khi đưa vào công việc thực tế.

```repo
- repo | shiyu-coder/Kronos
- kind | Mô hình
- desc | Kronos là mô hình nền tảng dùng dữ liệu nến OHLCV để dự báo chuỗi thời gian của thị trường tài chính.
- stars | 48k
- lang | Python
- license | MIT
```

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

### Dự báo chuỗi nến tài chính

Kronos được thiết kế riêng cho “ngôn ngữ” của thị trường tài chính, tức các chuỗi K-line có nhiều nhiễu. Mô hình có thể dự báo các trường `open`, `high`, `low`, `close`, `volume` và `amount` cho những mốc thời gian tương lai.

Điều này hữu ích khi bạn muốn tạo một lớp dự báo cho dashboard nội bộ, thử nghiệm chiến lược định lượng hoặc nghiên cứu cách một mô hình nền tảng xử lý dữ liệu thị trường. Kết quả chỉ là dự báo của mô hình, không phải cam kết giá sẽ diễn ra như vậy.

### Dùng tokenizer và mô hình có sẵn

Kronos chuyển dữ liệu OHLCV liên tục thành các token rời rạc theo cấu trúc phân cấp. Sau đó, mô hình Transformer tự hồi quy học cách dự đoán token tiếp theo. Cách tổ chức này giúp repo xử lý dữ liệu nến theo cách phù hợp hơn với đặc điểm của thị trường tài chính.

Bạn có thể tải tokenizer và model đã huấn luyện sẵn từ Hugging Face Hub bằng tên model được README cung cấp. Các lựa chọn gồm Kronos-mini, Kronos-small và Kronos-base. Kronos-large được liệt kê trong model zoo nhưng chưa được đánh dấu là mã nguồn mở.

### Chọn model theo nhu cầu

Kronos-mini có 4.1M tham số và context length 2048. Kronos-small có 24.7M tham số và context length 512. Kronos-base có 102.3M tham số và context length 512. Kronos-large có 499.2M tham số nhưng chưa được đánh dấu là open-source trong README.

Với lần chạy đầu, Kronos-small là lựa chọn dễ thử vì README dùng model này trong ví dụ. Nếu cần context dài hơn, Kronos-mini có giới hạn ngữ cảnh được công bố là 2048. Khi chọn model, bạn vẫn nên cân nhắc bộ nhớ và tốc độ của máy.

### Dự báo một hoặc nhiều chuỗi

Lớp `KronosPredictor` có phương thức `predict` cho một DataFrame. Nếu cần xử lý nhiều tài sản hoặc nhiều chuỗi cùng lúc, bạn có thể dùng `predict_batch`.

Batch prediction yêu cầu các chuỗi có cùng độ dài dữ liệu lịch sử và cùng độ dài dự báo. README cho biết phương thức này tận dụng xử lý song song trên GPU, đồng thời tự chuẩn hóa và đưa kết quả về thang dữ liệu riêng cho từng chuỗi.

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

Repo có pipeline tinh chỉnh sử dụng dữ liệu thị trường A-share đã được chuẩn bị qua Qlib. Quy trình gồm cấu hình đường dẫn, tiền xử lý dữ liệu, tinh chỉnh tokenizer, tinh chỉnh predictor và backtest.

Bạn có thể dùng phần này để nghiên cứu mô hình trên một nguồn dữ liệu hoặc nhóm tài sản riêng. Tuy nhiên, đây không phải bộ công cụ tự động biến dự báo thành hệ thống giao dịch hoàn chỉnh. README cảnh báo rằng chiến lược top-K trong ví dụ chỉ là điểm bắt đầu.

## 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 trong `requirements.txt` bằng pip.

Dữ liệu đầu vào cho dự báo phải là một pandas DataFrame có tối thiểu các cột `open`, `high`, `low` và `close`. Hai cột `volume` và `amount` là tùy chọn. Bạn cũng cần một pandas Series chứa timestamp lịch sử và một pandas Series chứa timestamp tương lai muốn dự báo.

Các model và tokenizer mẫu được tải từ Hugging Face Hub bằng tên như `NeoQuasar/Kronos-Tokenizer-base` và `NeoQuasar/Kronos-small`. Vì vậy, máy chạy cần có khả năng tải các model này theo cách mà thư viện trong repo hỗ trợ.

Nếu muốn chạy pipeline tinh chỉnh, bạn cần cài thêm Qlib bằng gói `pyqlib`, chuẩn bị dữ liệu Qlib cục bộ và sửa các đường dẫn trong `finetune/config.py`. README cũng mô tả các script huấn luyện là dành cho nhiều GPU và dùng `torchrun`.

README không nêu yêu cầu cụ thể về hệ điều hành, dung lượng RAM, loại GPU hoặc dung lượng ổ đĩa. README cũng không yêu cầu API key riêng cho ví dụ dự báo. Nếu dùng Comet.ml trong pipeline tinh chỉnh, bạn có thể tắt bằng cách đặt `use_comet = False` theo hướng dẫn.

```note
Kronos chỉ tạo dự báo từ dữ liệu thị trường. Không nên xem dự báo là tín hiệu mua bán chắc chắn. Pipeline backtest trong repo là ví dụ đơn giản, chưa mô phỏng đầy đủ phí giao dịch, trượt giá, tác động thị trường, quản trị rủi ro hoặc phân bổ danh mục.
```

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

```steps
- Chuẩn bị Python | Cài Python 3.10 trở lên và mở terminal
- Lấy mã nguồn | Clone repo rồi chuyển vào thư mục Kronos
- Cài thư viện | Chạy pip install với requirements.txt
- Tải model | Khởi tạo tokenizer và model từ Hugging Face Hub
- Chạy dự báo | Chuẩn bị DataFrame, timestamp và gọi predictor.predict
```

### Chuẩn bị thư mục 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 clone phổ thông sau:

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

Lệnh đầu tiên tải mã nguồn về máy. Lệnh thứ hai chuyển terminal vào thư mục dự án. Người mới thường chạy `pip install` khi terminal đang ở thư mục khác, khiến đường dẫn `requirements.txt` không được tìm thấy. Hãy kiểm tra bạn đang đứng trong thư mục có các mục như `README.md`, `model/`, `examples/` và `requirements.txt`.

### Cài các thư viện phụ thuộc

README yêu cầu Python 3.10 trở lên và cài dependency như sau:

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

Lệnh này đọc danh sách trong `requirements.txt` rồi cài các thư viện cần cho repo. Nếu máy có nhiều bản Python, hãy chắc chắn `pip` đang gắn với Python 3.10 trở lên. README không đưa ra lệnh thay thế cho trường hợp nhiều môi trường Python, nên bạn nên kiểm tra môi trường của mình trước khi xử lý lỗi pip.

Nếu chỉ muốn chạy pipeline tinh chỉnh, README yêu cầu cài thêm Qlib:

```bash
pip install pyqlib
```

Bạn không cần cài `pyqlib` nếu chỉ làm theo ví dụ dự báo cơ bản, trừ khi dependency hoặc phần việc của bạn yêu cầu nó. Trước khi tinh chỉnh, hãy chuẩn bị dữ liệu Qlib theo hướng dẫn chính thức của Qlib và đặt dữ liệu ở vị trí phù hợp.

### Tải tokenizer và model

Trong một file Python được chạy từ thư mục gốc của repo, dùng đoạn mã README cung cấp:

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

`KronosTokenizer` xử lý việc mã hóa dữ liệu nến. `Kronos` là model dự huấn luyện. Hai tên model phải tương ứng với các model được README cung cấp. Nếu tải model thất bại, hãy kiểm tra kết nối mạng, tên model và môi trường Python. README không nói rằng bạn cần API key riêng.

### Khởi tạo predictor

Sau khi có model và tokenizer, tạo predictor như sau:

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

`max_context=512` phù hợp với Kronos-small và Kronos-base theo README. Đây là độ dài chuỗi tối đa mà model có thể xử lý trong cấu hình này. Nếu `lookback` dài hơn, `KronosPredictor` sẽ tự xử lý việc cắt ngữ cảnh, nhưng README khuyến nghị không để độ dài dữ liệu đầu vào vượt giới hạn khi không cần thiết.

### Chuẩn bị dữ liệu đầu vào

README dùng file CSV mẫu và chuẩn hóa cột timestamp như sau:

```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']
```

`lookback` là số dòng lịch sử đưa vào model. `pred_len` là số mốc tương lai muốn dự báo. `x_df` lấy phần dữ liệu lịch sử, `x_timestamp` chứa thời gian tương ứng, còn `y_timestamp` chứa thời gian tương lai.

Bạn cần thay đường dẫn CSV bằng dữ liệu của mình. Tên cột phải đúng với yêu cầu. README chỉ nói `volume` và `amount` là tùy chọn ở phần mô tả API; nếu không có hai cột này, hãy xem thêm ví dụ không dùng volume và amount trong `examples/prediction_wo_vol_example.py`.

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

Gọi `predict` bằng đoạn mã 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à trung bình hóa theo mô tả trong README. Kết quả `pred_df` là pandas DataFrame có các giá trị dự báo cho `open`, `high`, `low`, `close`, `volume` và `amount`, với chỉ mục là các mốc trong `y_timestamp`.

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

Khi cần xử lý nhiều DataFrame, dùng đoạn mã README cung cấp:

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

Các DataFrame phải có cùng độ dài lịch sử và cùng `pred_len`. Mỗi DataFrame cần `open`, `high`, `low`, `close`; `volume` và `amount` có thể thiếu và sẽ được điền bằng số 0 theo README. Danh sách kết quả giữ nguyên thứ tự của dữ liệu đầu vào.

### Chạy ví dụ trực quan

README cho biết script hoàn chỉnh nằm ở `examples/prediction_example.py`. Script này gồm đọc dữ liệu, tạo dự báo và vẽ biểu đồ so sánh dữ liệu thực tế với dự báo. Nếu cần chạy ví dụ không có volume và amount, xem `examples/prediction_wo_vol_example.py`.

README không ghi một lệnh chạy cụ thể cho hai file ví dụ này. Vì vậy, hãy mở từng file để xem cách tác giả tổ chức dữ liệu và lệnh chạy tương ứng trong phiên bản repo bạn đã tải.

### Tinh chỉnh với dữ liệu Qlib

Trước tiên, mở `finetune/config.py` và sửa các đường dẫn `qlib_data_path`, `dataset_path`, `save_path`, `backtest_result_path`, `pretrained_tokenizer_path` và `pretrained_predictor_path`. Bạn cũng có thể điều chỉnh `instrument`, `train_time_range`, `epochs` và `batch_size`. Nếu không dùng Comet.ml, đặt `use_comet = False`.

Tiền xử lý dữ liệu:

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

Sau bước này, README cho biết các file `train_data.pkl`, `val_data.pkl` và `test_data.pkl` sẽ nằm trong thư mục `dataset_path`.

Tinh chỉnh tokenizer bằng số GPU bạn muốn dùng:

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

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

Trong hai lệnh trên, `NUM_GPUS` là chỗ giữ chỗ phải thay bằng số GPU thực tế. README mô tả các script này dành cho huấn luyện nhiều GPU, nên đây không phải quy trình nhẹ dành cho máy văn phòng thông thường.

Chạy backtest trên GPU chỉ định:

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

Script sẽ phân tích hiệu năng trong console và tạo biểu đồ đường cong lợi nhuận tích lũy của chiến lược so với benchmark theo mô tả của README.

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

Với cài đặt cơ bản, dấu hiệu đầu tiên là lệnh `pip install -r requirements.txt` hoàn tất mà không có lỗi dependency nghiêm trọng.

Khi chạy đoạn tải model, tokenizer và model phải được tạo thành công. Sau đó, lời gọi `predictor.predict` phải trả về một pandas DataFrame. Lệnh:

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

sẽ in phần đầu của kết quả dự báo. Kết quả mong đợi có các trường `open`, `high`, `low`, `close`, `volume` và `amount`, cùng chỉ mục theo `y_timestamp`.

Với `predict_batch`, bạn cần nhận được danh sách DataFrame theo đúng thứ tự của `df_list`. Với ví dụ trực quan, dấu hiệu thành công là script tạo biểu đồ so sánh dữ liệu ground truth với forecast.

Với pipeline tinh chỉnh, kiểm tra thư mục được khai báo trong `dataset_path` có ba file pickle sau tiền xử lý. Sau huấn luyện, checkpoint tốt nhất được lưu theo các đường dẫn suy ra từ `save_path` trong `config.py`. Khi chạy backtest, console phải in phân tích hiệu năng và script tạo biểu đồ đường cong lợi nhuận tích lũy.

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

### Chủ shop muốn theo dõi xu hướng nhu cầu

Chủ shop có thể lưu dữ liệu doanh số theo từng khoảng thời gian vào DataFrame có cấu trúc tương tự chuỗi nến, rồi thử nghiệm cách chuẩn bị dữ liệu và dự báo. Tuy nhiên, Kronos được thiết kế cho K-line tài chính, nên không nên tự động coi dữ liệu doanh số là dữ liệu tương thích nếu chưa kiểm tra logic của repo.

Cách dùng thực tế hơn là một lập trình viên trong nhóm lấy dữ liệu của mã tài sản cần theo dõi, tạo `x_df`, `x_timestamp`, `y_timestamp`, rồi gọi `predict`. Kết quả có thể đưa vào dashboard nội bộ để tham khảo xu hướng, thay vì dùng làm lệnh giao dịch tự động.

### Nhân viên phân tích cần dự báo một mã tài sản

Nhân viên phân tích có thể dùng CSV lịch sử với các cột `open`, `high`, `low`, `close`, `volume` và `amount`. Sau khi chọn `lookback` và `pred_len`, họ chạy predictor để nhận `pred_df`, rồi so sánh các cột dự báo với dữ liệu thực tế khi dữ liệu tương lai đã xuất hiện.

Ví dụ, dùng `lookback = 400` và `pred_len = 120` như README. Người phân tích có thể điều chỉnh `T`, `top_p` và `sample_count` để thử các thiết lập lấy mẫu khác nhau, nhưng cần đánh giá bằng dữ liệu ngoài mẫu thay vì chỉ nhìn một biểu đồ đẹp.

### Dev xây dashboard cho nhiều tài sản

Dev có thể gom nhiều DataFrame vào `df_list`, các timestamp lịch sử vào `x_timestamp_list` và timestamp tương lai vào `y_timestamp_list`. Sau đó dùng `predict_batch` để tạo dự báo cho nhiều chuỗi trong cùng một quy trình.

Cần bảo đảm mọi chuỗi có cùng độ dài lịch sử và cùng độ dài dự báo. Kết quả trả về cùng thứ tự đầu vào, nên dev có thể ghép kết quả với mã tài sản tương ứng trước khi hiển thị trên dashboard.

### Nhóm định lượng muốn thử mô hình trên dữ liệu riêng

Nhóm định lượng có thể dùng pipeline Qlib trong `finetune/`. Họ chuẩn bị dữ liệu Qlib, sửa cấu hình, chạy tiền xử lý, tinh chỉnh tokenizer, tinh chỉnh predictor rồi chạy backtest.

Kết quả backtest nên được xem là kết quả nghiên cứu ban đầu. README khuyến nghị quy trình production cần thêm tối ưu danh mục, trung hòa yếu tố rủi ro, định cỡ vị thế, quản trị rủi ro, phí giao dịch, trượt giá và tác động thị trường.

> Dự báo là nguyên liệu cho phân tích, không phải lời hứa về lợi nhuận.
>
> — Ông T

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

### Python hoặc dependency không đúng phiên bản

README yêu cầu Python 3.10 trở lên. Nếu pip báo lỗi khi cài, hãy kiểm tra phiên bản Python và chắc chắn terminal đang dùng đúng môi trường. Không nên tự ý đổi tên package trong `requirements.txt` khi chưa biết nguyên nhân.

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

Lỗi này thường xảy ra khi terminal không ở thư mục gốc của repo. Hãy chuyển vào thư mục `Kronos`, nơi có `README.md`, `model/` và `requirements.txt`, rồi chạy lại lệnh cài đặt.

### DataFrame thiếu cột bắt buộc

`predict` cần `open`, `high`, `low` và `close`. Nếu thiếu một trong các cột này, hãy sửa bước đọc và đổi tên dữ liệu trước khi gọi predictor. `volume` và `amount` là tùy chọn; README có thêm ví dụ riêng không dùng hai cột này.

### Vượt quá context length

Kronos-small và Kronos-base có `max_context` là 512. Nếu `lookback` dài hơn, predictor sẽ tự xử lý việc cắt ngữ cảnh, nhưng README khuyến nghị giữ input không vượt giới hạn khi có thể. Bạn nên chọn `lookback` phù hợp và ghi lại thiết lập khi so sánh kết quả.

### Chạy tinh chỉnh nhưng chưa chuẩn bị Qlib hoặc GPU

Pipeline tinh chỉnh cần Qlib, dữ liệu Qlib cục bộ, cấu hình đường dẫn và các lệnh `torchrun` cho nhiều GPU. Nếu chỉ có máy CPU hoặc chưa có dữ liệu Qlib, hãy bắt đầu bằng dự báo với model có sẵn. Không nên coi lệnh backtest mẫu là bằng chứng mô hình đã sẵn sàng giao dịch.

### Tin quá mức vào kết quả backtest

README cảnh báo chiến lược top-K chỉ là ví dụ đơn giản. Backtest có thể bỏ sót phí giao dịch, trượt giá, tác động thị trường và nhiều yếu tố quản trị rủi ro. Hãy xem đây là bước đánh giá kỹ thuật, không phải cơ sở duy nhất để quyết định đầu tư.

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

Kronos đáng thử nếu bạn muốn nghiên cứu mô hình nền tảng cho dữ liệu nến, cần một ví dụ Python có sẵn từ đọc dữ liệu đến dự báo, hoặc muốn tinh chỉnh một model trên pipeline Qlib. Repo có model zoo với nhiều kích thước, hỗ trợ dự báo đơn lẻ và batch, đồng thời có mã nguồn cho tokenizer, predictor, ví dụ và backtest.

Điểm mạnh khác là phần sử dụng cơ bản khá trực tiếp. Bạn cài dependency, tải tokenizer và model, tạo `KronosPredictor`, chuẩn bị DataFrame rồi gọi `predict`. Kết quả trả về ở dạng pandas DataFrame nên dễ nối với quy trình phân tích Python.

Giới hạn nằm ở chỗ mô hình không thay thế dữ liệu sạch, đánh giá ngoài mẫu hay hệ thống quản trị rủi ro. Pipeline tinh chỉnh được README mô tả là bản minh họa, cần Qlib và nhiều GPU. Repo cũng đã lâu chưa cập nhật, nên có thể phát sinh vấn đề tương thích với môi trường mới mà README chưa giải thích.

Bạn nên chọn Kronos nếu mục tiêu là học, nghiên cứu hoặc xây dựng prototype dự báo. Nếu cần một hệ thống giao dịch production, dữ liệu thời gian thực, quản lý lệnh, kiểm soát rủi ro và giám sát vận hành, bạn sẽ cần bổ sung nhiều thành phần khác hoặc chọn một nền tảng chuyên biệt hơn.

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

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

Repo dùng giấy phép MIT. README không nêu chi phí sử dụng các model trên Hugging Face Hub, nên bạn nên kiểm tra điều khoản của từng model trước khi triển khai thương mại.

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

README mô tả `predict_batch` tận dụng GPU và pipeline tinh chỉnh dùng `torchrun` cho nhiều GPU. README không khẳng định dự báo đơn lẻ bắt buộc phải có GPU.

### 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ụ thể. Vì vậy chưa có thông tin chính thức trong tư liệu để khẳng định quy trình Windows được hỗ trợ đầy đủ.

### Có cần API key để chạy model không?

README không yêu cầu API key riêng trong ví dụ dự báo. Model và tokenizer được tải bằng tên 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` và `close`. `volume` và `amount` là tùy chọn; README nói chúng sẽ được điền bằng số 0 khi dùng batch prediction mà bị thiếu.

### Kronos có phải hệ thống giao dịch tự động không?

Không. Kronos tạo dự báo và repo có một ví dụ backtest đơn giản, nhưng README nói pipeline này chưa phải hệ thống giao dịch production.

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

Kronos-small có 24.7M tham số, còn Kronos-base có 102.3M tham số. Cả hai được README liệt kê với context length 512.
