def predict_chronos2(df, selected_features, target, prediction_length, id_column, timestamp_column, model_path='/Users/lxh-mac/Documents/models/amazon/chronos-2'):
    pipeline: Chronos2Pipeline = BaseChronosPipeline.from_pretrained(model_path, device_map="cpu")
    energy_pred_cov_df = pipeline.predict_df(
        df[[id_column, timestamp_column, target]],  # 暂时只使用目标变量，不使用协变量
        future_df=None,
        prediction_length=prediction_length,
        quantile_levels=[0.1, 0.5, 0.9],
        id_column=id_column,
        timestamp_column=timestamp_column,
        target=target,
    )
    return energy_pred_cov_df['predictions']

import pandas as pd
import numpy as np
from chronos import ChronosPipeline

# 假设有3个相关变量的数据
df = pd.DataFrame({
    'timestamp': pd.date_range('2024-01-01', periods=100, freq='H'),
    'temperature': np.random.normal(20, 5, 100),  # 温度
    'humidity': np.random.normal(60, 10, 100),     # 湿度
    'pressure': np.random.normal(1013, 5, 100)     # 气压
})

# 方法1：分别预测每个变量
def channel_independent_predict(df, target_columns, prediction_length=24):
    predictions = {}
    
    for target in target_columns:
        # 为每个变量创建独立的DataFrame
        single_var_df = df[['timestamp', target]].copy()
        single_var_df['id'] = f'series_{target}'  # 给每个序列一个独立ID
        
        # 使用Chronos预测
        pipeline = ChronosPipeline.from_pretrained("amazon/chronos-t5-small")
        forecast = pipeline.predict(
            context=single_var_df[target].values[-168:],  # 最后168个点作为历史
            prediction_length=prediction_length,
            num_samples=100  # 用于计算分位数
        )
        
        predictions[target] = forecast.mean  # 取均值预测
        predictions[f'{target}_lower'] = forecast.quantile(0.1)  # 10%分位数
        predictions[f'{target}_upper'] = forecast.quantile(0.9)  # 90%分位数
    
    # 合并所有预测结果
    results = pd.DataFrame(predictions)
    return results

# 使用
targets = ['temperature', 'humidity', 'pressure']
results = channel_independent_predict(df, targets, prediction_length=24)

import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
from chronos import ChronosTokenizer
import pandas as pd

class MultivariateChronos:
    def __init__(self, model_name="amazon/chronos-t5-large"):
        # 加载预训练模型
        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
        self.tokenizer = ChronosTokenizer.from_pretrained(model_name)
        
        # 多变量特定的配置
        self.num_variables = 3  # 变量数量
        self.context_length = 168  # 历史长度
        
    def prepare_multivariate_data(self, df, variable_columns):
        """
        将多变量数据转换为Chronos可理解的格式
        """
        # 1. 对每个变量分别归一化和分桶
        normalized_data = {}
        for var in variable_columns:
            series = df[var].values
            # 归一化（使用每个序列的均值和标准差）
            mean, std = series.mean(), series.std()
            normalized = (series - mean) / (std + 1e-8)
            normalized_data[var] = normalized
        
        # 2. 交错排列变量
        # 格式: [var1_t1, var2_t1, var3_t1, var1_t2, var2_t2, var3_t2, ...]
        multivariate_series = []
        for i in range(len(df)):
            for var in variable_columns:
                multivariate_series.append(normalized_data[var][i])
        
        return np.array(multivariate_series), {'means': means, 'stds': stds}
    
    def multivariate_tokenize(self, multivariate_series):
        """
        将交错的多变量序列转换为token
        """
        # 将连续值离散化为token
        tokens = self.tokenizer.encode(multivariate_series)
        return torch.tensor(tokens).unsqueeze(0)  # 添加batch维度
    
    def fine_tune(self, train_data, epochs=10, learning_rate=1e-4):
        """
        在多变量数据上微调Chronos
        """
        self.model.train()
        optimizer = torch.optim.AdamW(self.model.parameters(), lr=learning_rate)
        
        for epoch in range(epochs):
            total_loss = 0
            for batch in train_data:
                # 准备输入（历史多变量序列）
                inputs = self.multivariate_tokenize(batch['input_series'])
                
                # 准备目标（未来多变量序列）
                targets = self.multivariate_tokenize(batch['target_series'])
                
                # 前向传播
                outputs = self.model(input_ids=inputs, labels=targets)
                loss = outputs.loss
                
                # 反向传播
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
                
                total_loss += loss.item()
            
            print(f"Epoch {epoch+1}, Loss: {total_loss/len(train_data):.4f}")
    
    def predict_multivariate(self, context_series, prediction_length=24):
        """
        使用微调后的模型进行多变量预测
        """
        self.model.eval()
        
        # 将上下文转换为token
        context_tokens = self.multivariate_tokenize(context_series)
        
        # 自回归生成预测
        with torch.no_grad():
            generated = self.model.generate(
                input_ids=context_tokens,
                max_length=len(context_tokens[0]) + prediction_length * self.num_variables,
                num_beams=5,
                temperature=0.7,
                do_sample=True
            )
        
        # 将token解码回数值
        predictions = self.tokenizer.decode(generated[0])
        
        # 将交错的预测拆分成各个变量
        pred_array = predictions.cpu().numpy()
        pred_by_var = {}
        
        for i, var in enumerate(self.variable_names):
            # 提取该变量的所有时间步
            var_predictions = pred_array[i::self.num_variables][-prediction_length:]
            pred_by_var[var] = var_predictions
        
        return pred_by_var

# 使用示例
if __name__ == "__main__":
    # 准备数据
    data = pd.read_csv('multivariate_data.csv')
    variables = ['temperature', 'humidity', 'pressure']
    
    # 初始化多变量Chronos
    mv_chronos = MultivariateChronos()
    mv_chronos.variable_names = variables
    
    # 准备训练数据
    train_series, stats = mv_chronos.prepare_multivariate_data(data, variables)
    
    # 创建滑动窗口训练样本
    train_dataset = []
    window_size = 168  # 7天每小时
    stride = 24  # 每天
    
    for i in range(0, len(train_series) - window_size - 24*3, stride):
        input_series = train_series[i:i+window_size]
        target_series = train_series[i+window_size:i+window_size+24*3]  # 预测3天
        train_dataset.append({
            'input_series': input_series,
            'target_series': target_series
        })
    
    # 微调模型
    mv_chronos.fine_tune(train_dataset, epochs=5)
    
    # 预测
    latest_context = train_series[-168:]  # 最后168个点
    predictions = mv_chronos.predict_multivariate(latest_context, prediction_length=24)
    
    # 反归一化
    for var in variables:
        mean, std = stats['means'][var], stats['stds'][var]
        predictions[var] = predictions[var] * std + mean

class HierarchicalChronos:
    def __init__(self):
        self.aggregation_matrix = None  # 聚合矩阵
    
    def hierarchical_forecast(self, df, hierarchy):
        """
        层次预测实现
        hierarchy = {
            'total': ['region_A', 'region_B'],
            'region_A': ['store_A1', 'store_A2'],
            'region_B': ['store_B1', 'store_B2', 'store_B3']
        }
        """
        forecasts = {}
        
        # 1. 底层预测（叶子节点）
        leaf_nodes = ['store_A1', 'store_A2', 'store_B1', 'store_B2', 'store_B3']
        for leaf in leaf_nodes:
            leaf_data = df[df['store_id'] == leaf]['sales']
            forecast = self.channel_independent_predict(leaf_data)
            forecasts[leaf] = forecast
        
        # 2. 中层聚合
        for parent, children in hierarchy.items():
            if parent not in ['total']:  # 不是最顶层
                child_forecasts = [forecasts[child] for child in children]
                # 简单求和（或加权平均）
                forecasts[parent] = np.sum(child_forecasts, axis=0)
        
        # 3. 顶层聚合
        forecasts['total'] = np.sum([
            forecasts['region_A'], 
            forecasts['region_B']
        ], axis=0)
        
        # 4. 协调（使用最小二乘协调）
        reconciled = self.reconcile_forecasts(forecasts, hierarchy)
        
        return reconciled
    
    def reconcile_forecasts(self, forecasts, hierarchy):
        """使用最小二乘法协调层次预测"""
        # 构建求和矩阵S
        S = self.build_sum_matrix(hierarchy)
        
        # 构建基础预测向量
        b = np.concatenate([forecasts[node] for node in forecasts.keys()])
        
        # 最小二乘协调
        # y_reconciled = S * (S^T * S)^(-1) * S^T * b
        S_T = S.T
        reconciled = S @ np.linalg.inv(S_T @ S) @ S_T @ b
        
        return self.reshape_to_hierarchy(reconciled, hierarchy)