Deploy to Hugging Face with LFS

.gitattributes

@@ -0,0 +1,3 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.db filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+venv/
+__pycache__/
+*.pyc
+.env
+.DS_Store
+*.db

Kronos-master/.gitignore

@@ -0,0 +1,76 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+
+# Linux
+*~
+
+# Data files (large files)
+*.feather
+*.parquet
+*.h5
+*.hdf5
+
+# Model files (large files)
+*.pth
+*.pt
+*.ckpt
+*.bin
+
+# Logs
+*.log
+logs/
+
+# Environment
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Temporary files
+*.tmp
+*.temp
+temp/
+tmp/
+.python-version

Kronos-master/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ShiYu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Kronos-master/README.md

@@ -0,0 +1,337 @@
+<div align="center">
+  <h2><b>Kronos: A Foundation Model for the Language of Financial Markets </b></h2>
+</div>
+
+
+<div align="center">
+
+</a> 
+<a href="https://huggingface.co/NeoQuasar"> 
+<img src="https://img.shields.io/badge/🤗-Hugging_Face-yellow" alt="Hugging Face"> 
+</a> 
+<a href="https://shiyu-coder.github.io/Kronos-demo/"> <img src="https://img.shields.io/badge/🚀-Live_Demo-brightgreen" alt="Live Demo"> </a>
+<a href="https://github.com/shiyu-coder/Kronos/graphs/commit-activity"> 
+<img src="https://img.shields.io/github/last-commit/shiyu-coder/Kronos?color=blue" alt="Last Commit"> 
+</a> 
+<a href="https://github.com/shiyu-coder/Kronos/stargazers"> 
+<img src="https://img.shields.io/github/stars/shiyu-coder/Kronos?color=lightblue" alt="GitHub Stars"> 
+</a> 
+<a href="https://github.com/shiyu-coder/Kronos/network/members"> 
+<img src="https://img.shields.io/github/forks/shiyu-coder/Kronos?color=yellow" alt="GitHub Forks"> 
+</a> 
+<a href="./LICENSE"> 
+<img src="https://img.shields.io/github/license/shiyu-coder/Kronos?color=green" alt="License"> 
+</a>
+
+</div>
+
+<div align="center">
+  <!-- Keep these links. Translations will automatically update with the README. -->
+  <a href="https://zdoc.app/de/shiyu-coder/Kronos">Deutsch</a> | 
+  <a href="https://zdoc.app/es/shiyu-coder/Kronos">Español</a> | 
+  <a href="https://zdoc.app/fr/shiyu-coder/Kronos">Français</a> | 
+  <a href="https://zdoc.app/ja/shiyu-coder/Kronos">日本語</a> | 
+  <a href="https://zdoc.app/ko/shiyu-coder/Kronos">한국어</a> | 
+  <a href="https://zdoc.app/pt/shiyu-coder/Kronos">Português</a> | 
+  <a href="https://zdoc.app/ru/shiyu-coder/Kronos">Русский</a> | 
+  <a href="https://zdoc.app/zh/shiyu-coder/Kronos">中文</a>
+</div>
+
+<p align="center">
+
+<img src="./figures/logo.png" width="100">
+
+</p>
+
+> Kronos is the **first open-source foundation model** for financial candlesticks (K-lines), 
+> trained on data from over **45 global exchanges**.
+
+
+</div>
+
+## 📰 News
+*   🚩 **[2025.11.10]** Kronos has been accpeted by AAAI 2026.
+*   🚩 **[2025.08.17]** We have released the scripts for fine-tuning! Check them out to adapt Kronos to your own tasks.
+*   🚩 **[2025.08.02]** Our paper is now available on [arXiv](https://arxiv.org/abs/2508.02739)!
+
+<p align="center">
+
+## 📜 Introduction
+
+**Kronos** is a family of decoder-only foundation models, pre-trained specifically for the "language" of financial markets—K-line sequences. Unlike general-purpose TSFMs, Kronos is designed to handle the unique, high-noise characteristics of financial data. It leverages a novel two-stage framework: 
+1. A specialized tokenizer first quantizes continuous, multi-dimensional K-line data (OHLCV) into **hierarchical discrete tokens**. 
+2. A large, autoregressive Transformer is then pre-trained on these tokens, enabling it to serve as a unified model for diverse quantitative tasks.
+
+<p align="center">
+    <img src="figures/overview.png" alt="" align="center" width="700px" />
+</p>
+
+## ✨ Live Demo 
+We have set up a live demo to visualize Kronos's forecasting results. The webpage showcases a forecast for the **BTC/USDT** trading pair over the next 24 hours. 
+
+**👉 [Access the Live Demo Here](https://shiyu-coder.github.io/Kronos-demo/)** 
+
+## 📦 Model Zoo 
+We release a family of pre-trained models with varying capacities to suit different computational and application needs. All models are readily accessible from the Hugging Face Hub.
+
+| Model        | Tokenizer                                                                       | Context length | Params  | Open-source                                                               |
+|--------------|---------------------------------------------------------------------------------| -------------- | ------ |---------------------------------------------------------------------------|
+| Kronos-mini  | [Kronos-Tokenizer-2k](https://huggingface.co/NeoQuasar/Kronos-Tokenizer-2k)     | 2048           | 4.1M   | ✅ [NeoQuasar/Kronos-mini](https://huggingface.co/NeoQuasar/Kronos-mini)  |
+| Kronos-small | [Kronos-Tokenizer-base](https://huggingface.co/NeoQuasar/Kronos-Tokenizer-base) | 512            | 24.7M  | ✅ [NeoQuasar/Kronos-small](https://huggingface.co/NeoQuasar/Kronos-small) |
+| Kronos-base  | [Kronos-Tokenizer-base](https://huggingface.co/NeoQuasar/Kronos-Tokenizer-base) | 512            | 102.3M | ✅ [NeoQuasar/Kronos-base](https://huggingface.co/NeoQuasar/Kronos-base)   |
+| Kronos-large | [Kronos-Tokenizer-base](https://huggingface.co/NeoQuasar/Kronos-Tokenizer-base) | 512            | 499.2M | ❌                                                                         |
+
+
+## 🚀 Getting Started
+
+### Installation
+
+1. Install Python 3.10+, and then install the dependencies:
+
+```shell
+pip install -r requirements.txt
+```
+
+### 📈 Making Forecasts
+
+Forecasting with Kronos is straightforward using the `KronosPredictor` class. It handles data preprocessing, normalization, prediction, and inverse normalization, allowing you to get from raw data to forecasts in just a few lines of code.
+
+**Important Note**: The `max_context` for `Kronos-small` and `Kronos-base` is **512**. This is the maximum sequence length the model can process. For optimal performance, it is recommended that your input data length (i.e., `lookback`) does not exceed this limit. The `KronosPredictor` will automatically handle truncation for longer contexts.
+
+Here is a step-by-step guide to making your first forecast.
+
+#### 1. Load the Tokenizer and Model
+
+First, load a pre-trained Kronos model and its corresponding tokenizer from the Hugging Face Hub.
+
+```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")
+```
+
+#### 2. Instantiate the Predictor
+
+Create an instance of `KronosPredictor`, passing the model, tokenizer, and desired device.
+
+```python
+# Initialize the predictor
+predictor = KronosPredictor(model, tokenizer, max_context=512)
+```
+
+#### 3. Prepare Input Data
+
+The `predict` method requires three main inputs:
+-   `df`: A pandas DataFrame containing the historical K-line data. It must include columns `['open', 'high', 'low', 'close']`. `volume` and `amount` are optional.
+-   `x_timestamp`: A pandas Series of timestamps corresponding to the historical data in `df`.
+-   `y_timestamp`: A pandas Series of timestamps for the future periods you want to predict.
+
+```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']
+```
+
+#### 4. Generate Forecasts 
+
+Call the `predict` method to generate forecasts. You can control the sampling process with parameters like `T`, `top_p`, and `sample_count` for probabilistic forecasting.
+
+```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())
+```
+
+The `predict` method returns a pandas DataFrame containing the forecasted values for `open`, `high`, `low`, `close`, `volume`, and `amount`, indexed by the `y_timestamp` you provided.
+
+For efficient processing of multiple time series, Kronos provides a `predict_batch` method that enables parallel prediction on multiple datasets simultaneously. This is particularly useful when you need to forecast multiple assets or time periods at once.
+
+```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())
+```
+
+**Important Requirements for Batch Prediction:**
+- All series must have the same historical length (lookback window)
+- All series must have the same prediction length (`pred_len`)
+- Each DataFrame must contain the required columns: `['open', 'high', 'low', 'close']`
+- `volume` and `amount` columns are optional and will be filled with zeros if missing
+
+The `predict_batch` method leverages GPU parallelism for efficient processing and automatically handles normalization and denormalization for each series independently.
+
+#### 5. Example and Visualization
+
+For a complete, runnable script that includes data loading, prediction, and plotting, please see [`examples/prediction_example.py`](examples/prediction_example.py).
+
+Running this script will generate a plot comparing the ground truth data against the model's forecast, similar to the one shown below:
+
+<p align="center">
+    <img src="figures/prediction_example.png" alt="Forecast Example" align="center" width="600px" />
+</p>
+
+Additionally, we provide a script that makes predictions without Volume and Amount data, which can be found in [`examples/prediction_wo_vol_example.py`](examples/prediction_wo_vol_example.py).
+
+
+## 🔧 Finetuning on Your Own Data (A-Share Market Example)
+
+We provide a complete pipeline for finetuning Kronos on your own datasets. As an example, we demonstrate how to use [Qlib](https://github.com/microsoft/qlib) to prepare data from the Chinese A-share market and conduct a simple backtest.
+
+> **Disclaimer:** This pipeline is intended as a demonstration to illustrate the finetuning process. It is a simplified example and not a production-ready quantitative trading system. A robust quantitative strategy requires more sophisticated techniques, such as portfolio optimization and risk factor neutralization, to achieve stable alpha.
+
+The finetuning process is divided into four main steps:
+
+1.  **Configuration**: Set up paths and hyperparameters.
+2.  **Data Preparation**: Process and split your data using Qlib.
+3.  **Model Finetuning**: Finetune the Tokenizer and the Predictor models.
+4.  **Backtesting**: Evaluate the finetuned model's performance.
+
+### Prerequisites
+
+1.  First, ensure you have all dependencies from `requirements.txt` installed.
+2.  This pipeline relies on `qlib`. Please install it:
+    ```shell
+      pip install pyqlib
+    ```
+3.  You will need to prepare your Qlib data. Follow the [official Qlib guide](https://github.com/microsoft/qlib) to download and set up your data locally. The example scripts assume you are using daily frequency data.
+
+### Step 1: Configure Your Experiment
+
+All settings for data, training, and model paths are centralized in `finetune/config.py`. Before running any scripts, please **modify the following paths** according to your environment:
+
+*   `qlib_data_path`: Path to your local Qlib data directory.
+*   `dataset_path`: Directory where the processed train/validation/test pickle files will be saved.
+*   `save_path`: Base directory for saving model checkpoints.
+*   `backtest_result_path`: Directory for saving backtesting results.
+*   `pretrained_tokenizer_path` and `pretrained_predictor_path`: Paths to the pre-trained models you want to start from (can be local paths or Hugging Face model names).
+
+You can also adjust other parameters like `instrument`, `train_time_range`, `epochs`, and `batch_size` to fit your specific task. If you don't use [Comet.ml](https://www.comet.com/), set `use_comet = False`.
+
+### Step 2: Prepare the Dataset
+
+Run the data preprocessing script. This script will load raw market data from your Qlib directory, process it, split it into training, validation, and test sets, and save them as pickle files.
+
+```shell
+python finetune/qlib_data_preprocess.py
+```
+
+After running, you will find `train_data.pkl`, `val_data.pkl`, and `test_data.pkl` in the directory specified by `dataset_path` in your config.
+
+### Step 3: Run the Finetuning
+
+The finetuning process consists of two stages: finetuning the tokenizer and then the predictor. Both training scripts are designed for multi-GPU training using `torchrun`.
+
+#### 3.1 Finetune the Tokenizer
+
+This step adjusts the tokenizer to the data distribution of your specific domain.
+
+```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
+```
+
+The best tokenizer checkpoint will be saved to the path configured in `config.py` (derived from `save_path` and `tokenizer_save_folder_name`).
+
+#### 3.2 Finetune the Predictor
+
+This step finetunes the main Kronos model for the forecasting task.
+
+```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
+```
+
+The best predictor checkpoint will be saved to the path configured in `config.py`.
+
+### Step 4: Evaluate with Backtesting
+
+Finally, run the backtesting script to evaluate your finetuned model. This script loads the models, performs inference on the test set, generates prediction signals (e.g., forecasted price change), and runs a simple top-K strategy backtest.
+
+```shell
+# Specify the GPU for inference
+python finetune/qlib_test.py --device cuda:0
+```
+
+The script will output a detailed performance analysis in your console and generate a plot showing the cumulative return curves of your strategy against the benchmark, similar to the one below:
+
+<p align="center">
+    <img src="figures/backtest_result_example.png" alt="Backtest Example" align="center" width="700px" />
+</p>
+
+### 💡 From Demo to Production: Important Considerations
+
+*   **Raw Signals vs. Pure Alpha**: The signals generated by the model in this demo are raw predictions. In a real-world quantitative workflow, these signals would typically be fed into a portfolio optimization model. This model would apply constraints to neutralize exposure to common risk factors (e.g., market beta, style factors like size and value), thereby isolating the **"pure alpha"** and improving the strategy's robustness.
+*   **Data Handling**: The provided `QlibDataset` is an example. For different data sources or formats, you will need to adapt the data loading and preprocessing logic.
+*   **Strategy and Backtesting Complexity**: The simple top-K strategy used here is a basic starting point. Production-level strategies often incorporate more complex logic for portfolio construction, dynamic position sizing, and risk management (e.g., stop-loss/take-profit rules). Furthermore, a high-fidelity backtest should meticulously model transaction costs, slippage, and market impact to provide a more accurate estimate of real-world performance.
+
+> **📝 AI-Generated Comments**: Please note that many of the code comments within the `finetune/` directory were generated by an AI assistant (Gemini 2.5 Pro) for explanatory purposes. While they aim to be helpful, they may contain inaccuracies. We recommend treating the code itself as the definitive source of logic.
+
+## 📖 Citation
+
+If you use Kronos in your research, we would appreciate a citation to our [paper](https://arxiv.org/abs/2508.02739):
+
+```
+@misc{shi2025kronos,
+      title={Kronos: A Foundation Model for the Language of Financial Markets}, 
+      author={Yu Shi and Zongliang Fu and Shuo Chen and Bohan Zhao and Wei Xu and Changshui Zhang and Jian Li},
+      year={2025},
+      eprint={2508.02739},
+      archivePrefix={arXiv},
+      primaryClass={q-fin.ST},
+      url={https://arxiv.org/abs/2508.02739}, 
+}
+```
+
+## 📜 License 
+This project is licensed under the [MIT License](./LICENSE).
+
+
+
+
+
+
+
+
+
+

Kronos-master/model/__init__.py

@@ -0,0 +1,17 @@
+from .kronos import KronosTokenizer, Kronos, KronosPredictor
+
+model_dict = {
+    'kronos_tokenizer': KronosTokenizer,
+    'kronos': Kronos,
+    'kronos_predictor': KronosPredictor
+}
+
+
+def get_model_class(model_name):
+    if model_name in model_dict:
+        return model_dict[model_name]
+    else:
+        print(f"Model {model_name} not found in model_dict")
+        raise NotImplementedError
+
+

Kronos-master/model/kronos.py

@@ -0,0 +1,664 @@
+import numpy as np
+import pandas as pd
+import torch
+from huggingface_hub import PyTorchModelHubMixin
+import sys
+
+from tqdm import trange
+
+sys.path.append("../")
+from model.module import *
+
+
+class KronosTokenizer(nn.Module, PyTorchModelHubMixin):
+    """
+    KronosTokenizer module for tokenizing input data using a hybrid quantization approach.
+
+    This tokenizer utilizes a combination of encoder and decoder Transformer blocks
+    along with the Binary Spherical Quantization (BSQuantizer) to compress and decompress input data.
+
+    Args:
+           d_in (int): Input dimension.
+           d_model (int): Model dimension.
+           n_heads (int): Number of attention heads.
+           ff_dim (int): Feed-forward dimension.
+           n_enc_layers (int): Number of encoder layers.
+           n_dec_layers (int): Number of decoder layers.
+           ffn_dropout_p (float): Dropout probability for feed-forward networks.
+           attn_dropout_p (float): Dropout probability for attention mechanisms.
+           resid_dropout_p (float): Dropout probability for residual connections.
+           s1_bits (int): Number of bits for the pre token in BSQuantizer.
+           s2_bits (int): Number of bits for the post token in BSQuantizer.
+           beta (float): Beta parameter for BSQuantizer.
+           gamma0 (float): Gamma0 parameter for BSQuantizer.
+           gamma (float): Gamma parameter for BSQuantizer.
+           zeta (float): Zeta parameter for BSQuantizer.
+           group_size (int): Group size parameter for BSQuantizer.
+
+    """
+
+    def __init__(self, d_in, d_model, n_heads, ff_dim, n_enc_layers, n_dec_layers, ffn_dropout_p, attn_dropout_p, resid_dropout_p, s1_bits, s2_bits, beta, gamma0, gamma, zeta, group_size):
+
+        super().__init__()
+        self.d_in = d_in
+        self.d_model = d_model
+        self.n_heads = n_heads
+        self.ff_dim = ff_dim
+        self.enc_layers = n_enc_layers
+        self.dec_layers = n_dec_layers
+        self.ffn_dropout_p = ffn_dropout_p
+        self.attn_dropout_p = attn_dropout_p
+        self.resid_dropout_p = resid_dropout_p
+
+        self.s1_bits = s1_bits
+        self.s2_bits = s2_bits
+        self.codebook_dim = s1_bits + s2_bits # Total dimension of the codebook after quantization
+        self.embed = nn.Linear(self.d_in, self.d_model)
+        self.head = nn.Linear(self.d_model, self.d_in)
+
+        # Encoder Transformer Blocks
+        self.encoder = nn.ModuleList([
+            TransformerBlock(self.d_model, self.n_heads, self.ff_dim, self.ffn_dropout_p, self.attn_dropout_p, self.resid_dropout_p)
+            for _ in range(self.enc_layers - 1)
+        ])
+        # Decoder Transformer Blocks
+        self.decoder = nn.ModuleList([
+            TransformerBlock(self.d_model, self.n_heads, self.ff_dim, self.ffn_dropout_p, self.attn_dropout_p, self.resid_dropout_p)
+            for _ in range(self.dec_layers - 1)
+        ])
+        self.quant_embed = nn.Linear(in_features=self.d_model, out_features=self.codebook_dim) # Linear layer before quantization
+        self.post_quant_embed_pre = nn.Linear(in_features=self.s1_bits, out_features=self.d_model) # Linear layer after quantization (pre part - s1 bits)
+        self.post_quant_embed = nn.Linear(in_features=self.codebook_dim, out_features=self.d_model) # Linear layer after quantization (full codebook)
+        self.tokenizer = BSQuantizer(self.s1_bits, self.s2_bits, beta, gamma0, gamma, zeta, group_size) # BSQuantizer module
+
+    def forward(self, x):
+        """
+        Forward pass of the KronosTokenizer.
+
+        Args:
+            x (torch.Tensor): Input tensor of shape (batch_size, seq_len, d_in).
+
+        Returns:
+            tuple: A tuple containing:
+                - tuple: (z_pre, z) - Reconstructed outputs from decoder with s1_bits and full codebook respectively,
+                         both of shape (batch_size, seq_len, d_in).
+                - torch.Tensor: bsq_loss - Loss from the BSQuantizer.
+                - torch.Tensor: quantized - Quantized representation from BSQuantizer.
+                - torch.Tensor: z_indices - Indices from the BSQuantizer.
+        """
+        z = self.embed(x)
+
+        for layer in self.encoder:
+            z = layer(z)
+
+        z = self.quant_embed(z) # (B, T, codebook)
+
+        bsq_loss, quantized, z_indices = self.tokenizer(z)
+
+        quantized_pre = quantized[:, :, :self.s1_bits] # Extract the first part of quantized representation (s1_bits)
+        z_pre = self.post_quant_embed_pre(quantized_pre)
+
+        z = self.post_quant_embed(quantized)
+
+        # Decoder layers (for pre part - s1 bits)
+        for layer in self.decoder:
+            z_pre = layer(z_pre)
+        z_pre = self.head(z_pre)
+
+        # Decoder layers (for full codebook)
+        for layer in self.decoder:
+            z = layer(z)
+        z = self.head(z)
+
+        return (z_pre, z), bsq_loss, quantized, z_indices
+
+    def indices_to_bits(self, x, half=False):
+        """
+        Converts indices to bit representations and scales them.
+
+        Args:
+            x (torch.Tensor): Indices tensor.
+            half (bool, optional): Whether to process only half of the codebook dimension. Defaults to False.
+
+        Returns:
+            torch.Tensor: Bit representation tensor.
+        """
+        if half:
+            x1 = x[0] # Assuming x is a tuple of indices if half is True
+            x2 = x[1]
+            mask = 2 ** torch.arange(self.codebook_dim//2, device=x1.device, dtype=torch.long) # Create a mask for bit extraction
+            x1 = (x1.unsqueeze(-1) & mask) != 0 # Extract bits for the first half
+            x2 = (x2.unsqueeze(-1) & mask) != 0 # Extract bits for the second half
+            x = torch.cat([x1, x2], dim=-1) # Concatenate the bit representations
+        else:
+            mask = 2 ** torch.arange(self.codebook_dim, device=x.device, dtype=torch.long) # Create a mask for bit extraction
+            x = (x.unsqueeze(-1) & mask) != 0 # Extract bits
+
+        x = x.float() * 2 - 1 # Convert boolean to bipolar (-1, 1)
+        q_scale = 1. / (self.codebook_dim ** 0.5) # Scaling factor
+        x = x * q_scale
+        return x
+
+    def encode(self, x, half=False):
+        """
+        Encodes the input data into quantized indices.
+
+        Args:
+            x (torch.Tensor): Input tensor of shape (batch_size, seq_len, d_in).
+            half (bool, optional): Whether to use half quantization in BSQuantizer. Defaults to False.
+
+        Returns:
+            torch.Tensor: Quantized indices from BSQuantizer.
+        """
+        z = self.embed(x)
+        for layer in self.encoder:
+            z = layer(z)
+        z = self.quant_embed(z)
+
+        bsq_loss, quantized, z_indices = self.tokenizer(z, half=half, collect_metrics=False)
+        return z_indices
+
+    def decode(self, x, half=False):
+        """
+        Decodes quantized indices back to the input data space.
+
+        Args:
+            x (torch.Tensor): Quantized indices tensor.
+            half (bool, optional): Whether the indices were generated with half quantization. Defaults to False.
+
+        Returns:
+            torch.Tensor: Reconstructed output tensor of shape (batch_size, seq_len, d_in).
+        """
+        quantized = self.indices_to_bits(x, half)
+        z = self.post_quant_embed(quantized)
+        for layer in self.decoder:
+            z = layer(z)
+        z = self.head(z)
+        return z
+
+
+class Kronos(nn.Module, PyTorchModelHubMixin):
+    """
+    Kronos Model.
+
+    Args:
+        s1_bits (int): Number of bits for pre tokens.
+        s2_bits (int): Number of bits for post tokens.
+        n_layers (int): Number of Transformer blocks.
+        d_model (int): Dimension of the model's embeddings and hidden states.
+        n_heads (int): Number of attention heads in the MultiheadAttention layers.
+        ff_dim (int): Dimension of the feedforward network in the Transformer blocks.
+        ffn_dropout_p (float): Dropout probability for the feedforward network.
+        attn_dropout_p (float): Dropout probability for the attention layers.
+        resid_dropout_p (float): Dropout probability for residual connections.
+        token_dropout_p (float): Dropout probability for token embeddings.
+        learn_te (bool): Whether to use learnable temporal embeddings.
+    """
+
+    def __init__(self, s1_bits, s2_bits, n_layers, d_model, n_heads, ff_dim, ffn_dropout_p, attn_dropout_p, resid_dropout_p, token_dropout_p, learn_te):
+        super().__init__()
+        self.s1_bits = s1_bits
+        self.s2_bits = s2_bits
+        self.n_layers = n_layers
+        self.d_model = d_model
+        self.n_heads = n_heads
+        self.learn_te = learn_te
+        self.ff_dim = ff_dim
+        self.ffn_dropout_p = ffn_dropout_p
+        self.attn_dropout_p = attn_dropout_p
+        self.resid_dropout_p = resid_dropout_p
+        self.token_dropout_p = token_dropout_p
+
+        self.s1_vocab_size = 2 ** self.s1_bits
+        self.token_drop = nn.Dropout(self.token_dropout_p)
+        self.embedding = HierarchicalEmbedding(self.s1_bits, self.s2_bits, self.d_model)
+        self.time_emb = TemporalEmbedding(self.d_model, self.learn_te)
+        self.transformer = nn.ModuleList([
+            TransformerBlock(self.d_model, self.n_heads, self.ff_dim, self.ffn_dropout_p, self.attn_dropout_p, self.resid_dropout_p)
+            for _ in range(self.n_layers)
+        ])
+        self.norm = RMSNorm(self.d_model)
+        self.dep_layer = DependencyAwareLayer(self.d_model)
+        self.head = DualHead(self.s1_bits, self.s2_bits, self.d_model)
+        self.apply(self._init_weights)
+
+    def _init_weights(self, module):
+
+        if isinstance(module, nn.Linear):
+            nn.init.xavier_normal_(module.weight)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, mean=0, std=self.embedding.d_model ** -0.5)
+        elif isinstance(module, nn.LayerNorm):
+            nn.init.ones_(module.weight)
+            nn.init.zeros_(module.bias)
+        elif isinstance(module, RMSNorm):
+            nn.init.ones_(module.weight)
+
+    def forward(self, s1_ids, s2_ids, stamp=None, padding_mask=None, use_teacher_forcing=False, s1_targets=None):
+        """
+        Args:
+            s1_ids (torch.Tensor): Input tensor of s1 token IDs. Shape: [batch_size, seq_len]
+            s2_ids (torch.Tensor): Input tensor of s2 token IDs. Shape: [batch_size, seq_len]
+            stamp (torch.Tensor, optional): Temporal stamp tensor. Shape: [batch_size, seq_len]. Defaults to None.
+            padding_mask (torch.Tensor, optional): Mask for padding tokens. Shape: [batch_size, seq_len]. Defaults to None.
+            use_teacher_forcing (bool, optional): Whether to use teacher forcing for s1 decoding. Defaults to False.
+            s1_targets (torch.Tensor, optional): Target s1 token IDs for teacher forcing. Shape: [batch_size, seq_len]. Defaults to None.
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor]:
+                - s1 logits: Logits for s1 token predictions. Shape: [batch_size, seq_len, s1_vocab_size]
+                - s2_logits: Logits for s2 token predictions, conditioned on s1. Shape: [batch_size, seq_len, s2_vocab_size]
+        """
+        x = self.embedding([s1_ids, s2_ids])
+        if stamp is not None:
+            time_embedding = self.time_emb(stamp)
+            x = x + time_embedding
+        x = self.token_drop(x)
+
+        for layer in self.transformer:
+            x = layer(x, key_padding_mask=padding_mask)
+
+        x = self.norm(x)
+
+        s1_logits = self.head(x)
+
+        if use_teacher_forcing:
+            sibling_embed = self.embedding.emb_s1(s1_targets)
+        else:
+            s1_probs = F.softmax(s1_logits.detach(), dim=-1)
+            sample_s1_ids = torch.multinomial(s1_probs.view(-1, self.s1_vocab_size), 1).view(s1_ids.shape)
+            sibling_embed = self.embedding.emb_s1(sample_s1_ids)
+
+        x2 = self.dep_layer(x, sibling_embed, key_padding_mask=padding_mask) # Dependency Aware Layer: Condition on s1 embeddings
+        s2_logits = self.head.cond_forward(x2)
+        return s1_logits, s2_logits
+
+    def decode_s1(self, s1_ids, s2_ids, stamp=None, padding_mask=None):
+        """
+        Decodes only the s1 tokens.
+
+        This method performs a forward pass to predict only s1 tokens. It returns the s1 logits
+        and the context representation from the Transformer, which can be used for subsequent s2 decoding.
+
+        Args:
+            s1_ids (torch.Tensor): Input tensor of s1 token IDs. Shape: [batch_size, seq_len]
+            s2_ids (torch.Tensor): Input tensor of s2 token IDs. Shape: [batch_size, seq_len]
+            stamp (torch.Tensor, optional): Temporal stamp tensor. Shape: [batch_size, seq_len]. Defaults to None.
+            padding_mask (torch.Tensor, optional): Mask for padding tokens. Shape: [batch_size, seq_len]. Defaults to None.
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor]:
+                - s1 logits: Logits for s1 token predictions. Shape: [batch_size, seq_len, s1_vocab_size]
+                - context: Context representation from the Transformer. Shape: [batch_size, seq_len, d_model]
+        """
+        x = self.embedding([s1_ids, s2_ids])
+        if stamp is not None:
+            time_embedding = self.time_emb(stamp)
+            x = x + time_embedding
+        x = self.token_drop(x)
+
+        for layer in self.transformer:
+            x = layer(x, key_padding_mask=padding_mask)
+
+        x = self.norm(x)
+
+        s1_logits = self.head(x)
+        return s1_logits, x
+
+    def decode_s2(self, context, s1_ids, padding_mask=None):
+        """
+        Decodes the s2 tokens, conditioned on the context and s1 tokens.
+
+        This method decodes s2 tokens based on a pre-computed context representation (typically from `decode_s1`)
+        and the s1 token IDs. It uses the dependency-aware layer and the conditional s2 head to predict s2 tokens.
+
+        Args:
+            context (torch.Tensor): Context representation from the transformer (output of decode_s1).
+                                     Shape: [batch_size, seq_len, d_model]
+            s1_ids (torch.Tensor): Input tensor of s1 token IDs. Shape: [batch_size, seq_len]
+            padding_mask (torch.Tensor, optional): Mask for padding tokens. Shape: [batch_size, seq_len]. Defaults to None.
+
+        Returns:
+            torch.Tensor: s2 logits. Shape: [batch_size, seq_len, s2_vocab_size]
+        """
+        sibling_embed = self.embedding.emb_s1(s1_ids)
+        x2 = self.dep_layer(context, sibling_embed, key_padding_mask=padding_mask)
+        return self.head.cond_forward(x2)
+
+
+def top_k_top_p_filtering(
+        logits,
+        top_k: int = 0,
+        top_p: float = 1.0,
+        filter_value: float = -float("Inf"),
+        min_tokens_to_keep: int = 1,
+):
+    """Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
+    Args:
+        logits: logits distribution shape (batch size, vocabulary size)
+        if top_k > 0: keep only top k tokens with highest probability (top-k filtering).
+        if top_p < 1.0: keep the top tokens with cumulative probability >= top_p (nucleus filtering).
+            Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)
+        Make sure we keep at least min_tokens_to_keep per batch example in the output
+    From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
+    """
+    if top_k > 0:
+        top_k = min(max(top_k, min_tokens_to_keep), logits.size(-1))  # Safety check
+        # Remove all tokens with a probability less than the last token of the top-k
+        indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
+        logits[indices_to_remove] = filter_value
+        return logits
+
+    if top_p < 1.0:
+        sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+        cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+
+        # Remove tokens with cumulative probability above the threshold (token with 0 are kept)
+        sorted_indices_to_remove = cumulative_probs > top_p
+        if min_tokens_to_keep > 1:
+            # Keep at least min_tokens_to_keep (set to min_tokens_to_keep-1 because we add the first one below)
+            sorted_indices_to_remove[..., :min_tokens_to_keep] = 0
+        # Shift the indices to the right to keep also the first token above the threshold
+        sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+        sorted_indices_to_remove[..., 0] = 0
+
+        # scatter sorted tensors to original indexing
+        indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)
+        logits[indices_to_remove] = filter_value
+        return logits
+
+
+def sample_from_logits(logits, temperature=1.0, top_k=None, top_p=None, sample_logits=True):
+    logits = logits / temperature
+    if top_k is not None or top_p is not None:
+        if top_k > 0 or top_p < 1.0:
+            logits = top_k_top_p_filtering(logits, top_k=top_k, top_p=top_p)
+
+    probs = F.softmax(logits, dim=-1)
+
+    if not sample_logits:
+        _, x = torch.topk(probs, k=1, dim=-1)
+    else:
+        x = torch.multinomial(probs, num_samples=1)
+
+    return x
+
+
+def auto_regressive_inference(tokenizer, model, x, x_stamp, y_stamp, max_context, pred_len, clip=5, T=1.0, top_k=0, top_p=0.99, sample_count=5, verbose=False, return_samples=False):
+    with torch.no_grad():
+        x = torch.clip(x, -clip, clip)
+
+        device = x.device
+        x = x.unsqueeze(1).repeat(1, sample_count, 1, 1).reshape(-1, x.size(1), x.size(2)).to(device)
+        x_stamp = x_stamp.unsqueeze(1).repeat(1, sample_count, 1, 1).reshape(-1, x_stamp.size(1), x_stamp.size(2)).to(device)
+        y_stamp = y_stamp.unsqueeze(1).repeat(1, sample_count, 1, 1).reshape(-1, y_stamp.size(1), y_stamp.size(2)).to(device)
+
+        x_token = tokenizer.encode(x, half=True)
+        
+        initial_seq_len = x.size(1)
+        batch_size = x_token[0].size(0)
+        total_seq_len = initial_seq_len + pred_len
+        full_stamp = torch.cat([x_stamp, y_stamp], dim=1)
+
+        generated_pre = x_token[0].new_empty(batch_size, pred_len)
+        generated_post = x_token[1].new_empty(batch_size, pred_len)
+
+        pre_buffer = x_token[0].new_zeros(batch_size, max_context)
+        post_buffer = x_token[1].new_zeros(batch_size, max_context)
+        buffer_len = min(initial_seq_len, max_context)
+        if buffer_len > 0:
+            start_idx = max(0, initial_seq_len - max_context)
+            pre_buffer[:, :buffer_len] = x_token[0][:, start_idx:start_idx + buffer_len]
+            post_buffer[:, :buffer_len] = x_token[1][:, start_idx:start_idx + buffer_len]
+
+        if verbose:
+            ran = trange
+        else:
+            ran = range
+        for i in ran(pred_len):
+            current_seq_len = initial_seq_len + i
+            window_len = min(current_seq_len, max_context)
+
+            if current_seq_len <= max_context:
+                input_tokens = [
+                    pre_buffer[:, :window_len],
+                    post_buffer[:, :window_len]
+                ]
+            else:
+                input_tokens = [pre_buffer, post_buffer]
+
+            context_end = current_seq_len
+            context_start = max(0, context_end - max_context)
+            current_stamp = full_stamp[:, context_start:context_end, :].contiguous()
+
+            s1_logits, context = model.decode_s1(input_tokens[0], input_tokens[1], current_stamp)
+            s1_logits = s1_logits[:, -1, :]
+            sample_pre = sample_from_logits(s1_logits, temperature=T, top_k=top_k, top_p=top_p, sample_logits=True)
+
+            s2_logits = model.decode_s2(context, sample_pre)
+            s2_logits = s2_logits[:, -1, :]
+            sample_post = sample_from_logits(s2_logits, temperature=T, top_k=top_k, top_p=top_p, sample_logits=True)
+
+            generated_pre[:, i] = sample_pre.squeeze(-1)
+            generated_post[:, i] = sample_post.squeeze(-1)
+
+            if current_seq_len < max_context:
+                pre_buffer[:, current_seq_len] = sample_pre.squeeze(-1)
+                post_buffer[:, current_seq_len] = sample_post.squeeze(-1)
+            else:
+                pre_buffer.copy_(torch.roll(pre_buffer, shifts=-1, dims=1))
+                post_buffer.copy_(torch.roll(post_buffer, shifts=-1, dims=1))
+                pre_buffer[:, -1] = sample_pre.squeeze(-1)
+                post_buffer[:, -1] = sample_post.squeeze(-1)
+
+        full_pre = torch.cat([x_token[0], generated_pre], dim=1)
+        full_post = torch.cat([x_token[1], generated_post], dim=1)
+
+        context_start = max(0, total_seq_len - max_context)
+        input_tokens = [
+            full_pre[:, context_start:total_seq_len].contiguous(),
+            full_post[:, context_start:total_seq_len].contiguous()
+        ]
+        z = tokenizer.decode(input_tokens, half=True)
+        z = z.reshape(-1, sample_count, z.size(1), z.size(2))
+        preds = z.cpu().numpy()
+        
+        if not return_samples:
+            preds = np.mean(preds, axis=1)
+
+        return preds
+
+
+def calc_time_stamps(x_timestamp):
+    time_df = pd.DataFrame()
+    time_df['minute'] = x_timestamp.dt.minute
+    time_df['hour'] = x_timestamp.dt.hour
+    time_df['weekday'] = x_timestamp.dt.weekday
+    time_df['day'] = x_timestamp.dt.day
+    time_df['month'] = x_timestamp.dt.month
+    return time_df
+
+
+class KronosPredictor:
+
+    def __init__(self, model, tokenizer, device=None, max_context=512, clip=5):
+        self.tokenizer = tokenizer
+        self.model = model
+        self.max_context = max_context
+        self.clip = clip
+        self.price_cols = ['open', 'high', 'low', 'close']
+        self.vol_col = 'volume'
+        self.amt_vol = 'amount'
+        self.time_cols = ['minute', 'hour', 'weekday', 'day', 'month']
+        
+        # Auto-detect device if not specified
+        if device is None:
+            if torch.cuda.is_available():
+                device = "cuda:0"
+            elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+                device = "mps"
+            else:
+                device = "cpu"
+        
+        self.device = device
+
+        self.tokenizer = self.tokenizer.to(self.device)
+        self.model = self.model.to(self.device)
+
+    def generate(self, x, x_stamp, y_stamp, pred_len, T, top_k, top_p, sample_count, verbose, return_samples=False):
+
+        x_tensor = torch.from_numpy(np.array(x).astype(np.float32)).to(self.device)
+        x_stamp_tensor = torch.from_numpy(np.array(x_stamp).astype(np.float32)).to(self.device)
+        y_stamp_tensor = torch.from_numpy(np.array(y_stamp).astype(np.float32)).to(self.device)
+
+        preds = auto_regressive_inference(self.tokenizer, self.model, x_tensor, x_stamp_tensor, y_stamp_tensor, self.max_context, pred_len,
+                                          self.clip, T, top_k, top_p, sample_count, verbose, return_samples=return_samples)
+        preds = preds[:, -pred_len:, :]
+        return preds
+
+    def predict(self, df, x_timestamp, y_timestamp, pred_len, T=1.0, top_k=0, top_p=0.9, sample_count=1, verbose=True):
+
+        if not isinstance(df, pd.DataFrame):
+            raise ValueError("Input must be a pandas DataFrame.")
+
+        if not all(col in df.columns for col in self.price_cols):
+            raise ValueError(f"Price columns {self.price_cols} not found in DataFrame.")
+
+        df = df.copy()
+        if self.vol_col not in df.columns:
+            df[self.vol_col] = 0.0  # Fill missing volume with zeros
+            df[self.amt_vol] = 0.0  # Fill missing amount with zeros
+        if self.amt_vol not in df.columns and self.vol_col in df.columns:
+            df[self.amt_vol] = df[self.vol_col] * df[self.price_cols].mean(axis=1)
+
+        if df[self.price_cols + [self.vol_col, self.amt_vol]].isnull().values.any():
+            raise ValueError("Input DataFrame contains NaN values in price or volume columns.")
+
+        x_time_df = calc_time_stamps(x_timestamp)
+        y_time_df = calc_time_stamps(y_timestamp)
+
+        x = df[self.price_cols + [self.vol_col, self.amt_vol]].values.astype(np.float32)
+        x_stamp = x_time_df.values.astype(np.float32)
+        y_stamp = y_time_df.values.astype(np.float32)
+
+        x_mean, x_std = np.mean(x, axis=0), np.std(x, axis=0)
+
+        x = (x - x_mean) / (x_std + 1e-5)
+        x = np.clip(x, -self.clip, self.clip)
+
+        x = x[np.newaxis, :]
+        x_stamp = x_stamp[np.newaxis, :]
+        y_stamp = y_stamp[np.newaxis, :]
+
+        preds = self.generate(x, x_stamp, y_stamp, pred_len, T, top_k, top_p, sample_count, verbose)
+
+        preds = preds.squeeze(0)
+        preds = preds * (x_std + 1e-5) + x_mean
+
+        pred_df = pd.DataFrame(preds, columns=self.price_cols + [self.vol_col, self.amt_vol], index=y_timestamp)
+        return pred_df
+
+
+    def predict_batch(self, df_list, x_timestamp_list, y_timestamp_list, pred_len, T=1.0, top_k=0, top_p=0.9, sample_count=1, verbose=True):
+        """
+        Perform parallel (batch) prediction on multiple time series. All series must have the same historical length and prediction length (pred_len).
+
+        Args:
+            df_list (List[pd.DataFrame]): List of input DataFrames, each containing price columns and optional volume/amount columns.
+            x_timestamp_list (List[pd.DatetimeIndex or Series]): List of timestamps corresponding to historical data, length should match the number of rows in each DataFrame.
+            y_timestamp_list (List[pd.DatetimeIndex or Series]): List of future prediction timestamps, length should equal pred_len.
+            pred_len (int): Number of prediction steps.
+            T (float): Sampling temperature.
+            top_k (int): Top-k filtering threshold.
+            top_p (float): Top-p (nucleus sampling) threshold.
+            sample_count (int): Number of parallel samples per series, automatically averaged internally.
+            verbose (bool): Whether to display autoregressive progress.
+
+        Returns:
+            List[pd.DataFrame]: List of prediction results in the same order as input, each DataFrame contains
+                                `open, high, low, close, volume, amount` columns, indexed by corresponding `y_timestamp`.
+        """
+        # Basic validation
+        if not isinstance(df_list, (list, tuple)) or not isinstance(x_timestamp_list, (list, tuple)) or not isinstance(y_timestamp_list, (list, tuple)):
+            raise ValueError("df_list, x_timestamp_list, y_timestamp_list must be list or tuple types.")
+        if not (len(df_list) == len(x_timestamp_list) == len(y_timestamp_list)):
+            raise ValueError("df_list, x_timestamp_list, y_timestamp_list must have consistent lengths.")
+
+        num_series = len(df_list)
+
+        x_list = []
+        x_stamp_list = []
+        y_stamp_list = []
+        means = []
+        stds = []
+        seq_lens = []
+        y_lens = []
+
+        for i in range(num_series):
+            df = df_list[i]
+            if not isinstance(df, pd.DataFrame):
+                raise ValueError(f"Input at index {i} is not a pandas DataFrame.")
+            if not all(col in df.columns for col in self.price_cols):
+                raise ValueError(f"DataFrame at index {i} is missing price columns {self.price_cols}.")
+
+            df = df.copy()
+            if self.vol_col not in df.columns:
+                df[self.vol_col] = 0.0
+                df[self.amt_vol] = 0.0
+            if self.amt_vol not in df.columns and self.vol_col in df.columns:
+                df[self.amt_vol] = df[self.vol_col] * df[self.price_cols].mean(axis=1)
+
+            if df[self.price_cols + [self.vol_col, self.amt_vol]].isnull().values.any():
+                raise ValueError(f"DataFrame at index {i} contains NaN values in price or volume columns.")
+
+            x_timestamp = x_timestamp_list[i]
+            y_timestamp = y_timestamp_list[i]
+
+            x_time_df = calc_time_stamps(x_timestamp)
+            y_time_df = calc_time_stamps(y_timestamp)
+
+            x = df[self.price_cols + [self.vol_col, self.amt_vol]].values.astype(np.float32)
+            x_stamp = x_time_df.values.astype(np.float32)
+            y_stamp = y_time_df.values.astype(np.float32)
+
+            if x.shape[0] != x_stamp.shape[0]:
+                raise ValueError(f"Inconsistent lengths at index {i}: x has {x.shape[0]} vs x_stamp has {x_stamp.shape[0]}.")
+            if y_stamp.shape[0] != pred_len:
+                raise ValueError(f"y_timestamp length at index {i} should equal pred_len={pred_len}, got {y_stamp.shape[0]}.")
+
+            x_mean, x_std = np.mean(x, axis=0), np.std(x, axis=0)
+            x_norm = (x - x_mean) / (x_std + 1e-5)
+            x_norm = np.clip(x_norm, -self.clip, self.clip)
+
+            x_list.append(x_norm)
+            x_stamp_list.append(x_stamp)
+            y_stamp_list.append(y_stamp)
+            means.append(x_mean)
+            stds.append(x_std)
+
+            seq_lens.append(x_norm.shape[0])
+            y_lens.append(y_stamp.shape[0])
+
+        # Require all series to have consistent historical and prediction lengths for batch processing
+        if len(set(seq_lens)) != 1:
+            raise ValueError(f"Parallel prediction requires all series to have consistent historical lengths, got: {seq_lens}")
+        if len(set(y_lens)) != 1:
+            raise ValueError(f"Parallel prediction requires all series to have consistent prediction lengths, got: {y_lens}")
+
+        x_batch = np.stack(x_list, axis=0).astype(np.float32)           # (B, seq_len, feat)
+        x_stamp_batch = np.stack(x_stamp_list, axis=0).astype(np.float32) # (B, seq_len, time_feat)
+        y_stamp_batch = np.stack(y_stamp_list, axis=0).astype(np.float32) # (B, pred_len, time_feat)
+
+        preds = self.generate(x_batch, x_stamp_batch, y_stamp_batch, pred_len, T, top_k, top_p, sample_count, verbose)
+        # preds: (B, pred_len, feat)
+
+        pred_dfs = []
+        for i in range(num_series):
+            preds_i = preds[i] * (stds[i] + 1e-5) + means[i]
+            pred_df = pd.DataFrame(preds_i, columns=self.price_cols + [self.vol_col, self.amt_vol], index=y_timestamp_list[i])
+            pred_dfs.append(pred_df)
+
+        return pred_dfs
+

Kronos-master/model/module.py

@@ -0,0 +1,570 @@
+import math
+
+from einops import rearrange, reduce
+import torch
+import torch.nn as nn
+from torch.autograd import Function
+import torch.nn.functional as F
+
+
+class DifferentiableEntropyFunction(Function):
+    @staticmethod
+    def forward(ctx, zq, basis, K, eps):
+        zb = (zq + 1) / 2
+        zi = ((zb * basis).sum(-1)).to(torch.int64)
+        cnt = torch.scatter_reduce(torch.zeros(2 ** K, device=zq.device, dtype=zq.dtype),
+                                   0,
+                                   zi.flatten(),
+                                   torch.ones_like(zi.flatten()).to(zq.dtype),
+                                   'sum')
+        prob = (cnt + eps) / (cnt + eps).sum()
+        H = -(prob * torch.log(prob)).sum()
+        ctx.save_for_backward(zq, zi, prob)
+        ctx.K = K
+        return H
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        zq, zi, prob = ctx.saved_tensors
+        grad_array = -grad_output * (torch.log(prob) + 1) / zi.numel() / ctx.K
+        reord_grad = grad_array[zi.flatten()].reshape(zi.shape)
+        grad_input = reord_grad.unsqueeze(-1) * zq
+        return grad_input, None, None, None, None
+
+
+def codebook_entropy(zq, basis, K, eps=1e-4):
+    return DifferentiableEntropyFunction.apply(zq, basis, K, eps)
+
+
+class BinarySphericalQuantizer(nn.Module):
+    def __init__(self, embed_dim, beta, gamma0, gamma, zeta,
+                 input_format='bchw',
+                 soft_entropy=True, group_size=9,
+                 persample_entropy_compute='analytical',
+                 cb_entropy_compute='group',
+                 l2_norm=True,
+                 inv_temperature=1):
+        """
+        Paper link: https://arxiv.org/pdf/2406.07548.pdf
+        Here we use the official implementation of the BinarySphericalQuantizer.
+        """
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.beta = beta  # loss weight for commit loss
+        self.gamma0 = gamma0  # loss weight for entropy penalty
+        self.gamma = gamma  # loss weight for entropy penalty
+        self.zeta = zeta  # loss weight for entire entropy penalty
+        self.input_format = input_format
+        assert self.embed_dim % group_size == 0, "embed_dim must be divisible by group_size"
+        self.num_groups = self.embed_dim // group_size
+        self.group_size = group_size
+        assert persample_entropy_compute in ['group', 'analytical'], "persample_entropy_compute must be either 'group' or 'analytical'"
+        assert cb_entropy_compute in ['group', 'nce'], "cb_entropy_compute must be either 'group' or 'nce'"
+        self.persample_entropy_compute = persample_entropy_compute
+        self.cb_entropy_compute = cb_entropy_compute
+        self.l2_norm = l2_norm
+        self.inv_temperature = inv_temperature
+
+        self.register_buffer('basis', 2 ** torch.arange(embed_dim - 1, -1, -1))
+        self.register_buffer('group_basis', 2 ** torch.arange(group_size - 1, -1, -1))
+
+        self.num_dimensions = 2 ** embed_dim
+        self.bits_per_index = embed_dim
+
+        # we only need to keep the codebook portion up to the group size
+        # because we approximate the H loss with this subcode
+        group_codes = torch.arange(2 ** self.group_size)
+        group_codebook = self.indexes_to_codes(group_codes).float()[:, -group_size:]
+        self.register_buffer('group_codebook', group_codebook, persistent=False)
+
+        self.soft_entropy = soft_entropy  # soft_entropy: Sec 3.2 of https://arxiv.org/pdf/1911.05894.pdf
+
+    def quantize(self, z):
+        assert z.shape[-1] == self.embed_dim, f"Expected {self.embed_dim} dimensions, got {z.shape[-1]}"
+
+        zhat = torch.where(z > 0,
+                           torch.tensor(1, dtype=z.dtype, device=z.device),
+                           torch.tensor(-1, dtype=z.dtype, device=z.device))
+        return z + (zhat - z).detach()
+
+    def forward(self, z, collect_metrics=True):
+        # if self.input_format == 'bchw':
+        #     z = rearrange(z, 'b c h w -> b h w c')
+        zq = self.quantize(z)
+
+        q_scale = 1. / (self.embed_dim ** 0.5) if self.l2_norm else 1.
+
+        zq = zq * q_scale
+
+        if not collect_metrics:
+            return zq, zq.new_zeros(()), {}
+
+        indices = self.codes_to_indexes(zq.detach())
+        group_indices = self.codes_to_group_indexes(zq.detach())
+        if not self.training:
+            used_codes = torch.unique(indices, return_counts=False)
+        else:
+            used_codes = None
+
+        if self.soft_entropy:
+            persample_entropy, cb_entropy, avg_prob = self.soft_entropy_loss(z)
+            entropy_penalty = self.gamma0 * persample_entropy - self.gamma * cb_entropy
+        else:
+            zb_by_sample = ((zq + 1) / 2).reshape(z.shape[0], -1, z.shape[-1]).to(torch.float32)
+            persample_entropy = self.get_hard_per_sample_entropy(zb_by_sample)
+            cb_entropy = codebook_entropy(zq, self.basis, self.embed_dim)
+            entropy_penalty = self.gamma0 * persample_entropy - self.gamma * cb_entropy
+
+        # commit loss
+        commit_loss = self.beta * torch.mean(((zq.detach() - z) ** 2).sum(dim=-1))
+
+        # if self.input_format == 'bchw':
+        #     zq = rearrange(zq, 'b h w c -> b c h w')
+
+        return (
+            zq,
+            commit_loss + self.zeta * entropy_penalty / self.inv_temperature,
+            {"H": cb_entropy, "used_codes": used_codes, "indices": indices, "group_indices": group_indices,
+             "avg_prob": avg_prob}
+        )
+
+    def soft_entropy_loss(self, z):
+        # if we divide the code in subgroups of size group_size, the codebook will be of size 2 ** group_size
+        # the sub-code is the last group_size bits of the full code
+        group_code_book = self.group_codebook / (self.embed_dim ** 0.5 if self.l2_norm else 1)
+        divided_z = rearrange(z, '... (g c) -> ... g c', c=self.group_size)
+
+        # we calculate the distance between the divided_z and the codebook for each subgroup
+        distance = - 2 * torch.einsum('... g c, d c ->... g d', divided_z, group_code_book)
+        prob = (-distance * self.inv_temperature).softmax(dim=-1)
+        if self.persample_entropy_compute == 'analytical':
+            if self.l2_norm:
+                p = torch.sigmoid(-4 * z / (self.embed_dim ** 0.5) * self.inv_temperature)
+            else:
+                p = torch.sigmoid(-4 * z * self.inv_temperature)
+            prob = torch.stack([p, 1 - p], dim=-1)
+            per_sample_entropy = self.get_entropy(prob, dim=-1, normalize=False).sum(dim=-1).mean()
+        else:
+            per_sample_entropy = self.get_entropy(prob, dim=-1, normalize=False).sum(dim=-1).mean()
+
+        # macro average of the probability of each subgroup
+        avg_prob = reduce(prob, '... g d ->g d', 'mean')
+        codebook_entropy = self.get_entropy(avg_prob, dim=-1, normalize=False)
+
+        # the approximation of the entropy is the sum of the entropy of each subgroup
+        return per_sample_entropy, codebook_entropy.sum(), avg_prob
+
+    def get_hard_per_sample_entropy(self, zb_by_sample):
+        probs_per_dim = zb_by_sample.sum(1) / zb_by_sample.shape[1]
+        persample_entropy = - probs_per_dim * torch.log(probs_per_dim + 1e-8) - (1 - probs_per_dim) * torch.log(1 - probs_per_dim + 1e-8)
+        persample_entropy = persample_entropy.sum(-1)
+        return persample_entropy.mean()
+
+    def codes_to_indexes(self, zhat):
+        """Converts a `code` to an index in the codebook.
+        Args:
+            zhat: A tensor of shape (B, ..., C) containing the codes. must be in {-1, 1}
+        """
+        assert zhat.shape[-1] == self.embed_dim, f"Expected {self.embed_dim} dimensions, got {zhat.shape[-1]}"
+        return ((zhat + 1) / 2 * self.basis).sum(axis=-1).to(torch.int64)
+
+    def codes_to_group_indexes(self, zhat):
+        """Converts a `code` to a list of indexes (in groups) in the codebook.
+        Args:
+            zhat: A tensor of shape (B, ..., C) containing the codes. must be in {-1, 1}
+        """
+        zhat_in_group = rearrange(zhat, 'b ... (g c) -> b ... g c', c=self.group_size)
+        return ((zhat_in_group + 1) / 2 * self.group_basis).sum(axis=-1).to(torch.int64)
+
+    def indexes_to_codes(self, indices):
+        """Inverse of `indexes_to_codes`."""
+        indices = indices.unsqueeze(-1)
+        codes_non_centered = torch.remainder(
+            torch.floor_divide(indices, self.basis), 2
+        )
+        return codes_non_centered * 2 - 1
+
+    def group_indexes_to_codes(self, group_indices):
+        """Inverse of `group_indexes_to_codes`."""
+        group_indices = group_indices.unsqueeze(-1)
+        codes_non_centered = torch.remainder(
+            torch.floor_divide(group_indices, self.group_basis), 2
+        )
+        codes_non_centered = rearrange(codes_non_centered, 'b ... g c -> b ... (g c)')
+        return codes_non_centered * 2 - 1
+
+    def get_entropy(self, count, dim=-1, eps=1e-4, normalize=True):
+        if normalize:
+            probs = (count + eps) / (count + eps).sum(dim=dim, keepdim=True)
+        else:
+            probs = count
+        H = -(probs * torch.log(probs + 1e-8)).sum(dim=dim)
+        return H
+
+    def get_group_codebook_entry(self, group_indices):
+        z_q = self.group_indexes_to_codes(group_indices)
+        q_scale = 1. / (self.embed_dim ** 0.5) if self.l2_norm else 1.
+        z_q = z_q * q_scale
+        if self.input_format == 'bchw':
+            h, w = int(z_q.shape[1] ** 0.5)
+            assert h * w == z_q.shape[1], 'Invalid sequence length'
+            z_q = rearrange(z_q, 'b (h w) c -> b c h w', h=h)
+        return z_q
+
+    def get_codebook_entry(self, indices):
+        z_q = self.indexes_to_codes(indices)
+        q_scale = 1. / (self.embed_dim ** 0.5) if self.l2_norm else 1.
+        z_q = z_q * q_scale
+        if self.input_format == 'bchw':
+            h, w = int(z_q.shape[1] ** 0.5)
+            assert h * w == z_q.shape[1], 'Invalid sequence length'
+            z_q = rearrange(z_q, 'b (h w) c -> b c h w', h=h)
+        return z_q
+
+
+class BSQuantizer(nn.Module):
+
+    def __init__(self, s1_bits, s2_bits, beta, gamma0, gamma, zeta, group_size):
+        super().__init__()
+        self.codebook_dim = s1_bits + s2_bits
+        self.s1_bits = s1_bits
+        self.s2_bits = s2_bits
+        self.bsq = BinarySphericalQuantizer(self.codebook_dim, beta, gamma0, gamma, zeta, group_size=group_size)
+
+    def bits_to_indices(self, bits):
+        bits = (bits >= 0).to(torch.long)
+        indices = 2 ** torch.arange(
+            0,
+            bits.shape[-1],
+            1,
+            dtype=torch.long,
+            device=bits.device,
+        )
+        return (bits * indices).sum(-1)
+
+    def forward(self, z, half=False, collect_metrics=True):
+        z = F.normalize(z, dim=-1)
+        quantized, bsq_loss, metrics = self.bsq(z, collect_metrics=collect_metrics)
+        if half:
+            q_pre = quantized[:, :, :self.s1_bits]
+            q_post = quantized[:, :, self.s1_bits:]
+            z_indices = [self.bits_to_indices(q_pre), self.bits_to_indices(q_post)]
+        else:
+            z_indices = self.bits_to_indices(quantized)
+        return bsq_loss, quantized, z_indices
+
+
+class RMSNorm(torch.nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-5):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def _norm(self, x):
+        return x * torch.rsqrt(torch.mean(x * x, dim=-1, keepdim=True) + self.eps)
+
+    def forward(self, x):
+        output = self._norm(x.float()).type_as(x)
+        return output * self.weight
+
+
+class FeedForward(nn.Module):
+    def __init__(self, d_model, ff_dim, ffn_dropout_p=0.0):
+        super().__init__()
+
+        self.w1 = nn.Linear(d_model, ff_dim, bias=False)
+        self.w3 = nn.Linear(d_model, ff_dim, bias=False)
+        self.w2 = nn.Linear(ff_dim, d_model, bias=False)
+        self.ffn_dropout = nn.Dropout(ffn_dropout_p)
+
+    def forward(self, x):
+        return self.ffn_dropout(self.w2(F.silu(self.w1(x)) * self.w3(x)))
+
+
+class RotaryPositionalEmbedding(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inv_freq", inv_freq)
+        self.seq_len_cached = None
+        self.cos_cached = None
+        self.sin_cached = None
+
+    def _update_cos_sin_cache(self, x, seq_len):
+        if seq_len != self.seq_len_cached:
+            self.seq_len_cached = seq_len
+            t = torch.arange(seq_len, device=x.device).type_as(self.inv_freq)
+            freqs = torch.einsum('i,j->ij', t, self.inv_freq)
+            emb = torch.cat((freqs, freqs), dim=-1).to(x.device)
+            self.cos_cached = emb.cos()[None, None, :, :]
+            self.sin_cached = emb.sin()[None, None, :, :]
+        return self.cos_cached, self.sin_cached
+
+    def forward(self, q, k):
+        cos, sin = self._update_cos_sin_cache(q, q.shape[-2])
+        return (
+            (q * cos) + (self._rotate_half(q) * sin),
+            (k * cos) + (self._rotate_half(k) * sin),
+        )
+
+    def _rotate_half(self, x):
+        x1, x2 = x.chunk(2, dim=-1)
+        return torch.cat((-x2, x1), dim=-1)
+
+
+class MultiHeadAttentionWithRoPE(nn.Module):
+    def __init__(self, d_model, n_heads, attn_dropout_p=0.0, resid_dropout_p=0.0):
+        super().__init__()
+        self.d_model = d_model
+        self.n_heads = n_heads
+        self.head_dim = d_model // n_heads
+
+        self.q_proj = nn.Linear(d_model, d_model)
+        self.k_proj = nn.Linear(d_model, d_model)
+        self.v_proj = nn.Linear(d_model, d_model)
+        self.out_proj = nn.Linear(d_model, d_model)
+        self.rotary = RotaryPositionalEmbedding(self.head_dim)
+        self.attn_dropout_p = attn_dropout_p
+        self.resid_dropout = nn.Dropout(resid_dropout_p)
+
+    def forward(self, x, key_padding_mask=None):
+        batch_size, seq_len, _ = x.shape
+
+        q = self.q_proj(x).view(batch_size, seq_len, self.n_heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(x).view(batch_size, seq_len, self.n_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(x).view(batch_size, seq_len, self.n_heads, self.head_dim).transpose(1, 2)
+
+        q, k = self.rotary(q, k)
+
+        if key_padding_mask is not None:
+            attn_mask = key_padding_mask.unsqueeze(1).unsqueeze(2)  # [batch, 1, 1, seq_len]
+            attn_mask = attn_mask.expand(-1, self.n_heads, seq_len, -1)  # [batch, n_heads, q_len, k_len]
+        else:
+            attn_mask = None
+
+        attn_output = F.scaled_dot_product_attention(
+            q, k, v,
+            attn_mask=attn_mask,
+            dropout_p=self.attn_dropout_p if self.training else 0.0,
+            is_causal=True
+        )
+
+        attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)
+        return self.resid_dropout(self.out_proj(attn_output))
+
+
+class MultiHeadCrossAttentionWithRoPE(nn.Module):
+    def __init__(self, d_model, n_heads, attn_dropout_p=0.0, resid_dropout=0.0):
+        super().__init__()
+        self.d_model = d_model
+        self.n_heads = n_heads
+        self.head_dim = d_model // n_heads
+
+        self.q_proj = nn.Linear(d_model, d_model)
+        self.k_proj = nn.Linear(d_model, d_model)
+        self.v_proj = nn.Linear(d_model, d_model)
+        self.out_proj = nn.Linear(d_model, d_model)
+        self.rotary = RotaryPositionalEmbedding(self.head_dim)
+        self.attn_dropout_p = attn_dropout_p
+        self.resid_dropout = nn.Dropout(resid_dropout)
+
+    def forward(self, query, key, value, key_padding_mask=None):
+        batch_size, q_len, _ = query.shape
+        _, seq_len, _ = key.shape
+
+        q = self.q_proj(query).view(batch_size, q_len, self.n_heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(key).view(batch_size, seq_len, self.n_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(value).view(batch_size, seq_len, self.n_heads, self.head_dim).transpose(1, 2)
+
+        q, k = self.rotary(q, k)
+
+        if key_padding_mask is not None:
+            attn_mask = key_padding_mask.unsqueeze(1).unsqueeze(2)
+            attn_mask = attn_mask.expand(-1, self.n_heads, q_len, -1)
+        else:
+            attn_mask = None
+
+        is_causal_flag = self.training
+
+        attn_output = F.scaled_dot_product_attention(
+            q, k, v,
+            attn_mask=attn_mask,
+            dropout_p=self.attn_dropout_p if self.training else 0.0,
+            is_causal=is_causal_flag
+        )
+
+        attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, q_len, self.d_model)
+        return self.resid_dropout(self.out_proj(attn_output))
+
+
+class HierarchicalEmbedding(nn.Module):
+    def __init__(self, s1_bits, s2_bits, d_model=256):
+        super().__init__()
+        self.s1_bits = s1_bits
+        self.s2_bits = s2_bits
+
+        vocab_s1 = 2 ** s1_bits
+        vocab_s2 = 2 ** s2_bits
+
+        self.emb_s1 = nn.Embedding(vocab_s1, d_model)
+        self.emb_s2 = nn.Embedding(vocab_s2, d_model)
+        self.d_model = d_model
+        self.fusion_proj = nn.Linear(d_model * 2, d_model)
+
+        nn.init.normal_(self.emb_s1.weight, mean=0, std=d_model ** -0.5)
+        nn.init.normal_(self.emb_s2.weight, mean=0, std=d_model ** -0.5)
+
+    def split_token(self, token_ids: torch.Tensor, s2_bits: int):
+        """Inputs:
+            token_ids (torch.Tensor): Composite token IDs of shape [batch_size, seq_len] or [N], each in range [0, 2^(s1_bits + s2_bits) - 1].
+            s2_bits (int): Number of low bits used for the fine token (s2).
+        """
+        assert isinstance(s2_bits, int) and s2_bits > 0, "s2_bits must be a positive integer"
+
+        t = token_ids.long()
+        mask = (1 << s2_bits) - 1
+        s2_ids = t & mask           # extract low bits
+        s1_ids = t >> s2_bits       # extract high bits
+        return s1_ids, s2_ids
+
+    def forward(self, token_ids):
+        """Inputs:
+        token_ids:
+            - tuple or list: (s1_ids, s2_ids), each of shape [batch_size, seq_len], or
+            - torch.Tensor: composite token IDs of shape [batch_size, seq_len], which will be split into (s1_ids, s2_ids) internally.
+        Output: [batch_size, seq_len, d_model]
+        """
+        if isinstance(token_ids, tuple) or isinstance(token_ids, list):
+            s1_ids, s2_ids = token_ids
+        else:
+            s1_ids, s2_ids = self.split_token(token_ids, self.s2_bits)
+        s1_emb = self.emb_s1(s1_ids) * math.sqrt(self.d_model)
+        s2_emb = self.emb_s2(s2_ids) * math.sqrt(self.d_model)
+        return self.fusion_proj(torch.cat([s1_emb, s2_emb], dim=-1))
+
+
+class DependencyAwareLayer(nn.Module):
+    def __init__(self, d_model, n_heads=4, attn_dropout_p=0.0, resid_dropout=0.0):
+        super().__init__()
+        self.cross_attn = MultiHeadCrossAttentionWithRoPE(d_model, n_heads, attn_dropout_p, resid_dropout)
+        self.norm = RMSNorm(d_model)
+
+    def forward(self, hidden_states, sibling_embed, key_padding_mask=None):
+        """hidden_states: [batch, seq_len, d_model]
+        sibling_embed: Embedding from another subtoken
+        """
+        attn_out = self.cross_attn(
+            query=sibling_embed,
+            key=hidden_states,
+            value=hidden_states,
+            key_padding_mask=key_padding_mask
+        )
+        return self.norm(hidden_states + attn_out)
+
+
+class TransformerBlock(nn.Module):
+    def __init__(self, d_model, n_heads, ff_dim=1024, ffn_dropout_p=0.0, attn_dropout_p=0.0, resid_dropout_p=0.0):
+        super().__init__()
+        self.norm1 = RMSNorm(d_model)
+        self.self_attn = MultiHeadAttentionWithRoPE(d_model, n_heads, attn_dropout_p, resid_dropout_p)
+        self.norm2 = RMSNorm(d_model)
+        self.ffn = FeedForward(d_model, ff_dim, ffn_dropout_p)
+
+    def forward(self, x, key_padding_mask=None):
+        residual = x
+        x = self.norm1(x)
+        attn_out = self.self_attn(x, key_padding_mask=key_padding_mask)
+        x = residual + attn_out
+
+        residual = x
+        x = self.norm2(x)
+        ffn_out = self.ffn(x)
+        x = residual + ffn_out
+        return x
+
+
+class DualHead(nn.Module):
+    def __init__(self, s1_bits, s2_bits, d_model):
+        super().__init__()
+        self.vocab_s1 = 2 ** s1_bits
+        self.vocab_s2 = 2 ** s2_bits
+        self.proj_s1 = nn.Linear(d_model, self.vocab_s1)
+        self.proj_s2 = nn.Linear(d_model, self.vocab_s2)
+
+    def compute_loss(self, s1_logits, s2_logits, s1_targets, s2_targets, padding_mask=None):
+        if padding_mask is not None:
+            valid_mask = (padding_mask == 0)
+            s1_logits = s1_logits[valid_mask]
+            s2_logits = s2_logits[valid_mask]
+            s1_targets = s1_targets[valid_mask]
+            s2_targets = s2_targets[valid_mask]
+            ce_s1 = F.cross_entropy(s1_logits, s1_targets)
+            ce_s2 = F.cross_entropy(s2_logits, s2_targets)
+        else:
+            ce_s1 = F.cross_entropy(s1_logits.reshape(-1, self.vocab_s1), s1_targets.reshape(-1))
+            ce_s2 = F.cross_entropy(s2_logits.reshape(-1, self.vocab_s2), s2_targets.reshape(-1))
+        ce_loss = (ce_s1 + ce_s2) / 2
+        return ce_loss, ce_s1, ce_s2
+
+    def forward(self, x):
+        return self.proj_s1(x)
+
+    def cond_forward(self, x2):
+        return self.proj_s2(x2)
+
+
+class FixedEmbedding(nn.Module):
+    def __init__(self, c_in, d_model):
+        super(FixedEmbedding, self).__init__()
+
+        w = torch.zeros(c_in, d_model).float()
+        w.require_grad = False
+
+        position = torch.arange(0, c_in).float().unsqueeze(1)
+        div_term = (torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model)).exp()
+
+        w[:, 0::2] = torch.sin(position * div_term)
+        w[:, 1::2] = torch.cos(position * div_term)
+
+        self.emb = nn.Embedding(c_in, d_model)
+        self.emb.weight = nn.Parameter(w, requires_grad=False)
+
+    def forward(self, x):
+        return self.emb(x).detach()
+
+
+class TemporalEmbedding(nn.Module):
+    def __init__(self, d_model, learn_pe):
+        super(TemporalEmbedding, self).__init__()
+
+        minute_size = 60
+        hour_size = 24
+        weekday_size = 7
+        day_size = 32
+        month_size = 13
+
+        Embed = FixedEmbedding if not learn_pe else nn.Embedding
+        self.minute_embed = Embed(minute_size, d_model)
+        self.hour_embed = Embed(hour_size, d_model)
+        self.weekday_embed = Embed(weekday_size, d_model)
+        self.day_embed = Embed(day_size, d_model)
+        self.month_embed = Embed(month_size, d_model)
+
+    def forward(self, x):
+        x = x.long()
+
+        minute_x = self.minute_embed(x[:, :, 0])
+        hour_x = self.hour_embed(x[:, :, 1])
+        weekday_x = self.weekday_embed(x[:, :, 2])
+        day_x = self.day_embed(x[:, :, 3])
+        month_x = self.month_embed(x[:, :, 4])
+
+        return hour_x + weekday_x + day_x + month_x + minute_x
+
+
+
+
+
+
+
+

Kronos-master/requirements.txt

@@ -0,0 +1,10 @@
+numpy
+pandas
+torch>=2.0.0
+
+einops==0.8.1
+huggingface_hub==0.33.1
+matplotlib==3.9.3
+pandas==2.2.2
+tqdm==4.67.1
+safetensors==0.6.2

README.md

@@ -0,0 +1,91 @@
+# Kronos AI Analysis
+
+Kronos AI Analysis is a FastAPI + Lightweight Charts application for:
+
+- loading market data from multiple providers with automatic fallback
+- calculating technical indicators
+- generating AI forecasts with Kronos
+- serving the web UI directly from the backend
+
+## Runtime Requirements
+
+- Windows with Python 3.11 installed
+- Internet access for live market data
+- Internet access on first Kronos model load if the model is not already cached locally
+
+## Project Layout
+
+```text
+Kronos_AI_Analysis/
+|-- backend/
+|   |-- main.py
+|   `-- launcher.py
+|-- frontend/
+|   `-- index.html
+|-- Kronos-master/
+|   `-- model/
+|-- dist/
+|   `-- SuperAI_Analysis.exe
+|-- requirements.txt
+`-- run_server.bat
+```
+
+## Recommended Start
+
+Run:
+
+```bat
+run_server.bat
+```
+
+The startup script now:
+
+1. checks Python 3.11
+2. repairs a broken virtual environment if needed
+3. installs the full runtime dependency set
+4. verifies Kronos can be imported
+5. starts the FastAPI server on `http://127.0.0.1:8000`
+
+## Manual Start
+
+```bat
+py -3.11 -m venv venv
+venv\Scripts\python.exe -m pip install -r requirements.txt
+venv\Scripts\python.exe -m uvicorn backend.main:app --host 127.0.0.1 --port 8000 --reload
+```
+
+## Important Notes
+
+- This project uses Kronos, not TimesFM.
+- Kronos source code is loaded from `Kronos-master`.
+- Kronos weights are loaded from Hugging Face via:
+  - `NeoQuasar/Kronos-base`
+  - `NeoQuasar/Kronos-Tokenizer-base`
+- The first AI forecast can take longer because the model may warm up or download into cache.
+
+## Key Endpoints
+
+- `GET /api/health`
+- `GET /api/symbols`
+- `GET /api/historical/{symbol}`
+- `GET /api/indicators/{symbol}`
+- `GET /api/forecast/{symbol}`
+- `GET /api/market-status`
+- `GET /api/crypto/market`
+- `WS /ws/price/{symbol}`
+
+## Health Expectations
+
+When the system is healthy:
+
+- `/api/health` returns `status: online`
+- `kronos.available` is `true`
+- `kronos.loaded` becomes `true` after warmup or after the first forecast
+- the frontend loads from the same backend origin
+
+## Troubleshooting
+
+- If Python 3.11 is missing, install it first.
+- If a previous `venv` was copied from another machine, `run_server.bat` rebuilds it.
+- If forecasts fail, check `/api/health` and confirm Kronos reports as available and loaded.
+- If market data fails, check network reachability to Binance, Bybit, CoinGecko, Twelve Data, Finnhub, and Yahoo Finance.

SOURCES_AND_SYMBOLS.md

@@ -0,0 +1,242 @@
+# NGUỒN DỮ LIỆU MIỄN PHÍ — XÁC NHẬN & PHÂN LOẠI MÃ GIAO DỊCH
+# Free Data Sources — Confirmed & Symbol Classification v4.0
+
+═══════════════════════════════════════════════════════════════════════
+## A. BẢNG NGUỒN DỮ LIỆU MIỄN PHÍ (Confirmed Free Sources)
+═══════════════════════════════════════════════════════════════════════
+
+| Nguồn        | URL cơ sở                              | API Key? | Giới hạn miễn phí        | Tốt nhất cho              |
+|--------------|----------------------------------------|----------|--------------------------|---------------------------|
+| Binance      | api.binance.com/api/v3                 | Không    | 1200 req/min             | Crypto OHLCV (tốt nhất)   |
+| Bybit V5     | api.bybit.com/v5/market                | Không    | 120 req/min              | Crypto backup             |
+| CoinGecko    | api.coingecko.com/api/v3               | Không    | 30 req/min               | Crypto OHLCV + market cap |
+| yfinance     | (scrapes finance.yahoo.com)            | Không    | Không giới hạn chính thức| Stocks, ETF, Forex, Chỉ số|
+| Finnhub      | finnhub.io/api/v1                      | Có (free)| 60 req/min               | Forex (OANDA), Stock, Crypto|
+| Twelvedata   | api.twelvedata.com                     | Có (free)| 800 credits/ngày, 8/phút | Forex, Stock, Crypto      |
+| Alpha Vantage| alphavantage.co/query                  | Có (free)| 25 req/ngày              | Forex fallback (hạn chế)  |
+| FRED         | fred.stlouisfed.org/graph/fredgraph    | Không    | Không giới hạn           | Macro (lãi suất, DXY...)  |
+
+### Ưu tiên nguồn theo loại tài sản:
+- **Crypto**:       Binance → Bybit → CoinGecko → yfinance → Finnhub
+- **Forex**:        Twelvedata → Finnhub (OANDA) → yfinance
+- **Kim loại**:     yfinance (futures =F) → Twelvedata → Finnhub
+- **Năng lượng**:   yfinance (futures =F) → Twelvedata → Finnhub
+- **Nông sản**:     yfinance (futures =F) → Twelvedata
+- **Chỉ số**:       yfinance (^SYMBOL) → Twelvedata → Finnhub
+- **Cổ phiếu Mỹ**:  yfinance → Finnhub → Twelvedata
+- **Cổ phiếu VN**:  yfinance (.VN suffix)
+- **Trái phiếu**:   yfinance (^TNX, ^TYX...)
+
+═══════════════════════════════════════════════════════════════════════
+## B. PHÂN LOẠI MÃ GIAO DỊCH CHUẨN
+═══════════════════════════════════════════════════════════════════════
+
+### 1. KIM LOẠI (Metals) — 13 mã
+| Mã           | Tên VN              | Ticker yfinance | Nguồn tốt nhất      |
+|--------------|---------------------|-----------------|---------------------|
+| XAUUSD       | Vàng                | GC=F            | Twelvedata, Finnhub  |
+| XAGUSD       | Bạc                 | SI=F            | Twelvedata, Finnhub  |
+| XPTUSD       | Bạch kim            | PL=F            | Twelvedata, yfinance |
+| XPDUSD       | Palladium           | PA=F            | Twelvedata, yfinance |
+| COPPER       | Đồng COMEX          | HG=F            | yfinance, Twelvedata |
+| COPPER_LME   | Đồng LME            | HG=F            | Twelvedata           |
+| ALUMINUM     | Nhôm COMEX          | ALI=F           | yfinance             |
+| ALUMINUM_LME | Nhôm LME            | LMAHDS03        | Twelvedata           |
+| NICKEL_LME   | Niken LME           | NI1             | Twelvedata           |
+| ZINC_LME     | Kẽm LME             | ZN1             | Twelvedata           |
+| IRON_ORE     | Quặng sắt           | TIO=F           | yfinance             |
+| STEEL_HRC    | Thép cuộn cán nóng  | HRC=F           | yfinance             |
+| LITHIUM      | Lithium (proxy ALB) | ALB             | yfinance             |
+
+### 2. NĂNG LƯỢNG (Energy) — 8 mã
+| Mã           | Tên VN              | Ticker yfinance | Ghi chú              |
+|--------------|---------------------|-----------------|----------------------|
+| WTI          | Dầu thô WTI         | CL=F            | Chuẩn Mỹ             |
+| BRENT        | Dầu Brent           | BZ=F            | Chuẩn quốc tế        |
+| NATURAL_GAS  | Khí tự nhiên        | NG=F            |                      |
+| GASOLINE_RBOB| Xăng RBOB           | RB=F            |                      |
+| HEATING_OIL  | Dầu sưởi            | HO=F            |                      |
+| LNG          | Khí hoá lỏng proxy  | LNG             | Cổ phiếu Cheniere    |
+| COAL         | Than Newcastle      | MTF=F           |                      |
+| URANIUM      | Uranium             | UX=F            |                      |
+
+### 3. NÔNG SẢN (Agricultural) — 7 mã
+| Mã           | Tên VN              | Ticker yfinance |
+|--------------|---------------------|-----------------|
+| CORN         | Ngô                 | ZC=F            |
+| WHEAT        | Lúa mì              | ZW=F            |
+| SOYBEAN      | Đậu tương           | ZS=F            |
+| SOYBEAN_OIL  | Dầu đậu tương       | ZL=F            |
+| SOYBEAN_MEAL | Khô đậu tương       | ZM=F            |
+| RICE         | Gạo thô             | ZR=F            |
+| OATS         | Yến mạch            | ZO=F            |
+
+### 4. NGUYÊN LIỆU CÔNG NGHIỆP (Soft Commodities) — 10 mã
+| Mã             | Tên VN              | Ticker yfinance |
+|----------------|---------------------|-----------------|
+| COFFEE_ARABICA | Cà phê Arabica      | KC=F            |
+| COFFEE_ROBUSTA | Cà phê Robusta      | RC=F            |
+| COCOA          | Ca cao              | CC=F            |
+| SUGAR_11       | Đường 11            | SB=F            |
+| WHITE_SUGAR    | Đường trắng         | LSW=F           |
+| COTTON         | Bông                | CT=F            |
+| ORANGE_JUICE   | Nước cam            | OJ=F            |
+| LUMBER         | Gỗ xẻ              | LBS=F           |
+| RUBBER_RSS3    | Cao su RSS3         | JRU=F           |
+| PALM_OIL       | Dầu cọ thô          | FCPO=F          |
+
+### 5. CRYPTO — 25 mã (Top by market cap)
+| Mã       | Tên            | Binance      | CoinGecko ID        |
+|----------|----------------|--------------|---------------------|
+| BTCUSD   | Bitcoin        | BTCUSDT      | bitcoin             |
+| ETHUSD   | Ethereum       | ETHUSDT      | ethereum            |
+| BNBUSD   | BNB            | BNBUSDT      | binancecoin         |
+| SOLUSD   | Solana         | SOLUSDT      | solana              |
+| XRPUSD   | Ripple         | XRPUSDT      | ripple              |
+| ADAUSD   | Cardano        | ADAUSDT      | cardano             |
+| AVAXUSD  | Avalanche      | AVAXUSDT     | avalanche-2         |
+| DOTUSD   | Polkadot       | DOTUSDT      | polkadot            |
+| MATICUSD | Polygon        | MATICUSDT    | matic-network       |
+| LINKUSD  | Chainlink      | LINKUSDT     | chainlink           |
+| LTCUSD   | Litecoin       | LTCUSDT      | litecoin            |
+| UNIUSD   | Uniswap        | UNIUSDT      | uniswap             |
+| ATOMUSD  | Cosmos         | ATOMUSDT     | cosmos              |
+| NEARUSD  | NEAR Protocol  | NEARUSDT     | near                |
+| APTUSD   | Aptos          | APTUSDT      | aptos               |
+| SUIUSD   | Sui            | SUIUSDT      | sui                 |
+| ARBUSD   | Arbitrum       | ARBUSDT      | arbitrum            |
+| OPUSD    | Optimism       | OPUSDT       | optimism            |
+| INJUSD   | Injective      | INJUSDT      | injective-protocol  |
+| TONUSD   | Toncoin        | TONUSDT      | the-open-network    |
+| TRXUSD   | Tron           | TRXUSDT      | tron                |
+| XMRUSD   | Monero         | (Bybit only) | monero              |
+| DOGEUSD  | Dogecoin       | DOGEUSDT     | dogecoin            |
+| SHIBAUSD | Shiba Inu      | SHIBUSDT     | shiba-inu           |
+| PEPE     | PEPE Coin      | PEPEUSDT     | pepe                |
+
+### 6. CẶP TIỀN (Forex) — 19 mã
+| Mã       | Tên           | Twelvedata   | Finnhub          | yfinance     |
+|----------|---------------|--------------|------------------|--------------|
+| DXY      | Chỉ số USD    | —            | —                | DX-Y.NYB     |
+| EURUSD   | EUR/USD       | EUR/USD      | OANDA:EUR_USD    | EURUSD=X     |
+| GBPUSD   | GBP/USD       | GBP/USD      | OANDA:GBP_USD    | GBPUSD=X     |
+| USDJPY   | USD/JPY       | USD/JPY      | OANDA:USD_JPY    | JPY=X        |
+| USDCHF   | USD/CHF       | USD/CHF      | OANDA:USD_CHF    | CHF=X        |
+| AUDUSD   | AUD/USD       | AUD/USD      | OANDA:AUD_USD    | AUDUSD=X     |
+| USDCAD   | USD/CAD       | USD/CAD      | OANDA:USD_CAD    | CAD=X        |
+| NZDUSD   | NZD/USD       | NZD/USD      | OANDA:NZD_USD    | NZDUSD=X     |
+| GBPJPY   | GBP/JPY       | GBP/JPY      | OANDA:GBP_JPY    | GBPJPY=X     |
+| EURJPY   | EUR/JPY       | EUR/JPY      | OANDA:EUR_JPY    | EURJPY=X     |
+| EURGBP   | EUR/GBP       | EUR/GBP      | OANDA:EUR_GBP    | EURGBP=X     |
+| CADCHF   | CAD/CHF       | CAD/CHF      | OANDA:CAD_CHF    | CADCHF=X     |
+| AUDNZD   | AUD/NZD       | AUD/NZD      | OANDA:AUD_NZD    | AUDNZD=X     |
+| USDVND   | USD/VND       | —            | —                | VND=X        |
+| USDHKD   | USD/HKD       | USD/HKD      | —                | HKD=X        |
+| USDSGD   | USD/SGD       | USD/SGD      | —                | SGD=X        |
+| USDCNY   | USD/CNY       | USD/CNH      | —                | CNY=X        |
+| USDINR   | USD/INR       | —            | —                | INR=X        |
+| USDBRL   | USD/BRL       | —            | —                | BRL=X        |
+
+### 7. CHỈ SỐ (Stock Indices) — 20 mã
+| Mã         | Tên                  | yfinance   | Ghi chú         |
+|------------|----------------------|------------|-----------------|
+| SP500      | S&P 500              | ^GSPC      | Chuẩn Mỹ        |
+| NASDAQ     | Nasdaq Composite     | ^IXIC      |                 |
+| NASDAQ100  | Nasdaq 100           | ^NDX       |                 |
+| DOW30      | Dow Jones 30         | ^DJI       |                 |
+| RUSSELL2000| Russell 2000         | ^RUT       | Small-cap Mỹ   |
+| VIX        | VIX Fear Index       | ^VIX       |                 |
+| VNINDEX    | VN-Index (HOSE)      | ^VNINDEX   | Việt Nam        |
+| HNX30      | HNX 30               | ^HNX30     | Việt Nam        |
+| UK100      | FTSE 100             | ^FTSE      | Anh             |
+| DAX40      | DAX 40               | ^GDAXI     | Đức             |
+| EU50       | Euro Stoxx 50        | ^STOXX50E  | Châu Âu         |
+| CAC40      | CAC 40               | ^FCHI      | Pháp            |
+| NIKKEI225  | Nikkei 225           | ^N225      | Nhật Bản        |
+| HSI        | Hang Seng            | ^HSI       | Hong Kong       |
+| SSE50      | SSE 50               | 000016.SS  | Trung Quốc      |
+| CSI300     | CSI 300              | 000300.SS  | Trung Quốc      |
+| ASX200     | ASX 200              | ^AXJO      | Úc              |
+| SENSEX     | BSE Sensex           | ^BSESN     | Ấn Độ           |
+| KOSPI      | KOSPI                | ^KS11      | Hàn Quốc        |
+| SGX        | Straits Times        | ^STI       | Singapore       |
+
+### 8. CỔ PHIẾU MỸ (US Stocks) — 21 mã
+AAPL, MSFT, NVDA, GOOGL, AMZN, META, TSLA, AVGO, JPM, V, MA,
+XOM, WMT, BAC, GS, AMD, INTC, NFLX, DIS, COIN, MSTR
+→ Tất cả dùng yfinance + Finnhub + Twelvedata (ticker trực tiếp)
+
+### 9. CỔ PHIẾU VIỆT NAM (VN Stocks) — 25 mã (yfinance .VN suffix)
+Ngân hàng: VCB, BID, CTG, TCB, MBB, VPB, ACB, HDB, SHB, STB
+Công nghệ: FPT
+Bất động sản: VIC, VHM
+FMCG: VNM, MSN, SAB
+Năng lượng/CN: GAS, PLX, POW, HPG, DGC
+Tiêu dùng: MWG
+Chứng khoán: SSI, VND, HCM
+
+### 10. TRÁI PHIẾU & LÃI SUẤT (Bonds & Rates) — 5 mã
+| Mã     | Tên                  | yfinance     | Ghi chú                |
+|--------|----------------------|--------------|------------------------|
+| US10Y  | Trái phiếu Mỹ 10 năm | ^TNX        | Chuẩn lãi suất toàn cầu|
+| US02Y  | Trái phiếu Mỹ 2 năm  | ^IRX        |                        |
+| US30Y  | Trái phiếu Mỹ 30 năm | ^TYX        |                        |
+| DE10Y  | Bund Đức 10 năm      | ^DE10YT=RR  |                        |
+| JP10Y  | JGB Nhật 10 năm      | ^JP10YT=RR  |                        |
+
+═══════════════════════════════════════════════════════════════════════
+## C. API ENDPOINTS v4.0
+═══════════════════════════════════════════════════════════════════════
+
+### Dữ liệu lịch sử
+GET  /api/symbols               → Danh sách tất cả mã (có thể lọc theo category)
+GET  /api/search?q=gold         → Tìm kiếm mờ (fuzzy search)
+GET  /api/historical/{symbol}   → Nến OHLCV (interval, limit)
+GET  /api/indicators/{symbol}   → Chỉ báo kỹ thuật (RSI, MACD, BB, EMA, ATR)
+
+### Giá thực tế
+GET  /api/ticker/{symbol}       → Giá cuối + 24h stats
+POST /api/watchlist/tickers     → Batch ticker cho danh mục
+GET  /api/crypto/market         → Top N crypto theo vốn hoá (CoinGecko)
+WS   /ws/price/{symbol}         → WebSocket stream giá thực tế (5s)
+
+### AI Forecast
+GET  /api/forecast/{symbol}     → Dự báo Kronos (horizon, quantiles 10/50/90)
+
+### Thị trường
+GET  /api/market-status         → Trạng thái mở/đóng cửa các sàn thế giới
+
+### Cache & Admin
+POST   /api/switch              → Xoá cache khi đổi symbol/interval
+DELETE /api/cache/{sym}/{iv}    → Xoá cache cụ thể
+DELETE /api/cache               → Xoá tất cả cache
+GET    /api/cache/stats         → Thống kê cache
+GET    /api/health              → Trạng thái server
+
+═══════════════════════════════════════════════════════════════════════
+## D. CÀI ĐẶT & CHẠY
+═══════════════════════════════════════════════════════════════════════
+
+# 1. Cài đặt dependencies
+pip install -r requirements.txt
+
+# 2. Cài pytz (cần cho market-status)
+pip install pytz
+
+# 3. Chạy server
+uvicorn main:app --host 0.0.0.0 --port 8000 --reload
+
+# 4. Xem API docs
+http://localhost:8000/docs
+
+# 5. Kiểm tra health
+curl http://localhost:8000/api/health
+
+# 6. Test lấy giá vàng
+curl "http://localhost:8000/api/historical/XAUUSD?interval=1h&limit=100"
+
+# 7. Test chỉ báo kỹ thuật BTC
+curl "http://localhost:8000/api/indicators/BTCUSD?interval=4h"
+
+# 8. Test thị trường đang mở
+curl http://localhost:8000/api/market-status

app.py

@@ -0,0 +1,7 @@
+import os
+import uvicorn
+from backend.main import app
+
+if __name__ == "__main__":
+    # Hugging Face Spaces yêu cầu ứng dụng phải chạy trên cổng 7860
+    uvicorn.run(app, host="0.0.0.0", port=7860)

backend/launcher.py

@@ -0,0 +1,71 @@
+import sys
+import os
+import time
+import webbrowser
+import threading
+import uvicorn
+import logging
+
+# Set up professional logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(message)s",
+)
+logger = logging.getLogger("super-ai-launcher")
+
+# ASCII Art Header
+BANNER = r"""
+  ____  _   _ ____  _____ ____      _    ___      _    _   _    _    _  __   ______ ___ ____  
+ / ___|| | | |  _ \| ____|  _ \    / \  |_ _|    / \  | \ | |  / \  | | \ \ / / ___|_ _/ ___| 
+ \___ \| | | | |_) |  _| | |_) |  / _ \  | |    / _ \ |  \| | / _ \ | |  \ V /\___ \ | \___ \ 
+  ___) | |_| |  __/| |___|  _ <  / ___ \ | |   / ___ \| |\  |/ ___ \| |___| |  ___) | |  ___) |
+ |____/ \___/|_|   |_____|_| \_\/_/   \_\___| /_/   \_\_| \_/_/   \_\_____|_| |____/___|____/ 
+
+ ══════════════════════════════════════════════════════════════════════════════════════════════
+  TRADING INTELLIGENT TERMINAL - AI PHÂN TÍCH BIỂU ĐỒ NẾN SỐ 1 THẾ GIỚI
+ ══════════════════════════════════════════════════════════════════════════════════════════════
+"""
+
+def print_banner():
+    # Clear console for a clean startup
+    os.system('cls' if os.name == 'nt' else 'clear')
+    print("\033[96m" + BANNER + "\033[0m")
+    print(" [*] Đang khởi động hệ thống phân tích AI...")
+    print(" [*] Đang nạp cơ sở dữ liệu thị trường...")
+    print(" [*] Hệ thống sẽ tự động mở trình duyệt sau khi hoàn tất.")
+    print(" ══════════════════════════════════════════════════════════════════════════════════════════════\n")
+
+# Import the FastAPI app
+try:
+    from main import app
+except ImportError:
+    # If running from within the backend folder
+    sys.path.append(os.path.dirname(__file__))
+    from main import app
+
+def open_browser():
+    """Wait for the server to start and then open the browser."""
+    # Give the server a few seconds to initialize
+    time.sleep(2.5)
+    url = "http://127.0.0.1:8000"
+    logger.info(f"Kết nối thành công! Đang mở bảng điều khiển tại {url}...")
+    webbrowser.open(url)
+
+if __name__ == "__main__":
+    print_banner()
+    
+    # Start the browser opener in a separate thread
+    threading.Thread(target=open_browser, daemon=True).start()
+    
+    # Run the uvicorn server
+    logger.info("Khởi động Backend Core...")
+    try:
+        # Hide the detailed uvicorn logs for a cleaner professional feel, 
+        # or keep them for transparency. Let's use 'warning' level for uvicorn 
+        # but keep our own logs at 'info'.
+        uvicorn.run(app, host="127.0.0.1", port=8000, log_level="warning")
+    except Exception as e:
+        logger.error(f"Lỗi khởi động hệ thống: {e}")
+        print("\n [!] Có lỗi xảy ra trong quá trình khởi động.")
+        print(" [!] Nhấn Enter để xem chi tiết lỗi và thoát...")
+        input()

frontend/index.html

@@ -0,0 +1,2217 @@
+<!doctype html>
+<html lang="vi">
+
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Super AI Analysis · AI phân tích biểu đồ nến số 1 thế giới hiện tại được nghiên cứu bởi đại học Thanh Hoa!
+  </title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link
+    href="https://fonts.googleapis.com/css2?family=Chakra+Petch:ital,wght@0,400;0,500;0,600;0,700;1,400&family=Barlow:wght@300;400;500;600&family=Space+Mono:wght@400;700&display=swap"
+    rel="stylesheet">
+  <script src="https://unpkg.com/lightweight-charts@4.2.2/dist/lightweight-charts.standalone.production.js"></script>
+  <style>
+    /* ═══════════════════════════════════════════════
+       DESIGN TOKENS
+    ═══════════════════════════════════════════════ */
+    :root {
+      /* Base surfaces */
+      --bg-base: #02060c;
+      --bg-depth: #010409;
+      --bg-glass: rgba(2, 8, 16, 0.75);
+      --bg-glass-light: rgba(4, 12, 24, 0.55);
+      --bg-control: rgba(6, 16, 36, 0.85);
+      --bg-control-hov: rgba(12, 28, 58, 0.95);
+      --bg-active: rgba(34, 211, 238, 0.12);
+
+      /* Borders */
+      --bdr-dim: rgba(40, 80, 140, 0.15);
+      --bdr-base: rgba(50, 95, 165, 0.25);
+      --bdr-muted: rgba(50, 100, 175, 0.38);
+      --bdr-accent: rgba(34, 211, 238, 0.45);
+
+      /* Text hierarchy */
+      --txt-bright: #ffffff;
+      --txt-primary: #f1f5f9;  /* Boosted from #cbd5e1 */
+      --txt-secondary: #cbd5e1; /* Boosted from #94a3b8 */
+      --txt-muted: #64748b;    /* Boosted from #475569 */
+
+      /* Accent — cold cyan */
+      --accent: #22d3ee;
+      --accent-lo: rgba(34, 211, 238, 0.08);
+      --accent-mid: rgba(34, 211, 238, 0.25);
+      --accent-glow: rgba(34, 211, 238, 0.40);
+
+      /* Semantic */
+      --ok: #2dd4bf;
+      --err: #fb7185;
+      --warn: #fbbf24;
+
+      /* Chart series */
+      --bull: #2dd4bf;
+      --bear: #fb7185;
+
+      /* Typography */
+      --ff-display: 'Barlow', 'Chakra Petch', sans-serif;
+      --ff-ui: 'Barlow', system-ui, sans-serif;
+      --ff-mono: 'Space Mono', monospace;
+
+      /* Layout */
+      --header-h: 60px;
+      --sidebar-w: 280px;
+      --radius: 8px;
+      --radius-lg: 18px;
+
+      /* Dashboard specificity */
+      --glass-cyan: rgba(6, 18, 42, 0.85);
+      --neon-cyan: #22d3ee;
+      --neon-pink: #f472b6;
+      --neon-green: #34d399;
+      --neon-blue: #3b82f6;
+    }
+
+    /* ═══════════════════════════════════════════════
+       RESET
+    ═══════════════════════════════════════════════ */
+    *,
+    *::before,
+    *::after {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    html,
+    body {
+      width: 100%;
+      height: 100%;
+      overflow: hidden;
+      background: var(--bg-base);
+      color: var(--txt-primary);
+      font-family: var(--ff-ui);
+      font-size: 13px;
+      -webkit-font-smoothing: antialiased;
+      -moz-osx-font-smoothing: grayscale;
+    }
+
+    /* ═══════════════════════════════════════════════
+       BACKGROUND SYSTEM
+       Layers (bottom→top):
+         1. Solid base color
+         2. Radial centre-glow (very subtle)
+         3. Dot matrix
+         4. Corner nebulae (pseudo)
+         5. Vignette overlay
+    ═══════════════════════════════════════════════ */
+    body {
+      background:
+        /* vignette */
+        radial-gradient(ellipse 130% 100% at 50% 50%,
+          transparent 55%, rgba(1, 4, 12, 0.92) 100%),
+        /* top-left ambient nebula */
+        radial-gradient(ellipse 60% 40% at -5% -5%,
+          rgba(16, 80, 180, 0.12) 0%, transparent 65%),
+        /* bottom-right ambient nebula */
+        radial-gradient(ellipse 55% 38% at 105% 105%,
+          rgba(0, 150, 180, 0.10) 0%, transparent 65%),
+        /* centre elevation */
+        radial-gradient(ellipse 100% 80% at 50% 20%,
+          rgba(6, 20, 50, 0.60) 0%, transparent 70%),
+        /* dot grid */
+        radial-gradient(circle, rgba(34, 211, 238, 0.055) 1px, transparent 1px),
+        /* solid base */
+        var(--bg-base);
+      background-size:
+        100% 100%,
+        100% 100%,
+        100% 100%,
+        100% 100%,
+        28px 28px,
+        100% 100%;
+    }
+
+    /* ═══════════════════════════════════════════════
+       APP SHELL
+    ═══════════════════════════════════════════════ */
+    #app {
+      display: flex;
+      flex-direction: column;
+      width: 100%;
+      height: 100%;
+      position: relative;
+    }
+
+    .app-body {
+      display: flex;
+      flex: 1;
+      overflow: hidden;
+      position: relative;
+    }
+
+    /* ── SIDEBAR ────────────────────────────────── */
+    .sidebar {
+      width: var(--sidebar-w);
+      background: var(--bg-depth);
+      border-right: 1px solid var(--bdr-dim);
+      display: flex;
+      flex-direction: column;
+      flex-shrink: 0;
+      z-index: 15;
+      transition: transform 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    }
+
+    .sidebar.collapsed {
+      transform: translateX(-100%);
+      margin-right: calc(var(--sidebar-w) * -1);
+    }
+
+    /* Floating Tab Trigger */
+    .sidebar-trigger {
+      position: absolute;
+      left: 0;
+      top: 50%;
+      transform: translateY(-50%);
+      width: 28px;
+      height: 80px;
+      background: var(--bg-depth);
+      border: 1px solid var(--bdr-accent);
+      border-left: none;
+      border-radius: 0 8px 8px 0;
+      display: none;
+      align-items: center;
+      justify-content: center;
+      cursor: pointer;
+      z-index: 20;
+      transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
+      box-shadow: 4px 0 15px rgba(0, 0, 0, 0.5);
+    }
+
+    .sidebar-trigger:hover {
+      background: var(--bg-active);
+      width: 32px;
+      box-shadow: 0 0 20px var(--accent-glow);
+    }
+
+    .sidebar-trigger span {
+      writing-mode: vertical-lr;
+      transform: rotate(180deg);
+      font-size: 0.7rem;
+      font-weight: 700;
+      letter-spacing: 0.15em;
+      text-transform: uppercase;
+      color: var(--accent);
+      white-space: nowrap;
+    }
+
+    .sidebar-head {
+      height: 48px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 0 16px;
+      border-bottom: 1px solid var(--bdr-dim);
+      background: rgba(255, 255, 255, 0.02);
+    }
+
+    .sidebar-title {
+      font-family: var(--ff-display);
+      font-size: 0.75rem;
+      font-weight: 700;
+      letter-spacing: 0.15em;
+      text-transform: uppercase;
+      color: var(--txt-primary);
+    }
+
+    .sidebar-content {
+      flex: 1;
+      overflow-y: auto;
+      padding: 12px;
+    }
+
+    /* Market Overview List */
+    .market-list {
+      display: flex;
+      flex-direction: column;
+      gap: 1px;
+    }
+
+    .market-item {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      padding: 10px 12px;
+      border-radius: var(--radius);
+      cursor: pointer;
+      transition: background 0.2s;
+    }
+
+    .market-item:hover {
+      background: rgba(255, 255, 255, 0.05);
+    }
+
+    .market-item.active {
+      background: var(--bg-active);
+      border: 1px solid var(--bdr-accent);
+    }
+
+    .m-sym {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+    }
+
+    .m-ticker {
+      font-family: var(--ff-mono);
+      font-size: 0.85rem;
+      font-weight: 700;
+      color: var(--txt-bright);
+    }
+
+    .m-name {
+      font-size: 0.72rem;
+      color: var(--txt-secondary);
+    }
+
+    .m-price-box {
+      text-align: right;
+    }
+
+    .m-price {
+      font-family: var(--ff-mono);
+      font-size: 0.85rem;
+      font-weight: 600;
+      color: var(--txt-bright);
+    }
+
+    .m-change {
+      font-size: 0.72rem;
+      font-weight: 700;
+    }
+
+    .m-change.up { color: var(--ok); }
+    .m-change.down { color: var(--err); }
+
+
+    /* ═══════════════════════════════════════════════
+       HEADER
+    ═══════════════════════════════════════════════ */
+    .hdr {
+      height: var(--header-h);
+      flex-shrink: 0;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 16px;
+      padding: 0 20px 0 18px;
+      background: var(--bg-glass);
+      backdrop-filter: blur(20px) saturate(160%);
+      -webkit-backdrop-filter: blur(20px) saturate(160%);
+      border-bottom: 1px solid var(--bdr-dim);
+      position: relative;
+      z-index: 20;
+      animation: hdr-slide-in 0.5s ease both;
+    }
+
+    /* thin accent line bottom */
+    .hdr::after {
+      content: '';
+      position: absolute;
+      bottom: -1px;
+      left: 0;
+      right: 0;
+      height: 1px;
+      background: linear-gradient(90deg,
+          transparent 0%, var(--accent-mid) 20%,
+          var(--accent-mid) 80%, transparent 100%);
+      pointer-events: none;
+    }
+
+    @keyframes hdr-slide-in {
+      from {
+        transform: translateY(-100%);
+        opacity: 0;
+      }
+
+      to {
+        transform: translateY(0);
+        opacity: 1;
+      }
+    }
+
+    /* ── Logo ─────────────────────────────────────── */
+    .logo {
+      display: flex;
+      align-items: center;
+      gap: 11px;
+      flex-shrink: 0;
+    }
+
+    .logo-mark {
+      position: relative;
+      width: 48px;
+      height: 48px;
+      flex-shrink: 0;
+    }
+
+    .logo-mark svg {
+      width: 100%;
+      height: 100%;
+      filter: drop-shadow(0 0 6px var(--accent-glow));
+    }
+
+    .logo-text {
+      display: flex;
+      flex-direction: column;
+      gap: 1px;
+    }
+
+    .logo-name {
+      font-family: var(--ff-display);
+      font-size: 1.45rem;
+      font-weight: 700;
+      letter-spacing: 0.12em;
+      color: #ffffff;
+      line-height: 1;
+      background: linear-gradient(90deg, #ffffff 0%, #a8f4ff 60%, #ffffff 100%);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      background-clip: text;
+    }
+
+    .logo-name span {
+      font-weight: 700;
+      letter-spacing: 0.12em;
+      opacity: 1;
+    }
+
+    .logo-sub {
+      font-size: 0.78rem;
+      font-family: var(--ff-ui);
+      font-weight: 400;
+      letter-spacing: 0.05em;
+      color: #ffffff;
+      line-height: 1.2;
+    }
+
+    /* ── Divider ──────────────────────────────────── */
+    .hdr-divider {
+      width: 1px;
+      height: 28px;
+      background: var(--bdr-base);
+      flex-shrink: 0;
+    }
+
+    /* ── Controls bar ─────────────────────────────── */
+    .ctrls {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      flex: 1;
+      justify-content: flex-end;
+    }
+
+    /* Search Omnibox */
+    .omnibox {
+      position: relative;
+      width: 320px;
+    }
+
+    .omnibox input {
+      width: 100%;
+      height: 38px;
+      background: var(--bg-control);
+      border: 1px solid var(--bdr-base);
+      border-radius: var(--radius);
+      padding: 0 12px;
+      padding-left: 36px;
+      color: var(--txt-bright);
+      font-family: var(--ff-ui);
+      font-size: 0.9rem;
+      outline: none;
+      transition: all 0.22s;
+    }
+
+    .omnibox input:focus {
+      border-color: var(--accent);
+      box-shadow: 0 0 0 3px var(--accent-lo);
+      background: var(--bg-control-hov);
+    }
+
+    .omnibox i {
+      position: absolute;
+      left: 12px;
+      top: 50%;
+      transform: translateY(-50%);
+      color: var(--txt-secondary);
+      pointer-events: none;
+    }
+
+    .search-results {
+      position: absolute;
+      top: 100%;
+      left: 0;
+      right: 0;
+      margin-top: 8px;
+      background: var(--bg-glass);
+      backdrop-filter: blur(20px);
+      border: 1px solid var(--bdr-muted);
+      border-radius: var(--radius);
+      box-shadow: 0 10px 25px rgba(0, 0, 0, 0.5);
+      max-height: 400px;
+      overflow-y: auto;
+      z-index: 100;
+      display: none;
+    }
+
+    .search-results.visible {
+      display: block;
+    }
+
+    .search-item {
+      padding: 10px 14px;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      cursor: pointer;
+      transition: background 0.15s;
+    }
+
+    .search-item:hover {
+      background: rgba(255, 255, 255, 0.08);
+    }
+
+    .search-item .sym {
+      font-family: var(--ff-mono);
+      font-weight: 700;
+      color: var(--accent);
+    }
+
+    .search-item .name {
+      font-size: 0.8rem;
+      color: var(--txt-secondary);
+    }
+
+    .market-status-bar {
+      display: flex;
+      align-items: center;
+      gap: 16px;
+      margin-right: 20px;
+    }
+
+    .m-stat {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 0.72rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+
+    .m-stat .pulse {
+      width: 6px;
+      height: 6px;
+      border-radius: 50%;
+    }
+
+    .m-stat.open { color: var(--ok); }
+    .m-stat.open .pulse { background: var(--ok); box-shadow: 0 0 8px var(--ok); }
+    .m-stat.closed { color: var(--txt-muted); }
+    .m-stat.closed .pulse { background: var(--txt-muted); }
+
+
+    .ctrl-unit {
+      display: flex;
+      flex-direction: column;
+      gap: 3px;
+    }
+
+    .ctrl-label {
+      font-family: var(--ff-display);
+      font-size: 0.78rem;
+      font-weight: 500;
+      letter-spacing: 0.18em;
+      color: #ffffff;
+      text-transform: uppercase;
+      padding-left: 2px;
+      line-height: 1;
+    }
+
+    /* unified form control look */
+    .k-select,
+    .k-input {
+      height: var(--ctrl-h);
+      background: var(--bg-control);
+      border: 1px solid var(--bdr-base);
+      color: var(--txt-bright);
+      padding: 0 10px;
+      border-radius: var(--radius);
+      font-family: var(--ff-ui);
+      font-size: 0.95rem;
+      font-weight: 500;
+      outline: none;
+      cursor: pointer;
+      transition:
+        border-color 0.22s ease,
+        background 0.22s ease,
+        box-shadow 0.22s ease;
+      appearance: none;
+      -webkit-appearance: none;
+    }
+
+    .k-select {
+      background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='6' fill='none'%3E%3Cpath d='M1 1l4 4 4-4' stroke='%235080a8' stroke-width='1.4' stroke-linecap='round'/%3E%3C/svg%3E");
+      background-repeat: no-repeat;
+      background-position: right 9px center;
+      padding-right: 28px;
+    }
+
+    .k-select optgroup {
+      background: #060d20;
+      color: var(--txt-secondary);
+      font-size: 0.75rem;
+    }
+
+    .k-select option {
+      background: #060d20;
+      color: var(--txt-bright);
+    }
+
+    .k-select:hover,
+    .k-input:hover,
+    .k-select:focus,
+    .k-input:focus {
+      border-color: var(--bdr-accent);
+      background: var(--bg-control-hov);
+      box-shadow: 0 0 0 3px var(--accent-lo), inset 0 0 0 1px var(--accent-lo);
+    }
+
+    #symbolSelect {
+      width: 280px;
+    }
+
+    #timeframeSelect {
+      width: 110px;
+    }
+
+    #horizonInput {
+      width: 90px;
+      text-align: center;
+      font-family: var(--ff-mono);
+      font-size: 0.95rem;
+    }
+
+    /* primary button */
+    .btn-primary {
+      height: var(--ctrl-h);
+      padding: 0 18px;
+      background: linear-gradient(135deg, rgba(34, 211, 238, 0.18) 0%, rgba(34, 211, 238, 0.10) 100%);
+      border: 1px solid var(--bdr-accent);
+      color: var(--accent);
+      border-radius: var(--radius);
+      font-family: var(--ff-display);
+      font-size: 0.95rem;
+      font-weight: 700;
+      letter-spacing: 0.12em;
+      text-transform: uppercase;
+      cursor: pointer;
+      transition:
+        background 0.22s ease,
+        box-shadow 0.22s ease,
+        transform 0.14s ease,
+        border-color 0.22s ease;
+      white-space: nowrap;
+    }
+
+    .btn-primary:hover {
+      background: linear-gradient(135deg, rgba(34, 211, 238, 0.30) 0%, rgba(34, 211, 238, 0.18) 100%);
+      box-shadow: var(--glow-accent);
+      border-color: var(--accent);
+    }
+
+    .btn-primary:active {
+      transform: scale(0.97);
+    }
+
+    .btn-primary:disabled {
+      opacity: 0.35;
+      cursor: not-allowed;
+      box-shadow: none;
+      transform: none;
+      border-color: var(--bdr-dim);
+    }
+
+    /* secondary icon button */
+    .btn-icon {
+      height: var(--ctrl-h);
+      width: var(--ctrl-h);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: var(--bg-control);
+      border: 1px solid var(--bdr-base);
+      color: var(--txt-secondary);
+      border-radius: var(--radius);
+      cursor: pointer;
+      font-size: 0.90rem;
+      line-height: 1;
+      transition:
+        border-color 0.22s,
+        background 0.22s,
+        color 0.22s,
+        box-shadow 0.22s,
+        transform 0.14s;
+    }
+
+    .btn-icon:hover {
+      border-color: var(--bdr-muted);
+      background: var(--bg-control-hov);
+      color: var(--txt-bright);
+    }
+
+    .btn-icon:active {
+      transform: scale(0.93);
+    }
+
+    /* ═══════════════════════════════════════════════
+       MAIN CHART AREA
+    ═══════════════════════════════════════════════ */
+    .main {
+      flex: 1;
+      position: relative;
+      overflow: hidden;
+      /* subtle inner top shadow */
+      box-shadow: inset 0 8px 24px rgba(0, 0, 0, 0.35);
+    }
+
+    /* ═══════════════════════════════════════════════
+       ANALYSIS DASHBOARD v6.0 — 3 GAUGE HERO
+    ═══════════════════════════════════════════════ */
+    .analysis-panel {
+      position: absolute;
+      inset: 0;
+      z-index: 100;
+      width: 100%;
+      height: 100%;
+      padding: 0;
+      background: rgba(2, 6, 14, 0.98);
+      backdrop-filter: blur(50px) saturate(220%);
+      -webkit-backdrop-filter: blur(50px) saturate(220%);
+      display: none; /* FULL HIDE */
+      flex-direction: column;
+      overflow: hidden;
+      animation: dash-in 0.5s cubic-bezier(0.16, 1, 0.3, 1) both;
+    }
+    .analysis-panel.active {
+      display: flex;
+    }
+    @keyframes dash-in {
+      from { opacity: 0; transform: scale(0.98); }
+      to   { opacity: 1; transform: scale(1); }
+    }
+
+    /* ── Dashboard Header ── */
+    .dash-header {
+      display: flex; align-items: center; justify-content: space-between;
+      padding: 20px 40px; flex-shrink: 0;
+      border-bottom: 1px solid rgba(255,255,255,0.08);
+      background: linear-gradient(180deg, rgba(255,255,255,0.03) 0%, rgba(255,255,255,0.01) 100%);
+    }
+    .dash-header-left { display: flex; align-items: center; gap: 14px; }
+    .dash-logo-dot {
+      width: 16px; height: 16px; border-radius: 50%;
+      background: linear-gradient(135deg, #22d3ee, #3b82f6);
+      box-shadow: 0 0 14px rgba(34,211,238,0.6);
+      animation: dot-breathe 2.5s ease-in-out infinite;
+    }
+    @keyframes dot-breathe {
+      0%,100% { box-shadow: 0 0 8px rgba(34,211,238,0.4); }
+      50% { box-shadow: 0 0 22px rgba(34,211,238,0.8); }
+    }
+    .dash-title {
+      font-family: var(--ff-display); font-size: 1.6rem; font-weight: 800;
+      color: #ffffff; letter-spacing: 0.12em; text-transform: uppercase;
+    }
+    .dash-subtitle {
+      font-size: 1rem; color: rgba(255,255,255,0.5); margin-left: 15px;
+      letter-spacing: 0.08em;
+    }
+    .dash-close {
+      width: 40px; height: 40px; display: flex; align-items: center; justify-content: center;
+      cursor: pointer; color: rgba(255,255,255,0.4); border-radius: 10px;
+      border: 1px solid rgba(255,255,255,0.08); background: rgba(255,255,255,0.03);
+      transition: all 0.2s;
+    }
+    .dash-close:hover { background: rgba(255,255,255,0.1); color: #fff; border-color: rgba(255,255,255,0.2); }
+
+    /* ── Dashboard Body — top gauges + bottom tables ── */
+    .dash-body {
+      flex: 1; display: flex; flex-direction: column; overflow: hidden;
+    }
+
+    /* ── TOP: 3 Big Gauges Row ── */
+    .dash-gauges-hero {
+      display: flex; justify-content: center; align-items: stretch;
+      gap: 0; flex-shrink: 0;
+      border-bottom: 1px solid rgba(255,255,255,0.06);
+    }
+    .gauge-hero-card {
+      flex: 1; min-width: 0;
+      display: flex; flex-direction: column; align-items: center;
+      justify-content: center; gap: 15px;
+      padding: 40px 30px;
+      border-right: 1px solid rgba(255,255,255,0.08);
+      transition: all 0.4s cubic-bezier(0.16, 1, 0.3, 1);
+      position: relative;
+    }
+    .gauge-hero-card:last-child { border-right: none; }
+    .gauge-hero-card:hover { background: rgba(255,255,255,0.03); transform: translateY(-4px); }
+    .gauge-hero-card.hero-total {
+      background: linear-gradient(180deg, rgba(34, 211, 238, 0.08) 0%, rgba(2,6,14,0) 100%);
+    }
+    .gauge-hero-card.hero-total::before {
+      content: ''; position: absolute; top: 0; left: 10%; right: 10%; height: 4px;
+      background: linear-gradient(90deg, transparent, var(--accent), transparent);
+      border-radius: 4px;
+      box-shadow: 0 0 20px var(--accent-glow);
+    }
+
+    .gauge-hero-title {
+      font-family: var(--ff-display); font-size: 1.3rem; font-weight: 800;
+      color: rgba(255,255,255,0.9); text-transform: uppercase;
+      letter-spacing: 0.22em; text-align: center;
+    }
+    .gauge-hero-title.title-total {
+      font-size: 1.55rem; color: #ffffff;
+      text-shadow: 0 0 35px rgba(34,211,238,0.5);
+    }
+    .gauge-hero-svg-wrap {
+      position: relative;
+      width: 320px; height: 220px;
+      display: flex; align-items: center; justify-content: center;
+    }
+    .gauge-hero-value-box {
+      position: absolute;
+      top: 62%; left: 50%;
+      transform: translate(-50%, -50%);
+      display: flex; flex-direction: column; align-items: center;
+    }
+    .gauge-hero-value-num {
+      font-family: var(--ff-display); font-size: 2.2rem; font-weight: 900;
+      color: #fff; line-height: 1;
+      text-shadow: 0 0 20px rgba(255,255,255,0.3);
+    }
+    .gauge-hero-value-label {
+      font-size: 0.7rem; font-weight: 700; color: rgba(255,255,255,0.4);
+      text-transform: uppercase; letter-spacing: 0.1em; margin-top: 4px;
+    }
+
+    .gauge-hero-signal {
+      font-family: var(--ff-display); font-size: 1.8rem; font-weight: 900;
+      text-transform: uppercase; letter-spacing: 0.15em;
+      text-shadow: 0 0 20px rgba(0,0,0,0.5);
+      margin-top: 5px;
+    }
+    .gauge-hero-signal.strong-buy { color: #22c55e; text-shadow: 0 0 15px rgba(34, 197, 94, 0.4); }
+    .gauge-hero-signal.buy { color: #86efac; }
+    .gauge-hero-signal.strong-sell { color: #ef4444; text-shadow: 0 0 15px rgba(239, 68, 68, 0.4); }
+    .gauge-hero-signal.sell { color: #fca5a5; }
+    .gauge-hero-signal.neutral { color: #cbd5e1; }
+    .gauge-hero-signal.signal-total { font-size: 2.2rem; }
+    .gauge-hero-counts {
+      display: flex; gap: 20px; font-size: 0.8rem; color: rgba(255,255,255,0.4);
+      letter-spacing: 0.02em;
+    }
+    .gauge-hero-counts .ghc-label { text-transform: uppercase; font-weight: 600; }
+    .gauge-hero-counts .ghc-value {
+      font-family: var(--ff-mono); font-weight: 900;
+      font-size: 1.1rem; color: #ffffff; display: block;
+      margin-top: 2px;
+    }
+
+    /* ── BOTTOM: Data Tables Grid ── */
+    .dash-tables-row {
+      flex: 1; display: grid; overflow: hidden;
+      grid-template-columns: 1fr 1fr 1fr;
+      gap: 0;
+    }
+    .dash-col {
+      display: flex; flex-direction: column;
+      border-right: 1px solid rgba(255,255,255,0.04);
+      overflow: hidden;
+    }
+    .dash-col:last-child { border-right: none; }
+
+    .dc-header {
+      padding: 14px 20px; flex-shrink: 0;
+      border-bottom: 1px solid rgba(255,255,255,0.06);
+      background: rgba(255,255,255,0.018);
+      font-family: var(--ff-display);
+      font-size: 0.85rem; font-weight: 800; color: #ffffff;
+      text-transform: uppercase; letter-spacing: 0.12em;
+    }
+
+    .dash-table-wrap {
+      flex: 1; overflow-y: auto; overflow-x: hidden;
+    }
+    .dash-table-wrap::-webkit-scrollbar { width: 3px; }
+    .dash-table-wrap::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.08); border-radius: 10px; }
+
+    .dt { width: 100%; border-collapse: collapse; }
+    .dt td {
+      padding: 9px 18px; font-size: 0.88rem;
+      border-bottom: 1px solid rgba(255,255,255,0.03);
+    }
+    .dt td:first-child { color: rgba(255,255,255,0.8); font-weight: 500; }
+    .dt .dt-val {
+      font-family: var(--ff-mono); font-weight: 700; color: #ffffff; text-align: right;
+    }
+    .dt .dt-act {
+      font-weight: 800; text-align: right; font-size: 0.85rem; letter-spacing: 0.03em;
+    }
+    .dt-act-buy  { color: #60a5fa !important; }
+    .dt-act-sell { color: #fb7185 !important; }
+    .dt-act-neut { color: rgba(255,255,255,0.3) !important; }
+
+    .pivot-table { width: 100%; border-collapse: collapse; }
+    .pivot-table th {
+      padding: 8px 10px; font-size: 0.7rem; font-weight: 800;
+      color: rgba(255,255,255,0.4); text-transform: uppercase;
+      letter-spacing: 0.08em; text-align: center;
+      border-bottom: 1px solid rgba(255,255,255,0.06);
+    }
+    .pivot-table td {
+      padding: 7px 10px; font-family: var(--ff-mono); font-size: 0.85rem;
+      font-weight: 600; color: #ffffff; text-align: center;
+      border-bottom: 1px solid rgba(255,255,255,0.025);
+    }
+    .pivot-table td:first-child {
+      font-weight: 800; color: rgba(255,255,255,0.55); font-family: var(--ff-ui);
+      text-align: left; padding-left: 18px;
+    }
+
+    .summary-disclaimer {
+      padding: 10px 20px;
+      font-size: 0.72rem; color: rgba(255,255,255,0.25); line-height: 1.5;
+      border-top: 1px solid rgba(255,255,255,0.04);
+      text-align: center; flex-shrink: 0;
+    }
+    .summary-disclaimer strong { color: rgba(255,255,255,0.4); }
+
+    /* ── Loading state ── */
+    .dash-loading {
+      display: flex; flex-direction: column; align-items: center; justify-content: center;
+      height: 100%; gap: 16px; color: rgba(255,255,255,0.4);
+    }
+    .dash-loading .loader-ring { border-top-color: var(--accent); }
+    .dash-loading p { font-size: 0.9rem; letter-spacing: 0.05em; animation: loader-pulse 1.4s ease-in-out infinite; }
+
+    /* Dashboard responsive */
+    @media (max-width: 1200px) {
+      .dash-tables-row { grid-template-columns: 1fr 1fr; }
+      .dash-col.col-pivots { display: none; }
+      .gauge-hero-card { padding: 20px 14px 18px; }
+      .gauge-hero-svg-wrap { width: 180px; height: 108px; }
+    }
+    @media (max-width: 800px) {
+      .dash-gauges-hero { flex-direction: column; }
+      .gauge-hero-card { border-right: none; border-bottom: 1px solid rgba(255,255,255,0.05); }
+      .dash-tables-row { grid-template-columns: 1fr; }
+    }
+
+    #chart {
+      position: absolute;
+      inset: 0;
+      width: 100%;
+      height: 100%;
+      z-index: 5;
+    }
+
+    /* Futuristic AI Overlay */
+    .chart-bg-overlay {
+      position: absolute;
+      inset: 0;
+      pointer-events: none;
+      z-index: 1;
+      opacity: 0.17;
+      background-image: url('ai_analysis_bg.png');
+      background-size: contain;
+      background-repeat: no-repeat;
+      background-position: left bottom;
+      mask-image: linear-gradient(to right, black 20%, transparent 80%);
+      -webkit-mask-image: linear-gradient(to right, black 20%, transparent 80%);
+    }
+
+    .chart-logo-overlay {
+      position: absolute;
+      bottom: 35px;
+      right: 85px;
+      pointer-events: none;
+      z-index: 2;
+      font-family: var(--ff-display);
+      font-size: 2.2rem;
+      font-weight: 700;
+      letter-spacing: 0.25em;
+      line-height: 1;
+      background: linear-gradient(180deg, #fff 0%, var(--accent) 50%, #0a4d5c 100%);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      background-clip: text;
+      filter: drop-shadow(0 0 15px rgba(34, 211, 238, 0.45));
+      opacity: 0.55;
+      text-transform: uppercase;
+      white-space: nowrap;
+    }
+
+    /* ── Terminal Loader Overlay (Strict Isolation) ── */
+    .terminal-loader-overlay {
+      position: absolute;
+      inset: 0 !important;
+      width: 100% !important;
+      height: 100% !important;
+      display: none; /* FULL HIDE */
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      background: rgba(1, 4, 12, 0.98);
+      backdrop-filter: blur(50px) saturate(200%);
+      -webkit-backdrop-filter: blur(50px) saturate(200%);
+      z-index: 9999;
+      opacity: 0;
+      transition: opacity 0.5s ease;
+    }
+
+    .terminal-loader-overlay.active {
+      display: flex;
+      opacity: 1;
+    }
+
+    .loader-inner {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 14px;
+    }
+
+    .loader-ring {
+      width: 42px;
+      height: 42px;
+      border-radius: 50%;
+      border: 1.5px solid var(--bdr-dim);
+      border-top-color: var(--accent);
+      animation: spin 0.8s linear infinite;
+    }
+
+    @keyframes spin {
+      to {
+        transform: rotate(360deg);
+      }
+    }
+
+    .loader-text {
+      font-family: var(--ff-display);
+      font-size: 0.68rem;
+      letter-spacing: 0.22em;
+      color: var(--txt-secondary);
+      text-transform: uppercase;
+      animation: loader-pulse 1.4s ease-in-out infinite;
+    }
+
+    @keyframes loader-pulse {
+
+      0%,
+      100% {
+        opacity: 0.4;
+      }
+
+      50% {
+        opacity: 1;
+      }
+    }
+
+    /* ═══════════════════════════════════════════════
+       STATUS OVERLAY
+    ═══════════════════════════════════════════════ */
+    .status-wrap {
+      position: absolute;
+      top: 16px;
+      left: 16px;
+      z-index: 10;
+      pointer-events: none;
+      animation: fade-in 0.6s 0.3s ease both;
+    }
+
+    @keyframes fade-in {
+      from {
+        opacity: 0;
+        transform: translateY(-6px);
+      }
+
+      to {
+        opacity: 1;
+        transform: translateY(0);
+      }
+    }
+
+    .status-pill {
+      display: inline-flex;
+      align-items: center;
+      gap: 9px;
+      padding: 7px 14px 7px 10px;
+      background: var(--bg-glass);
+      backdrop-filter: blur(14px) saturate(160%);
+      -webkit-backdrop-filter: blur(14px) saturate(160%);
+      border: 1px solid var(--bdr-dim);
+      border-radius: 20px;
+      transition: border-color 0.3s ease;
+    }
+
+    .status-pill.ok {
+      border-color: rgba(45, 212, 170, 0.30);
+    }
+
+    .status-pill.error {
+      border-color: rgba(240, 96, 112, 0.30);
+    }
+
+    .status-pill.loading {
+      border-color: rgba(34, 211, 238, 0.28);
+    }
+
+    .dot {
+      width: 7px;
+      height: 7px;
+      border-radius: 50%;
+      background: var(--txt-muted);
+      flex-shrink: 0;
+      transition: background 0.3s, box-shadow 0.3s;
+    }
+
+    .dot.ok {
+      background: var(--ok);
+      box-shadow: 0 0 8px var(--ok-glow);
+    }
+
+    .dot.error {
+      background: var(--err);
+      box-shadow: 0 0 8px var(--err-glow);
+    }
+
+    .dot.loading {
+      background: var(--accent);
+      box-shadow: 0 0 8px var(--accent-glow);
+      animation: dot-pulse 1.2s ease-in-out infinite;
+    }
+
+    @keyframes dot-pulse {
+
+      0%,
+      100% {
+        transform: scale(0.85);
+        opacity: 0.5;
+      }
+
+      50% {
+        transform: scale(1.20);
+        opacity: 1.0;
+      }
+    }
+
+    .status-label {
+      font-family: var(--ff-ui);
+      font-size: 0.72rem;
+      font-weight: 500;
+      color: var(--txt-primary);
+      letter-spacing: 0.02em;
+      white-space: nowrap;
+    }
+
+    /* ═══════════════════════════════════════════════
+       SCROLLBAR
+    ═══════════════════════════════════════════════ */
+    ::-webkit-scrollbar {
+      width: 4px;
+      height: 4px;
+    }
+
+    ::-webkit-scrollbar-track {
+      background: transparent;
+    }
+
+    ::-webkit-scrollbar-thumb {
+      background: var(--bdr-base);
+      border-radius: 2px;
+    }
+
+    ::-webkit-scrollbar-thumb:hover {
+      background: var(--txt-muted);
+    }
+
+    /* ═══════════════════════════════════════════════
+       RESPONSIVE
+    ═══════════════════════════════════════════════ */
+    @media (max-width: 960px) {
+      .ctrl-label {
+        display: none;
+      }
+
+      .ctrl-unit {
+        flex-direction: row;
+        align-items: center;
+      }
+
+      #symbolSelect {
+        width: 150px;
+      }
+
+      .logo-sub {
+        display: none;
+      }
+    }
+
+    @media (max-width: 680px) {
+      .hdr {
+        padding: 0 12px;
+        gap: 8px;
+      }
+
+      .logo-sub {
+        display: none;
+      }
+
+      .hdr-divider {
+        display: none;
+      }
+
+      #symbolSelect {
+        width: 130px;
+      }
+
+      #timeframeSelect {
+        width: 60px;
+      }
+
+      #horizonInput {
+        width: 56px;
+      }
+
+      .btn-primary {
+        padding: 0 12px;
+        font-size: 0.68rem;
+        letter-spacing: 0.06em;
+      }
+    }
+  </style>
+</head>
+
+<body>
+  <div id="app">
+
+    <!-- ── HEADER ───────────────────────────────── -->
+    <header class="hdr">
+
+      <!-- Logo -->
+      <div class="logo">
+        <div class="logo-mark">
+          <!-- Stylised K hexagon mark -->
+          <svg viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+            <polygon points="16,2 28,9 28,23 16,30 4,23 4,9" stroke="rgba(34,211,238,0.55)" stroke-width="1"
+              fill="rgba(34,211,238,0.06)" />
+            <polygon points="16,6 24,11 24,21 16,26 8,21 8,11" stroke="rgba(34,211,238,0.22)" stroke-width="0.5"
+              fill="none" />
+            <!-- AI shape -->
+            <path d="M9,22 L13,10 L17,22 M10.5,18 L15.5,18" stroke="#22d3ee" stroke-width="1.8" stroke-linecap="round"
+              stroke-linejoin="round" />
+            <line x1="22" y1="10" x2="22" y2="22" stroke="#22d3ee" stroke-width="1.8" stroke-linecap="round" />
+            <!-- corner accents -->
+            <circle cx="16" cy="2" r="1" fill="rgba(34,211,238,0.5)" />
+            <circle cx="28" cy="9" r="1" fill="rgba(34,211,238,0.3)" />
+            <circle cx="4" cy="23" r="1" fill="rgba(34,211,238,0.3)" />
+          </svg>
+        </div>
+        <!-- Market Status -->
+        <div class="market-status-bar" id="marketStatusBar"></div>
+      </div>
+
+      <div class="hdr-divider"></div>
+
+      <!-- Controls -->
+      <div class="ctrls">
+
+        <button class="btn-icon" id="toggleMarketBtn" title="Ẩn/Hiện Thị trường">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <line x1="3" y1="12" x2="21" y2="12"></line>
+            <line x1="3" y1="6" x2="21" y2="6"></line>
+            <line x1="3" y1="18" x2="21" y2="18"></line>
+          </svg>
+        </button>
+
+        <!-- Omnibox Search -->
+        <div class="omnibox">
+          <i><svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line></svg></i>
+          <input type="text" id="symbolSearch" placeholder="Tìm kiếm mã (VD: Gold, BTC, AAPL...)" autocomplete="off">
+          <div class="search-results" id="searchResults"></div>
+        </div>
+
+        <div class="ctrl-unit">
+          <span class="ctrl-label">Khung thời gian</span>
+          <select class="k-select" id="timeframeSelect">
+            <option>1m</option>
+            <option>5m</option>
+            <option>15m</option>
+            <option>1h</option>
+            <option>4h</option>
+            <option selected>1d</option>
+            <option>1w</option>
+          </select>
+        </div>
+
+        <div class="ctrl-unit">
+          <span class="ctrl-label">Dự báo (nến)</span>
+          <input class="k-input" id="horizonInput" type="number" min="5" max="300" value="10" />
+        </div>
+
+        <div class="ctrl-unit">
+          <span class="ctrl-label">Chỉ báo</span>
+          <select class="k-select" id="indicatorSelect" style="width: 140px;">
+            <option value="none">Không có</option>
+            <option value="bb">Bollinger Bands</option>
+            <option value="rsi">RSI (14)</option>
+            <option value="both">Cả hai</option>
+          </select>
+        </div>
+
+        <button class="btn-primary" id="refreshBtn">Phân tích</button>
+
+
+        <button class="btn-icon" id="fitBtn" title="Khớp toàn bộ dữ liệu">
+          <!-- expand icon -->
+          <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+            <path d="M1 5V1h4M9 1h4v4M13 9v4H9M5 13H1V9" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"
+              stroke-linejoin="round" />
+          </svg>
+        </button>
+
+      </div>
+    </header>
+
+    <!-- ── BODY ──────────────────────────────── -->
+    <div class="app-body">
+      <div class="sidebar-trigger" id="reopenSidebarBtn" title="Mở danh sách thị trường">
+        <span>Thị trường</span>
+      </div>
+      
+      <!-- Side Sidebar (Market Overview) -->
+      <aside class="sidebar" id="sidebar">
+        <div class="sidebar-head">
+          <span class="sidebar-title">Thị trường</span>
+          <button class="btn-icon" id="toggleSidebarBtn" style="width: 28px; height: 28px; border: none; background: transparent;">
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+              <polyline points="15 18 9 12 15 6"></polyline>
+            </svg>
+          </button>
+        </div>
+        <div class="sidebar-content">
+          <div class="market-list" id="marketOverview">
+            <!-- Market items will be injected here -->
+          </div>
+        </div>
+      </aside>
+
+      <!-- Main Area -->
+      <main class="main">
+
+        <!-- Status badge -->
+        <div class="status-wrap">
+          <div class="status-pill" id="statusPill">
+            <div class="dot" id="statusDot"></div>
+            <span class="status-label" id="statusText">Hệ thống sẵn sàng</span>
+          </div>
+        </div>
+
+        <!-- Terminal Loading overlay -->
+        <div class="terminal-loader-overlay" id="terminalLoader">
+          <div class="loader-inner">
+            <div class="loader-ring"></div>
+            <div class="loader-text" id="loaderText">Hệ thống đang nạp dữ liệu...</div>
+          </div>
+        </div>
+
+        <!-- Futuristic Overlays -->
+        <div class="chart-bg-overlay"></div>
+        <div class="chart-logo-overlay">KRONOS AI</div>
+
+        <!-- Chart canvas -->
+        <div id="chart"></div>
+
+        <aside class="analysis-panel hidden" id="analysisPanel"></aside>
+
+      </main>
+    </div>
+  </div>
+
+  <!-- ══════════════════════════════════════════════
+       JAVASCRIPT — all original logic preserved
+  ══════════════════════════════════════════════ -->
+  <script>
+    const API_BASE = (window.location.origin && window.location.origin !== 'null')
+      ? window.location.origin
+      : 'http://127.0.0.1:8000';
+
+    /* ── DOM refs ──────────────────────────────── */
+    /* ── DOM refs ──────────────────────────────── */
+    const symbolSearch = document.getElementById('symbolSearch');
+    const searchResults = document.getElementById('searchResults');
+    const timeframeSelect = document.getElementById('timeframeSelect');
+    const horizonInput = document.getElementById('horizonInput');
+    const refreshBtn = document.getElementById('refreshBtn');
+    const fitBtn = document.getElementById('fitBtn');
+    const statusText = document.getElementById('statusText');
+    const statusDot = document.getElementById('statusDot');
+    const statusPill = document.getElementById('statusPill');
+    const terminalLoader = document.getElementById('terminalLoader');
+    const loaderText = document.getElementById('loaderText');
+    const analysisPanel = document.getElementById('analysisPanel');
+    const sidebar = document.getElementById('sidebar');
+    const toggleSidebarBtn = document.getElementById('toggleSidebarBtn');
+    const marketOverview = document.getElementById('marketOverview');
+    const marketStatusBar = document.getElementById('marketStatusBar');
+    const indicatorSelect = document.getElementById('indicatorSelect');
+
+    /* ── State ─────────────────────────────────── */
+    let currentSymbol = 'XAUUSD';
+    let currentInterval = '1d';
+    let ws = null;
+    let fetchController = null;
+    const symbolMap = new Map();
+    const timeframeMap = {
+      '1m': '1 Phút', '5m': '5 Phút', '15m': '15 Phút',
+      '1h': '1 Giờ', '4h': '4 Giờ', '1d': '1 Ngày', '1w': '1 Tuần'
+    };
+
+    /* ── Indicator Calculation Helpers ────────── */
+    /* ── WebSocket Management ────────────────────── */
+    function connectWS(symbol) {
+      if (ws) {
+        ws.close();
+        ws = null;
+      }
+
+      const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+      const wsUrl = `${API_BASE.replace(/^https?:\/\//, wsProtocol)}/ws/price/${symbol}`;
+      
+      console.log(`[WS] Connecting to ${wsUrl}`);
+      ws = new WebSocket(wsUrl);
+
+      ws.onmessage = (event) => {
+        const data = JSON.parse(event.data);
+        if (data.error) return;
+
+        // Update current candle if price changed
+        const lastCandle = lastCandleData;
+        if (lastCandle && data.price) {
+          const update = {
+            time: lastCandle.time,
+            open: lastCandle.open,
+            high: Math.max(lastCandle.high, data.price),
+            low: Math.min(lastCandle.low, data.price),
+            close: data.price
+          };
+          candleSeries.update(update);
+          lastCandleData = update;
+        }
+
+        // Update overview items if they exist
+        updateOverviewItem(data);
+      };
+
+      ws.onclose = () => {
+        console.log('[WS] Disconnected');
+        // Reconnect after 5s if still active
+        setTimeout(() => {
+          if (currentSymbol === symbol) connectWS(symbol);
+        }, 5000);
+      };
+    }
+
+    let lastCandleData = null;
+
+    /* ── Market Status & Overview ────────────────── */
+    async function refreshMarketStatus() {
+      try {
+        const data = await apiRequest('/api/market-status');
+        marketStatusBar.innerHTML = data.markets.map(m => `
+          <div class="m-stat ${m.status}">
+            <div class="pulse"></div>
+            <span>${m.market}</span>
+          </div>
+        `).join('');
+      } catch (e) {
+        console.warn('Market status fetch failed', e);
+      }
+    }
+
+    async function refreshOverview() {
+      try {
+        const symbol = currentSymbol || 'BTCUSD';
+        const data = await apiRequest(`/api/market-peers?symbol=${symbol}`);
+        renderOverview(`${data.category.toUpperCase()} LIÊN QUAN`, data.peers);
+      } catch (e) {
+        console.warn('Overview fetch failed', e);
+      }
+    }
+
+    function renderOverview(categoryLabel, peers) {
+      marketOverview.innerHTML = `
+        <div style="font-size:0.65rem; color:var(--txt-muted); margin-bottom:8px; padding-left:12px;">${categoryLabel}</div>
+        ${peers.map(p => `
+          <div class="market-item ${p.symbol === currentSymbol ? 'active' : ''}" onclick="switchSymbol('${p.symbol}')" id="overview-${p.symbol}">
+            <div class="m-sym">
+              <span class="m-ticker">${p.symbol}</span>
+              <span class="m-name">${p.name}</span>
+            </div>
+            <div class="m-price-box">
+              <div class="m-price">${formatPrice(p.price)}</div>
+              <div class="m-change ${p.change_24h >= 0 ? 'up' : 'down'}">${formatPct(p.change_24h)}</div>
+            </div>
+          </div>
+        `).join('')}
+      `;
+    }
+
+    function updateOverviewItem(data) {
+      const itemPrice = document.querySelector(`#overview-${data.symbol} .m-price`);
+      const itemChange = document.querySelector(`#overview-${data.symbol} .m-change`);
+      if (itemPrice) itemPrice.textContent = formatPrice(data.price);
+      if (itemChange) {
+        itemChange.textContent = formatPct(data.change_pct);
+        itemChange.className = `m-change ${data.change_pct >= 0 ? 'up' : 'down'}`;
+      }
+    }
+
+    /* ── Search Logic ───────────────────────────── */
+    let searchTimeout = null;
+    symbolSearch.oninput = (e) => {
+      clearTimeout(searchTimeout);
+      const q = e.target.value.trim();
+      if (!q) {
+        searchResults.classList.remove('visible');
+        return;
+      }
+      searchTimeout = setTimeout(async () => {
+        try {
+          const data = await apiRequest(`/api/search?q=${encodeURIComponent(q)}`);
+          renderSearchResults(data.results);
+        } catch (e) {
+          console.error('Search failed', e);
+        }
+      }, 300);
+    };
+
+    function renderSearchResults(results) {
+      if (!results.length) {
+        searchResults.classList.remove('visible');
+        return;
+      }
+      searchResults.innerHTML = results.map(r => `
+        <div class="search-item" onclick="switchSymbol('${r.symbol}')">
+          <span class="sym">${r.symbol}</span>
+          <span class="name">${r.label}</span>
+        </div>
+      `).join('');
+      searchResults.classList.add('visible');
+    }
+
+    /* ── Switch Logic ───────────────────────────── */
+    async function switchSymbol(symbol) {
+      currentSymbol = symbol;
+      symbolSearch.value = symbol;
+      searchResults.classList.remove('visible');
+      
+      // Update labels immediately for better UX responsiveness
+      const sLabel = symbolMap.get(symbol) || symbol;
+      updateStatus(`${sLabel} · ${currentInterval} — Đang nạp...`, 'loading');
+
+      // Update active state in sidebar
+      document.querySelectorAll('.market-item').forEach(el => el.classList.remove('active'));
+      const activeItem = document.getElementById(`overview-${symbol}`);
+      if (activeItem) activeItem.classList.add('active');
+
+      await refreshChart();
+      refreshOverview();
+      connectWS(symbol);
+    }
+
+    /* ── Chart init ────────────────────────────── */
+    const chartEl = document.getElementById('chart');
+
+    const chart = LightweightCharts.createChart(chartEl, {
+      layout: {
+        background: { type: 'solid', color: 'transparent' },
+        textColor: 'rgba(100, 150, 200, 0.85)',
+        fontSize: 11,
+        fontFamily: "'Space Mono', 'Courier New', monospace",
+      },
+      grid: {
+        vertLines: { visible: false },
+        horzLines: { visible: false },
+      },
+      rightPriceScale: {
+        borderColor: 'rgba(40, 80, 140, 0.25)',
+        autoScale: true,
+        scaleMargins: { top: 0.08, bottom: 0.08 },
+      },
+      timeScale: {
+        borderColor: 'rgba(40, 80, 140, 0.25)',
+        timeVisible: true,
+        secondsVisible: false,
+        fixLeftEdge: false,
+        fixRightEdge: false,
+      },
+      crosshair: {
+        mode: LightweightCharts.CrosshairMode.Normal,
+        vertLine: {
+          color: 'rgba(34, 211, 238, 0.35)',
+          width: 1,
+          labelBackgroundColor: '#040d1e',
+        },
+        horzLine: {
+          color: 'rgba(34, 211, 238, 0.35)',
+          width: 1,
+          labelBackgroundColor: '#040d1e',
+        },
+      },
+      watermark: {
+        visible: true,
+        fontSize: 64,
+        horzAlign: 'center',
+        vertAlign: 'center',
+        color: 'rgba(34, 211, 238, 0.04)',
+        text: 'Super AI Analysis',
+      },
+      handleScroll: true,
+      handleScale: true,
+    });
+
+    /* ── Series ────────────────────────────────── */
+    const candleSeries = chart.addCandlestickSeries({
+      upColor: '#1dba8a',
+      downColor: '#e05560',
+      borderVisible: false,
+      wickUpColor: '#1dba8a',
+      wickDownColor: '#e05560',
+    });
+
+    const p50Series = chart.addLineSeries({
+      color: '#22d3ee',
+      lineWidth: 2,
+      title: 'Dự báo AI',
+      priceLineVisible: false,
+      lastValueVisible: true,
+      visible: false,
+    });
+
+    const p10Series = chart.addLineSeries({
+      color: 'rgba(34, 211, 238, 0.22)',
+      lineWidth: 1,
+      lineStyle: LightweightCharts.LineStyle.Dashed,
+      priceLineVisible: false,
+      lastValueVisible: false,
+      visible: false,
+    });
+
+    const p90Series = chart.addLineSeries({
+      color: 'rgba(34, 211, 238, 0.22)',
+      lineWidth: 1,
+      lineStyle: LightweightCharts.LineStyle.Dashed,
+      priceLineVisible: false,
+      lastValueVisible: false,
+      visible: false,
+    });
+
+    /* ── Indicator Series ──────────────────────── */
+    const bbMiddleSeries = chart.addLineSeries({ color: 'rgba(255, 255, 255, 0.2)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false });
+    const bbUpperSeries = chart.addLineSeries({ color: 'rgba(34, 211, 238, 0.3)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false });
+    const bbLowerSeries = chart.addLineSeries({ color: 'rgba(34, 211, 238, 0.3)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false });
+
+    let rsiSeries = null;
+
+    /* ── Status helpers ────────────────────────── */
+    /* ── UI Sync & Loader helpers ──────────────── */
+    function clearAllOverlays() {
+      // Unify state by hiding all primary overlays
+      terminalLoader.classList.remove('active');
+      analysisPanel.classList.remove('active');
+      searchResults.classList.remove('visible');
+    }
+
+    function showLoader(msg = 'Đang tải dữ liệu') {
+      loaderText.textContent = msg;
+      terminalLoader.classList.add('active');
+    }
+
+    function hideLoader() {
+      terminalLoader.classList.remove('active');
+    }
+
+    function updateStatus(msg, type = '') {
+      statusText.textContent = msg;
+      statusDot.className = 'dot ' + type;
+      statusPill.className = 'status-pill ' + type;
+    }
+
+    function formatPrice(value) {
+      if (value === null || value === undefined || Number.isNaN(Number(value))) return '--';
+      return Number(value).toLocaleString('en-US', { maximumFractionDigits: 4 });
+    }
+
+    function formatPct(value) {
+      if (value === null || value === undefined || Number.isNaN(Number(value))) return '--';
+      const num = Number(value);
+      const sign = num > 0 ? '+' : '';
+      return `${sign}${num.toFixed(2)}%`;
+    }
+
+    function formatRR(value) {
+      if (value === null || value === undefined || Number.isNaN(Number(value))) return '--';
+      return `${Number(value).toFixed(2)}R`;
+    }
+
+    /* ── State for cached analysis data ──────────── */
+    let lastAnalysisPayload = null;
+    let lastAnalysisSymbol = null;
+    let lastAnalysisInterval = null;
+
+    /* ── Fullscreen Dashboard v6.0 — 3 Gauge Hero ──── */
+    function renderAnalysisPanel(symbol, interval, payload) {
+      // Cache the payload for toggle reuse
+      if (payload?.analysis) {
+        lastAnalysisPayload = payload;
+        lastAnalysisSymbol = symbol;
+        lastAnalysisInterval = interval;
+      }
+
+      if (!payload?.analysis) {
+        analysisPanel.innerHTML = `
+          <div class="dash-loading">
+            <div class="loader-ring" style="width:42px;height:42px;border-radius:50%;border:1.5px solid rgba(40,80,140,0.15);border-top-color:var(--accent);animation:spin 0.8s linear infinite;"></div>
+            <p>Nhấn "Phân tích" để hiển thị bảng phân tích kỹ thuật</p>
+          </div>
+        `;
+        return;
+      }
+
+      const a = payload.analysis;
+      if (!a.oscillators && !a.moving_averages) {
+        analysisPanel.innerHTML = '<div class="dash-loading"><div class="loader-ring" style="width:42px;height:42px;border-radius:50%;border:1.5px solid rgba(40,80,140,0.15);border-top-color:var(--accent);animation:spin 0.8s linear infinite;"></div><p>Đang tính toán...</p></div>';
+        return;
+      }
+
+      const osc = a.oscillators || { sell:0, neutral:0, buy:0, signal:'--', data:[] };
+      const ma = a.moving_averages || { sell:0, neutral:0, buy:0, signal:'--', data:[] };
+      const summary = a.summary || { sell:0, neutral:0, buy:0, signal:'--' };
+      const pivots = (a.pivot_points || {}).data || [];
+
+      // ── AI Forecast calculation ──
+      const confidence = payload.ensemble?.confidence ?? 0;
+      const forecastRows = payload.forecast || [];
+      const lastClose = payload.last_close || 0;
+      let forecastEnd = lastClose;
+      if (forecastRows.length > 1) {
+        forecastEnd = forecastRows[forecastRows.length - 1]?.p50 ?? lastClose;
+      }
+      const forecastPctChange = lastClose > 0 ? ((forecastEnd - lastClose) / lastClose) * 100 : 0;
+
+      // ── Compute AI Forecast as Buy/Sell gauge ──
+      // Map forecast % change to a score: >0 = buy, <0 = sell
+      // Strength determines strong/weak
+      const absChange = Math.abs(forecastPctChange);
+      let aiBuy = 0, aiSell = 0, aiNeutral = 0;
+      if (forecastPctChange > 0.5) {
+        aiBuy = absChange > 2 ? 2 : 1;
+        aiNeutral = absChange > 2 ? 0 : 1;
+      } else if (forecastPctChange < -0.5) {
+        aiSell = absChange > 2 ? 2 : 1;
+        aiNeutral = absChange > 2 ? 0 : 1;
+      } else {
+        aiNeutral = 1;
+      }
+      const aiTotal = aiBuy + aiSell + aiNeutral;
+      let aiSignal = 'Trung lập';
+      if (forecastPctChange > 2) aiSignal = 'Mua mạnh';
+      else if (forecastPctChange > 0.5) aiSignal = 'Mua';
+      else if (forecastPctChange < -2) aiSignal = 'Bán mạnh';
+      else if (forecastPctChange < -0.5) aiSignal = 'Bán';
+
+      // ── TỔNG KẾT = (Phân tích kỹ thuật + Dự báo AI) / 2 ──
+      const techTotal = (summary.buy + summary.sell + summary.neutral) || 1;
+      const techScore = (summary.buy - summary.sell) / techTotal; // -1 to +1
+      const aiScore = forecastPctChange > 0.5 ? Math.min(forecastPctChange / 5, 1) :
+                      forecastPctChange < -0.5 ? Math.max(forecastPctChange / 5, -1) : 0;
+      const combinedScore = (techScore + aiScore) / 2; // -1 to +1
+
+      // Map combined score to buy/sell/neutral counts for gauge
+      let totalBuy = 0, totalSell = 0, totalNeutral = 0;
+      if (combinedScore > 0.15) { totalBuy = Math.round(Math.abs(combinedScore) * 10); totalNeutral = 10 - totalBuy; }
+      else if (combinedScore < -0.15) { totalSell = Math.round(Math.abs(combinedScore) * 10); totalNeutral = 10 - totalSell; }
+      else { totalNeutral = 10; }
+
+      let totalSignal = 'Trung lập';
+      if (combinedScore > 0.4) totalSignal = 'Mua mạnh';
+      else if (combinedScore > 0.15) totalSignal = 'Mua';
+      else if (combinedScore < -0.4) totalSignal = 'Bán mạnh';
+      else if (combinedScore < -0.15) totalSignal = 'Bán';
+
+      // ── Big SVG Gauge builder (Fix Clipping + Add Value) ──
+      function buildBigGauge(sell, neutral, buy, signal, w=320, h=220) {
+        const total = sell + neutral + buy || 1;
+        const score = (buy - sell) / total;
+        const displayValue = Math.round((score + 1) * 50);
+        const angle = score * 135;
+        const cx = w/2, cy = h * 0.52, r = (w/2) * 0.72; // Adjusted r and cy to prevent clipping
+        const strokeW = 18;
+        function arc(s, e, col) {
+          const sa = (s-90)*Math.PI/180, ea = (e-90)*Math.PI/180;
+          const x1=cx+r*Math.cos(sa), y1=cy+r*Math.sin(sa), x2=cx+r*Math.cos(ea), y2=cy+r*Math.sin(ea);
+          return `<path d="M${x1},${y1} A${r},${r} 0 ${(e-s)>180?1:0} 1 ${x2},${y2}" fill="none" stroke="${col}" stroke-width="${strokeW}" stroke-linecap="round" opacity="0.8"/>`;
+        }
+        // Needle
+        const na = (angle-90)*Math.PI/180, nl = r + 5;
+        const nx = cx+nl*Math.cos(na), ny = cy+nl*Math.sin(na);
+        // Needle dynamic color
+        const needleColor = score > 0.3 ? '#4ade80' : score > 0.1 ? '#bbf7d0' : score < -0.3 ? '#f87171' : score < -0.1 ? '#fecaca' : '#f1f5f9';
+        
+        return `
+          <div class="gauge-hero-value-box">
+            <div class="gauge-hero-value-num">${displayValue}</div>
+            <div class="gauge-hero-value-label">Chỉ số</div>
+          </div>
+          <svg width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">
+            <defs>
+              <filter id="needle-glow"><feGaussianBlur stdDeviation="6" result="blur"/><feMerge><feMergeNode in="blur"/><feMergeNode in="SourceGraphic"/></feMerge></filter>
+            </defs>
+            <!-- Arc segments -->
+            ${arc(-135,-81,'#ef4444')}${arc(-81,-27,'#fca5a5')}${arc(-27,27,'#f1f5f9')}${arc(27,81,'#bbf7d0')}${arc(81,135,'#22c55e')}
+            <!-- Labels -->
+            <text x="${cx + r*Math.cos((-135-90)*Math.PI/180)*1.35}" y="${cy + r*Math.sin((-135-90)*Math.PI/180)*1.35}" fill="rgba(255,255,255,0.3)" font-size="10" text-anchor="middle" font-family="var(--ff-display)" font-weight="900">BÁN</text>
+            <text x="${cx + r*Math.cos((135-90)*Math.PI/180)*1.35}" y="${cy + r*Math.sin((135-90)*Math.PI/180)*1.35}" fill="rgba(255,255,255,0.3)" font-size="10" text-anchor="middle" font-family="var(--ff-display)" font-weight="900">MUA</text>
+            <!-- Needle -->
+            <line x1="${cx}" y1="${cy}" x2="${nx}" y2="${ny}" stroke="${needleColor}" stroke-width="7" stroke-linecap="round" filter="url(#needle-glow)"/>
+            <circle cx="${cx}" cy="${cy}" r="14" fill="${needleColor}" />
+            <circle cx="${cx}" cy="${cy}" r="7" fill="#fff" />
+          </svg>
+        `;
+      }
+
+      function signalClass(signal) {
+        if (signal.includes('Mua mạnh')) return 'strong-buy';
+        if (signal.includes('Mua')) return 'buy';
+        if (signal.includes('Bán mạnh')) return 'strong-sell';
+        if (signal.includes('Bán')) return 'sell';
+        return 'neutral';
+      }
+
+      function actCls(act) {
+        return act === 'Mua' ? 'dt-act-buy' : act === 'Bán' ? 'dt-act-sell' : 'dt-act-neut';
+      }
+
+      const oscRows = osc.data.map(d => `<tr><td>${d.name}</td><td class="dt-val">${d.value !== null ? d.value : '—'}</td><td class="dt-act ${actCls(d.action)}">${d.action}</td></tr>`).join('');
+      const maRows = ma.data.map(d => `<tr><td>${d.name}</td><td class="dt-val">${d.value !== null ? d.value : '—'}</td><td class="dt-act ${actCls(d.action)}">${d.action}</td></tr>`).join('');
+      const pivotRows = pivots.map(p => `<tr><td>${p.level}</td><td>${p.classic ?? '—'}</td><td>${p.fibonacci ?? '—'}</td><td>${p.camarilla ?? '—'}</td><td>${p.woodie ?? '—'}</td><td>${p.dm ?? '—'}</td></tr>`).join('');
+
+      const sLabel = symbolMap.get(symbol) || symbol;
+      const tLabel = timeframeMap[interval] || interval;
+
+      analysisPanel.innerHTML = `
+        <!-- Dashboard Header -->
+        <div class="dash-header">
+          <div class="dash-header-left">
+            <div class="dash-logo-dot"></div>
+            <span class="dash-title">${sLabel}</span>
+            <span class="dash-subtitle">· ${tLabel} · Bảng Phân tích Tổng hợp</span>
+          </div>
+          <div class="dash-close" id="dashCloseBtn" title="Đóng">
+            <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+              <line x1="18" y1="6" x2="6" y2="18"></line>
+              <line x1="6" y1="6" x2="18" y2="18"></line>
+            </svg>
+          </div>
+        </div>
+
+        <!-- Dashboard Body -->
+        <div class="dash-body">
+
+          <!-- TOP ROW: 3 Big Gauges -->
+          <div class="dash-gauges-hero">
+
+            <!-- Gauge 1: Phân tích kỹ thuật (was TỔNG KẾT) -->
+            <div class="gauge-hero-card">
+              <div class="gauge-hero-title">PHÂN TÍCH KỸ THUẬT</div>
+              <div class="gauge-hero-svg-wrap">
+                ${buildBigGauge(summary.sell, summary.neutral, summary.buy, summary.signal)}
+              </div>
+              <div class="gauge-hero-signal ${signalClass(summary.signal)}">${summary.signal}</div>
+              <div class="gauge-hero-counts">
+                <span><span class="ghc-label">Bán</span><span class="ghc-value">${summary.sell}</span></span>
+                <span><span class="ghc-label">Trung lập</span><span class="ghc-value">${summary.neutral}</span></span>
+                <span><span class="ghc-label">Mua</span><span class="ghc-value">${summary.buy}</span></span>
+              </div>
+            </div>
+
+            <!-- Gauge 2: Dự báo AI (Buy/Sell gauge) -->
+            <div class="gauge-hero-card">
+              <div class="gauge-hero-title">DỰ BÁO AI</div>
+              <div class="gauge-hero-svg-wrap">
+                ${buildBigGauge(aiSell, aiNeutral, aiBuy, aiSignal)}
+              </div>
+              <div class="gauge-hero-signal ${signalClass(aiSignal)}">${aiSignal}</div>
+            </div>
+
+            <!-- Gauge 3: TỔNG KẾT = (Phân tích KT + Dự báo AI) / 2 -->
+            <div class="gauge-hero-card hero-total">
+              <div class="gauge-hero-title title-total">⚡ TỔNG KẾT</div>
+              <div class="gauge-hero-svg-wrap">
+                ${buildBigGauge(totalSell, totalNeutral, totalBuy, totalSignal)}
+              </div>
+              <div class="gauge-hero-signal signal-total ${signalClass(totalSignal)}">${totalSignal}</div>
+            </div>
+
+          </div>
+
+          <!-- BOTTOM: Data Tables -->
+          <div class="dash-tables-row">
+
+            <!-- Oscillators -->
+            <div class="dash-col">
+              <div class="dc-header">Chỉ số Dao động</div>
+              <div class="dash-table-wrap">
+                <table class="dt"><tbody>${oscRows}</tbody></table>
+              </div>
+            </div>
+
+            <!-- Moving Averages -->
+            <div class="dash-col">
+              <div class="dc-header">Trung bình trượt</div>
+              <div class="dash-table-wrap">
+                <table class="dt"><tbody>${maRows}</tbody></table>
+              </div>
+            </div>
+
+            <!-- Pivot Points -->
+            <div class="dash-col col-pivots">
+              <div class="dc-header">Điểm xoay</div>
+              <div class="dash-table-wrap">
+                <table class="pivot-table">
+                  <thead><tr><th>Mức</th><th>CL</th><th>FB</th><th>CM</th><th>WD</th><th>DM</th></tr></thead>
+                  <tbody>${pivotRows}</tbody>
+                </table>
+              </div>
+            </div>
+
+          </div>
+
+          <div class="summary-disclaimer">
+            <strong>⚠ Cảnh báo</strong> — Thông tin phân tích kỹ thuật này không phải lời khuyên đầu tư. Hãy luôn quản lý rủi ro.
+          </div>
+
+        </div>
+      `;
+
+      // Close logic
+      const closeBtn = document.getElementById('dashCloseBtn');
+      if (closeBtn) closeBtn.onclick = () => analysisPanel.classList.remove('active');
+    }
+
+
+
+    /* ── Clear chart immediately on switch ─────── */
+    function clearChartImmediate() {
+      candleSeries.setData([]);
+      p50Series.setData([]);
+      p10Series.setData([]);
+      p90Series.setData([]);
+
+      p50Series.applyOptions({ visible: false });
+      p10Series.applyOptions({ visible: false });
+      p90Series.applyOptions({ visible: false });
+      
+      // Clear indicators
+      bbMiddleSeries.setData([]);
+      bbUpperSeries.setData([]);
+      bbLowerSeries.setData([]);
+      if (rsiSeries) rsiSeries.setData([]);
+
+      // Hide dashboard and clear cached data on symbol switch
+      analysisPanel.classList.remove('active');
+      lastAnalysisPayload = null;
+      lastAnalysisSymbol = null;
+      chart.priceScale('right').applyOptions({ autoScale: true });
+
+      const symbol = currentSymbol;
+      const interval = timeframeSelect.value;
+      if (symbol && interval) {
+        fetch(`${API_BASE}/api/switch`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ symbol, interval }),
+        }).catch(e => console.warn('[switch] failed', e));
+      }
+    }
+
+    /* ── API helper ────────────────────────────── */
+    async function apiRequest(path) {
+      const sep = path.includes('?') ? '&' : '?';
+      const url = `${API_BASE}${path}${sep}_t=${Date.now()}`;
+      
+      const options = { method: 'GET' };
+      if (fetchController) options.signal = fetchController.signal;
+
+      const resp = await fetch(url, options);
+      if (!resp.ok) {
+        const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+        throw new Error(typeof err.detail === 'object'
+          ? err.detail.message || JSON.stringify(err.detail)
+          : (err.detail || 'Lỗi kết nối'));
+      }
+      return resp.json();
+    }
+
+    /* ── Load symbol list metadata ─────────────── */
+    async function loadSymbols() {
+      try {
+        const data = await apiRequest('/api/symbols');
+        data.symbols.forEach(s => symbolMap.set(s.symbol, s.label));
+        // Default overview refresh
+        refreshOverview();
+      } catch (e) {
+        updateStatus('Lỗi nạp metadata: ' + e.message, 'error');
+      }
+    }
+
+    /* ── Main refresh ──────────────────────────── */
+    async function refreshChart() {
+      const symbol = currentSymbol;
+      const interval = timeframeSelect.value;
+      const horizon = Math.max(5, Math.min(300, parseInt(horizonInput.value) || 10));
+      if (!symbol) return;
+
+      // New: Abort previous requests
+      if (fetchController) fetchController.abort();
+      fetchController = new AbortController();
+
+      refreshBtn.disabled = true;
+      // Don't auto-show dashboard panel on chart refresh
+      updateStatus(`${symbol} · ${interval} — Đang nạp dữ liệu...`, 'loading');
+
+      showLoader('Đang nạp dữ liệu...');
+
+      /* Update chart watermark */
+      const sLabel = symbolMap.get(symbol) || symbol;
+      const tLabel = timeframeMap[interval] || interval;
+      chart.applyOptions({
+        watermark: {
+          text: `${sLabel} · ${tLabel}`,
+          color: 'rgba(34, 211, 238, 0.27)',
+          fontSize: 72,
+        },
+      });
+
+      clearChartImmediate();
+
+      // Start fetching Stage 1 (Fast: OHLCV + Indicators)
+      try {
+        const [histData, indData] = await Promise.all([
+          apiRequest(`/api/historical/${encodeURIComponent(symbol)}?interval=${interval}&limit=500`),
+          apiRequest(`/api/indicators/${encodeURIComponent(symbol)}?interval=${interval}&limit=500`)
+        ]);
+
+        if (histData.data.length > 0) {
+          candleSeries.setData(histData.data);
+          lastCandleData = histData.data[histData.data.length - 1];
+        }
+
+        /* ── Indicators ── */
+        const type = indicatorSelect.value;
+        const indicators = indData.indicators || {};
+        const series = indicators.series || {};
+        
+        if (type === 'bb' || type === 'both') {
+          if (series.bb_upper) bbUpperSeries.setData(series.bb_upper);
+          if (series.bb_mid) bbMiddleSeries.setData(series.bb_mid);
+          if (series.bb_lower) bbLowerSeries.setData(series.bb_lower);
+        }
+
+        // Add RSI update if needed
+        
+        chart.timeScale().fitContent();
+        hideLoader();
+        updateStatus(`${symbol} · ${interval} | Đang nạp AI...`, 'loading');
+
+        // Trigger Stage 2 in background (Slow: AI Forecast)
+        fetchAIAnalysis(symbol, interval);
+
+      } catch (e) {
+        if (e.name === 'AbortError') return; // Ignore canceled requests
+        console.error('Stage 1 Fetch Error:', e);
+        updateStatus('Lỗi nạp dữ liệu: ' + e.message, 'error');
+      } finally {
+        refreshBtn.disabled = false;
+        hideLoader();
+      }
+    }
+
+    /* ── Stage 2: Background AI Forecast ───────────────── */
+    async function fetchAIAnalysis(symbol, interval) {
+      if (currentSymbol !== symbol) return; // Prevent race conditions
+      
+      const panel = document.getElementById('analysisPanel');
+      panel.innerHTML = `
+        <div class="dash-loading">
+          <div class="loader-ring" style="width:42px;height:42px;border-radius:50%;border:1.5px solid rgba(40,80,140,0.15);border-top-color:var(--accent);animation:spin 0.8s linear infinite;"></div>
+          <p>AI đang tính toán...</p>
+        </div>
+      `;
+      
+      try {
+        const horizon = horizonInput.value || 24;
+        const fData = await apiRequest(`/api/forecast/${encodeURIComponent(symbol)}?interval=${interval}&horizon=${horizon}`);
+        
+        if (currentSymbol !== symbol) return; // Discard if user switched
+        
+        renderAnalysisPanel(symbol, interval, fData);
+
+        let isBull = false;
+        let lastForecastVal = 0;
+
+        if (fData.error || !fData.forecast || fData.forecast.length === 0) {
+          updateStatus('AI: ' + (fData.error || 'Thiếu dữ liệu dự báo'), 'warning');
+        } else {
+          // Safeguard: Ensure we have candle data before aligning
+          if (!lastCandleData || !lastCandleData.time) {
+            updateStatus(`${symbol} · ${interval} — AI Sẵn sàng`, 'ok');
+            return; 
+          }
+
+          // Alignment Fix: Prepend the current price candle to the forecast data
+          const currentPoint = { time: lastCandleData.time, value: lastCandleData.close };
+          
+          const p50 = [currentPoint, ...fData.forecast.map(d => ({ time: d.time, value: d.p50 }))];
+          const p10 = [currentPoint, ...fData.forecast.map(d => ({ time: d.time, value: d.p10 }))];
+          const p90 = [currentPoint, ...fData.forecast.map(d => ({ time: d.time, value: d.p90 }))];
+
+          const first = p50[0]?.value ?? 0;
+          lastForecastVal = p50[p50.length - 1]?.value ?? 0;
+          isBull = lastForecastVal >= first;
+
+          const aiMain = isBull ? '#1dba8a' : '#e05560';
+          const aiBand = isBull ? 'rgba(29,186,138,0.1)' : 'rgba(224,85,96,0.1)';
+
+          p50Series.applyOptions({ color: aiMain, visible: true });
+          p10Series.applyOptions({ color: aiBand, visible: true });
+          p90Series.applyOptions({ color: aiBand, visible: true });
+
+          p50Series.setData(p50);
+          p10Series.setData(p10);
+          p90Series.setData(p90);
+        }
+
+        const trend = isBull ? '↑ TĂNG' : '↓ GIẢM';
+        const confidence = fData.analysis?.confidence ?? fData.ensemble?.confidence ?? 0;
+        if (currentSymbol !== symbol || timeframeSelect.value !== interval) return;
+        
+        updateStatus(
+          `${symbol} · ${interval}  |  AI: ${trend} (${Math.round(confidence)}%)  |  Giá: ${formatPrice(lastCandleData?.close)}`,
+          'ok'
+        );
+
+      } catch (e) {
+        if (e.name === 'AbortError') return; // Silent abort
+        console.error('Stage 2 Fetch Error:', e);
+        panel.innerHTML = `<div class="dash-loading"><p style="color:#fb7185;">Không thể kết nối AI: ${e.message}</p></div>`;
+        updateStatus('AI Offline', 'warning');
+      }
+    }
+
+    /* ── Event listeners ───────────────────────── */
+    const reopenSidebarBtn = document.getElementById('reopenSidebarBtn');
+    const toggleMarketBtn = document.getElementById('toggleMarketBtn');
+    
+    function toggleSidebar(forceOpen = null) {
+      const isCollapsed = sidebar.classList.contains('collapsed');
+      const targetState = (forceOpen !== null) ? !forceOpen : !isCollapsed;
+      
+      sidebar.classList.toggle('collapsed', targetState);
+      reopenSidebarBtn.style.display = targetState ? 'flex' : 'none';
+      
+      setTimeout(() => chart.applyOptions({ width: chartEl.clientWidth }), 300);
+    }
+
+    // Unified toggle handlers
+    toggleSidebarBtn.onclick = () => toggleSidebar(false); // Close
+    reopenSidebarBtn.onclick = () => toggleSidebar(true);  // Open
+    toggleMarketBtn.onclick = () => toggleSidebar();     // Toggle
+
+    timeframeSelect.onchange = refreshChart;
+    indicatorSelect.onchange = refreshChart;
+
+    // "Phân tích" button: toggle dashboard ON/OFF without reloading chart
+    refreshBtn.onclick = () => {
+      const isActive = analysisPanel.classList.contains('active');
+      if (!isActive) {
+        // Show dashboard — use cached data if available, or fetch fresh
+        if (lastAnalysisPayload && lastAnalysisSymbol === currentSymbol) {
+          renderAnalysisPanel(lastAnalysisSymbol, lastAnalysisInterval, lastAnalysisPayload);
+          analysisPanel.classList.add('active');
+        } else {
+          // No cached data: fetch from API without reloading chart
+          analysisPanel.classList.add('active');
+          analysisPanel.innerHTML = `
+            <div class="dash-loading">
+              <div class="loader-ring" style="width:48px;height:48px;"></div>
+              <p>Hệ thống AI đang khởi tạo dữ liệu...</p>
+            </div>
+          `;
+          fetchAIAnalysis(currentSymbol, timeframeSelect.value);
+        }
+      } else {
+        // Hide dashboard
+        analysisPanel.classList.remove('active');
+      }
+    };
+
+    fitBtn.onclick = () => chart.timeScale().fitContent();
+
+    /* ── Click out to close search ─────────────── */
+    document.addEventListener('click', (e) => {
+      if (!symbolSearch.contains(e.target) && !searchResults.contains(e.target)) {
+        searchResults.classList.remove('visible');
+      }
+    });
+
+    /* ── Resize handler ────────────────────────── */
+    const ro = new ResizeObserver(() => {
+      chart.applyOptions({
+        width: chartEl.clientWidth,
+        height: chartEl.clientHeight,
+      });
+    });
+    ro.observe(chartEl);
+
+    /* ── Bootstrap ─────────────────────────────── */
+    (async () => {
+      await loadSymbols();
+      await refreshMarketStatus();
+      
+      // Start polling
+      setInterval(refreshMarketStatus, 60000); // 1m
+      setInterval(refreshOverview, 15000);    // 15s
+
+      // Default start
+      await switchSymbol('XAUUSD');
+    })();
+  </script>
+</body>
+
+</html>

requirements.txt

@@ -0,0 +1,15 @@
+fastapi==0.136.0
+uvicorn[standard]==0.44.0
+httpx==0.28.1
+pandas==2.2.2
+numpy==2.4.4
+yfinance==1.3.0
+ccxt==4.5.49
+torch==2.11.0
+aiofiles==25.1.0
+pytz==2026.1.post1
+einops==0.8.1
+huggingface_hub==0.33.1
+matplotlib==3.9.3
+tqdm==4.67.1
+safetensors==0.6.2

run.bat

@@ -0,0 +1,73 @@
+@echo off
+setlocal EnableExtensions EnableDelayedExpansion
+cd /d "%~dp0"
+
+title Kronos AI Analysis
+
+set "PYTHONUTF8=1"
+set "PYTHONIOENCODING=utf-8"
+set "KRONOS_PRELOAD=1"
+set "VENV_DIR=%CD%\venv"
+set "VENV_PY=%VENV_DIR%\Scripts\python.exe"
+
+echo ==========================================
+echo      KRONOS AI ANALYSIS - STARTUP
+echo ==========================================
+echo.
+
+echo [1/5] Checking Python 3.11...
+py -3.11 -V >nul 2>&1
+if errorlevel 1 (
+    echo [ERROR] Python 3.11 is required but was not found.
+    echo [HINT] Install Python 3.11 and run this script again.
+    goto :end
+)
+
+echo [2/5] Checking virtual environment...
+if exist "%VENV_PY%" (
+    "%VENV_PY%" -V >nul 2>&1
+    if errorlevel 1 (
+        echo [WARN] Existing venv is invalid. Rebuilding a clean one...
+        if exist "%CD%\venv_legacy_broken" rmdir /s /q "%CD%\venv_legacy_broken"
+        ren "%VENV_DIR%" "venv_legacy_broken"
+    )
+)
+
+if not exist "%VENV_PY%" (
+    echo [INFO] Creating fresh Python 3.11 virtual environment...
+    py -3.11 -m venv "%VENV_DIR%"
+    if errorlevel 1 (
+        echo [ERROR] Failed to create virtual environment.
+        goto :end
+    )
+)
+
+set "REQUESTS_CA_BUNDLE=%VENV_DIR%\Lib\site-packages\pip\_vendor\certifi\cacert.pem"
+
+echo [3/5] Installing or verifying dependencies...
+"%VENV_PY%" -m pip install -r requirements.txt
+if errorlevel 1 (
+    echo [ERROR] Dependency installation failed.
+    goto :end
+)
+
+echo [4/5] Running Kronos runtime self-check...
+"%VENV_PY%" -c "import backend.main as m; assert m.KRONOS_AVAILABLE, 'Kronos import failed'; print('KRONOS_PATH=', m.KRONOS_PATH); print('SYMBOLS=', len(m.SYMBOLS))"
+if errorlevel 1 (
+    echo [ERROR] Backend self-check failed.
+    goto :end
+)
+
+echo [5/5] Starting backend...
+echo [INFO] Opening http://127.0.0.1:8000
+start "" http://127.0.0.1:8000
+echo.
+echo ------------------------------------------
+echo  KEEP THIS WINDOW OPEN WHILE USING THE APP
+echo  TO STOP: PRESS CTRL+C
+echo ------------------------------------------
+echo.
+"%VENV_PY%" -m uvicorn backend.main:app --host 127.0.0.1 --port 8000 --reload
+
+:end
+pause