2017 میں ، Attention Is All You Need نامی ایک مقالہ سامنے آیا ، اور اگلے چند سالوں میں ، اب تک پیداواری AI کے پورے میدان پر قابو پالیا گیا ہے۔ اس تاریخی اور اہم مقالے میں ، 8 محققین نے پہلی بار ٹرانسفارمر کی نیورون نیٹ ورک کی تعمیر کی تجویز پیش کی ، جس میں روایتی لوپ اور وولٹیج آپریشن کو ترک کرتے ہوئے ، مکمل طور پر توجہ کے طریقہ کار پر مبنی ہے۔ خود توجہ کے ذریعہ ، ٹرانسفارمر ان پٹ سیریز میں فاصلے پر انحصار کو مؤثر طریقے سے پکڑ سکتا ہے ، جس سے ماڈل طویل متن کو سنبھالنے میں زیادہ موثر اور درست ہوجاتا ہے۔ کثیر سر توجہ کے ذریعہ ، اس نے ماڈل کی ترجمانی کی صلاحیت کو مزید بڑھا دیا ہے ، جس سے یہ ان پٹ سیریز کے مختلف حصوں پر توجہ مرکوز کرنے کے قابل بناتا ہے ، اور اسی وقت زیادہ پیچیدہ الفاظ کے تعلقات کو پکڑ سکتا ہے۔

ٹرانسفارمرز کو مالیاتی مقدار پر لاگو کرنا

ٹرانسفارمر کی بنیادی جدت خود توجہ کے طریقہ کار میں ہے ، جو تسلسل میں کسی بھی دو عناصر کے مابین انحصار کو پکڑنے کے قابل ہے ، چاہے ان کے درمیان فاصلہ کتنا ہی دور ہو۔ اس خصوصیت کی وجہ سے یہ خاص طور پر مالیاتی ٹائم سیریز کے اعداد و شمار کو سنبھالنے کے لئے موزوں ہے جس میں پیچیدہ وقت انحصار ہے۔

ٹائم سیریز کی پیشن گوئی

روایتی مالیاتی ٹائم سیریز کی پیشن گوئی کے طریقوں (جیسے ARIMA، LSTM) کو طویل مدتی انحصار کو پکڑنے میں دشواری کا سامنا کرنا پڑتا ہے، اور ٹرانسفارمر اس میں بہت اچھا کام کرتا ہے.

ملٹی فیکٹر ماڈل

ٹرانسفارمر ایک ہی وقت میں سینکڑوں عوامل کو سنبھال سکتا ہے ، خود کار طریقے سے عوامل کے مابین پیچیدہ غیر لکیری تعلقات اور ٹائمنگ کی خصوصیات سیکھتا ہے

• عنصر اہمیت تجزیہ: توجہ کے وزن کے ذریعہ اہم محرکات کی شناخت

• متحرک عنصر کی نمائش: عنصر کی تاثیر کو پکڑنے کے لئے وقت کی تبدیلی کی خصوصیات

رسک مینجمنٹ

مارکیٹ کے خطرے کی ماڈلنگ:

• VaR (رسک ویلیو) کی پیش گوئی: انتہائی مارکیٹ کے حالات میں غیر لکیری تعلقات سے نمٹنا

• اتار چڑھاؤ کی پیشن گوئی: اتار چڑھاؤ کے اجتماع کے اثرات اور بیعانہ کے اثرات کو پکڑنا

• وابستگی کی پیشن گوئی: متحرک اثاثوں کی وابستگی ماڈلنگ

پورٹ فولیو کی اصلاح

ٹرانسفارمر:

• کثیر اثاثہ، کثیر تعدد ڈیٹا

• مارکیٹ کی شناخت اور پیشن گوئی

توجہ کے وزن پر مبنی اثاثوں کا انتخاب ٹرانزیکشن پر عملدرآمد کی اصلاح:

• مارکیٹ شاک ماڈلنگ: بڑے پیمانے پر تجارت کے اثرات کی پیش گوئی

• بہترین عملدرآمد کی حکمت عملی: ٹرانزیکشن لاگت کو کم سے کم کرنا

ہائی فریکوئینسی ٹریڈنگ اور مارکیٹ مائیکرو اسٹرکچر

آرڈر کی فہرست کا تجزیہ ٹرانسفارمر اعلی تعدد آرڈر بک کے اعداد و شمار کو مؤثر طریقے سے سنبھال سکتا ہے:

• احکامات کے بہاؤ کی پیش گوئی: خرید و فروخت کے احکامات میں عدم توازن کی پیش گوئی

• قیمت کے جھٹکے کا تجزیہ: مارکیٹ کی قیمتوں پر بڑے آرڈرز کے اثرات کا اندازہ لگانا

• لیکویڈیٹی پیشن گوئی: مارکیٹ کی گہرائی میں تبدیلی کی پیشن گوئی

مارکیٹ میں ہیرا پھیری کا پتہ لگانا

ٹرانزیکشن سیریز کے نمونوں کا تجزیہ کرکے:

• اسپاؤفنگ

• پمپ اینڈ ڈمپ موڈ

• مارکیٹ میں دیگر جوڑ توڑ

جنگیں

ٹرانسفارمر خاص طور پر 5 جہتی OHLCV ٹائم سیریز کے اعداد و شمار کو سنبھالتا ہے (کھلنے کی قیمت ، سب سے زیادہ قیمت ، کم قیمت ، بند ہونے کی قیمت ، حجم):

• ان پٹ شکل: ((batch_size, seq_len=30، feature_dim=5)

• تسلسل میں وقت کے انحصار کو سیکھنے کے ذریعہ زیادہ سے زیادہ ٹائم لائن کی خصوصیات کو نکالنا

• مارکیٹ کے پیچیدہ نمونوں کو سادہ تکنیکی اشارے سے بہتر انداز میں پکڑنا

ٹرانسفارمر ماڈل کی تعریف (ٹائم سیریز ٹرانسفارمر کلاس)

class TimeSeriesTransformer(nn.Module):
    def __init__(self, input_dim=5, d_model=32, nhead=4, num_encoder_layers=2, dim_feedforward=64, dropout=0.1, num_classes=3):
        super(TimeSeriesTransformer, self).__init__()
        self.input_proj = nn.Linear(input_dim, d_model)
        encoder_layer = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout, batch_first=True)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_encoder_layers)
        self.feature_layer = nn.Linear(d_model, d_model) # 用于提取特征
        self.classifier = nn.Linear(d_model, num_classes) # 用于Transformer自身的预测（如果需要）

    def forward(self, src, return_features=False):
        src = self.input_proj(src)
        memory = self.transformer_encoder(src)
        # 取序列的最后一个时间步的输出作为特征
        features = self.feature_layer(memory[:, -1, :])
        
        if return_features:
            return features
        else:
            return self.classifier(features)

ڈیٹا پری پروسیسنگ فنکشن

ٹرانسفارمر ان پٹ حاصل کریں

def get_transformer_input(klines, index):
    if index < config.TRANSFORMER_SEQ_LEN - 1:
        return torch.zeros(1, config.TRANSFORMER_SEQ_LEN, 5)
    
    # 提取序列数据
    start_idx = index - config.TRANSFORMER_SEQ_LEN + 1
    end_idx = index + 1
    seq_data = klines[start_idx:end_idx]
    
    # 转换为OHLCV数组
    ohlcv = np.array([[k["open"], k["high"], k["low"], k["close"], k["volume"]] 
                     for k in seq_data])
    
    # 自动创建并拟合scaler（仅在训练时）
    if ModelRegistry.transformer_scaler is None:
        ModelRegistry.transformer_scaler = StandardScaler()
        if len(klines) > config.TRANSFORMER_SEQ_LEN:
            all_ohlcv = np.array([[k["open"], k["high"], k["low"], k["close"], k["volume"]] 
                                 for k in klines])
            ModelRegistry.transformer_scaler.fit(all_ohlcv)
    
    # 标准化数据
    normalized_ohlcv = ModelRegistry.transformer_scaler.transform(ohlcv)
    return torch.tensor(normalized_ohlcv, dtype=torch.float32).unsqueeze(0)

ٹرانسفارمر ان پٹ حاصل کریں (فکسڈ سکیلر)

def get_transformer_input_with_fixed_scaler(klines, index, fixed_scaler):
    """使用固定的scaler生成Transformer输入（用于实时预测）"""

    seq_data = klines[start_idx:end_idx]
    ohlcv = np.array([[k["open"], k["high"], k["low"], k["close"], k["volume"]] 
                     for k in seq_data])
    
    normalized_ohlcv = fixed_scaler.transform(ohlcv)
    return torch.tensor(normalized_ohlcv, dtype=torch.float32).unsqueeze(0)

تربیت میں ٹرانسفارمرز سے متعلق کوڈ

if config.TRANSFORMER_ENABLED:
    Log("开始联合训练Transformer和分类器...")
    
    # 创建Transformer模型
    ModelRegistry.transformer_model = TimeSeriesTransformer(
        input_dim=5, 
        d_model=config.TRANSFORMER_D_MODEL, 
        nhead=config.TRANSFORMER_NHEAD, 
        num_encoder_layers=config.TRANSFORMER_NUM_LAYERS,
        num_classes=3
    )
    
    # 优化器和损失函数
    optimizer_transformer = torch.optim.Adam(
        ModelRegistry.transformer_model.parameters(), 
        lr=config.TRANSFORMER_LEARNING_RATE
    )
    criterion_transformer = nn.CrossEntropyLoss()
    
    # 准备Transformer训练数据（避免数据泄露）
    X_transformer_sequences = []
    y_transformer_sequences = []
    
    for i in range(len(klines_for_transformer_training) - config.PREDICT_HORIZON - config.TRANSFORMER_SEQ_LEN + 1):
        # 提取序列
        seq_start = i
        seq_end = i + config.TRANSFORMER_SEQ_LEN
        seq_ohlcv = np.array([[k["open"], k["high"], k["low"], k["close"], k["volume"]] 
                            for k in klines_for_transformer_training[seq_start:seq_end]])
        
        # 标准化
        seq_normalized = ModelRegistry.transformer_scaler.transform(seq_ohlcv)
        X_transformer_sequences.append(seq_normalized)
        
        # 计算标签（价格变化）
        current_kline = klines_for_transformer_training[seq_end - 1]
        future_kline = klines_for_transformer_training[seq_end - 1 + config.PREDICT_HORIZON]
        # ... 标签计算逻辑 ...
    
    # 训练Transformer模型
    for epoch in range(config.TRANSFORMER_TRAIN_EPOCHS):
        ModelRegistry.transformer_model.train()
        optimizer_transformer.zero_grad()
        outputs = ModelRegistry.transformer_model(X_transformer_sequences)
        loss = criterion_transformer(outputs, y_transformer_sequences)
        loss.backward()
        optimizer_transformer.step()

ٹرانسفارمرز کوڈ کی اصل وقت کی پیشن گوئی

model_expects_transformer = any("transformer_feat" in name for name in ModelRegistry.feature_names)

if model_expects_transformer:
    if config.TRANSFORMER_ENABLED and ModelRegistry.transformer_model and ModelRegistry.transformer_scaler:
        # 检查数据是否足够
        if len(FeatureStore.klines_1min) >= config.TRANSFORMER_SEQ_LEN:
            # 使用固定scaler获取输入
            transformer_input = get_transformer_input_with_fixed_scaler(
                FeatureStore.klines_1min, 
                len(FeatureStore.klines_1min) - 1,
                ModelRegistry.transformer_scaler  # 使用训练好的scaler
            )
            
            # 提取Transformer特征
            with torch.no_grad():
                transformer_feature_np = ModelRegistry.transformer_model(
                    transformer_input, 
                    return_features=True
                ).squeeze(0).numpy()
        else:
            # 数据不足时使用零填充
            transformer_feature_np = np.zeros(config.TRANSFORMER_D_MODEL)
    else:
        # 配置禁用或模型丢失时使用零填充
        transformer_feature_np = np.zeros(config.TRANSFORMER_D_MODEL)

# 特征拼接
if transformer_feature_np is not None:
    transformer_cols = [f"transformer_feat_{i}" for i in range(config.TRANSFORMER_D_MODEL)]
    transformer_df = pd.DataFrame(transformer_feature_np.reshape(1, -1), columns=transformer_cols)
    
    # 合并表格特征和Transformer特征
    final_features_for_model_df = pd.concat([scaled_features_df, transformer_df], axis=1)

ماڈل محفوظ اور لوڈ

ٹرانسفارمر ماڈل محفوظ کریں:

if config.TRANSFORMER_ENABLED and ModelRegistry.transformer_model:
    transformer_path = os.path.join(config.MODEL_DIR, f"transformer_model_{version}.pth")
    torch.save(ModelRegistry.transformer_model.state_dict(), transformer_path)
    
    # 同时保存scaler
    transformer_scaler_path = os.path.join(config.MODEL_DIR, f"transformer_scaler_{version}.pkl")
    with open(transformer_scaler_path, 'wb') as f:
        pickle.dump(ModelRegistry.transformer_scaler, f)

ٹرانسفارمر ماڈل لوڈ کریں:

if config.TRANSFORMER_ENABLED:
    transformer_path = os.path.join(config.MODEL_DIR, f"transformer_model_{ModelRegistry.current_model_version}.pth")
    
    if os.path.exists(transformer_path):
        ModelRegistry.transformer_model = TimeSeriesTransformer(
            input_dim=5, 
            d_model=config.TRANSFORMER_D_MODEL, 
            nhead=config.TRANSFORMER_NHEAD,
            num_encoder_layers=config.TRANSFORMER_NUM_LAYERS, 
            num_classes=3
        )
        ModelRegistry.transformer_model.load_state_dict(torch.load(transformer_path))
        ModelRegistry.transformer_model.eval()
        
        # 加载scaler
        transformer_scaler_path = os.path.join(config.MODEL_DIR, f"transformer_scaler_{ModelRegistry.current_model_version}.pkl")
        with open(transformer_scaler_path, "rb") as f:
            ModelRegistry.transformer_scaler = pickle.load(f)

ترتیب پیرامیٹر

self.TRANSFORMER_ENABLED = self.config["transformer"]["enabled"]  # 是否启用
self.TRANSFORMER_SEQ_LEN = self.config["transformer"]["seq_len"]  # 序列长度（30）
self.TRANSFORMER_D_MODEL = self.config["transformer"]["d_model"]  # 特征维度（32）
self.TRANSFORMER_NHEAD = self.config["transformer"]["nhead"]      # 注意力头数（4）
self.TRANSFORMER_NUM_LAYERS = self.config["transformer"]["num_layers"]  # 层数（2）
self.TRANSFORMER_TRAIN_EPOCHS = self.config["transformer"]["train_epochs"]  # 训练轮数
self.TRANSFORMER_LEARNING_RATE = self.config["transformer"]["learning_rate"]  # 学习率

خصوصیت نام کا انتظام

def update_feature_names_with_transformer():
    """更新特征名称列表以包含Transformer特征"""
    base_features = [...]  # 29个基础特征
    
    if config.TRANSFORMER_ENABLED:
        transformer_features = [f"transformer_feat_{i}" for i in range(config.TRANSFORMER_D_MODEL)]
        ModelRegistry.feature_names = base_features + transformer_features  
    else:
        ModelRegistry.feature_names = base_features  # 仅29个特征

ٹرانسفارمر کے کام کا بہاؤ

实时预测时：
1. 获取最近30根K线的OHLCV数据 → (30, 5)
2. 使用训练时确定的scaler标准化 → 标准化后的(30, 5)
3. 输入Transformer模型 → 提取32维特征向量
4. 与29维表格特征拼接 → 61维特征向量
5. 输入LightGBM进行最终预测
6. 输出：上涨/下跌/盘整的概率分布

خلاصہ کریں۔

ٹرانسفارمر ماڈل نے مالیاتی شعبے میں انقلابی تبدیلیاں لائی ہیں ، اس کی طاقتور سیریل ماڈلنگ کی صلاحیت خاص طور پر مالیاتی ٹائم سیریز تجزیہ کے لئے موزوں ہے۔ ٹرانسفارمر فنانشل ٹیکنالوجیز کے مختلف شعبوں کو تبدیل کررہا ہے ، جس میں مقدار کی تجارت سے لے کر رسک مینجمنٹ تک ، متبادل ڈیٹا تجزیہ سے لے کر پورٹ فولیو کی اصلاح تک ہے۔

تاہم ، ٹرانسفارمر کو کامیابی کے ساتھ لاگو کرنے کے لئے مالیاتی منڈیوں کی خصوصیات کو گہرائی سے سمجھنے کی ضرورت ہے ، بشمول اعداد و شمار کی عدم استحکام ، سگنل کی شور اور ریگولیشن کی پیچیدگی۔ مستقبل میں ، ماڈل کی ترجمانی میں بہتری ، حساب کتاب کی کارکردگی کو بہتر بنانے اور مالیاتی شعبے کے لئے خصوصی فن تعمیر کی ترقی کے ساتھ ، ٹرانسفارمر کو مالیاتی شعبے میں زیادہ قدر کی توقع ہے۔