diff --git a/.claudeignore b/.claudeignore
new file mode 100644
index 0000000..c18dd8d
--- /dev/null
+++ b/.claudeignore
@@ -0,0 +1 @@
+__pycache__/
diff --git a/.clauderc b/.clauderc
new file mode 100644
index 0000000..4ddc2ed
--- /dev/null
+++ b/.clauderc
@@ -0,0 +1,9 @@
+custom_instructions: |
+  - When refactoring, prefer using partial updates or specific function rewrites instead of outputting the entire file content. This helps avoid token limit errors.
+  - If a file is larger than 300 lines, always suggest a modular breakdown before refactoring.
+  - Please be concise. Skip lengthy explanations and focus on the code changes only. Use short responses.
+  - Only output the diff or the specific functions that need changing. Do not repeat the unchanged parts of the file.
+
+post_task_instructions: |
+  After significant changes, ask me if you should update CLAUDE.md to reflect the new architecture or commands.
+
diff --git a/compare_embeddings.py b/compare_embeddings.py
new file mode 100644
index 0000000..ace827f
--- /dev/null
+++ b/compare_embeddings.py
@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""
+Compare generated embeddings with database embeddings (0_7 version).
+Handles format conversion for datetime and instrument columns.
+
+SUMMARY OF FINDINGS:
+- Generated embeddings and database embeddings have DIFFERENT values
+- Instrument mapping: 430xxx -> SHxxxxx, 830xxx -> SZxxxxx, 6xxxxx -> SH6xxxxx
+- Correlation between corresponding dimensions: ~0.0067 (essentially zero)
+- The generated embeddings are NOT the same as the database 0_7 embeddings
+- Possible reasons:
+  1. Different model weights/versions used for generation
+  2. Different input features or normalization
+  3. Different random seed or inference configuration
+"""
+import polars as pl
+import numpy as np
+from pathlib import Path
+
+def instrument_int_to_code(inst_int: int) -> str:
+    """Convert integer instrument code to exchange-prefixed string.
+
+    The encoding in the embedding file uses:
+    - 4xxxxx -> SHxxxxxx (Shanghai A-shares, but code mapping is non-trivial)
+    - 8xxxxx -> SZxxxxxx (Shenzhen A-shares)
+    - Direct 6-digit codes are also present (600xxx, 000xxx, 300xxx)
+
+    Note: The exact mapping from 430017 -> SH600021 requires the original
+    features file. We attempt an approximate mapping here.
+    """
+    inst_str = str(inst_int)
+
+    # Already 6-digit code
+    if len(inst_str) == 6 and inst_str[0] not in ('4', '8'):
+        if inst_str.startswith('6'):
+            return f"SH{inst_str}"
+        else:
+            return f"SZ{inst_str}"
+
+    # 6-digit with exchange prefix (4=SH, 8=SZ)
+    if len(inst_str) == 6 and inst_str[0] in ('4', '8'):
+        exchange = 'SH' if inst_str[0] == '4' else 'SZ'
+        # The mapping from 430xxx -> 600xxx is not 1:1
+        # Return the code as-is for matching attempts
+        return f"{exchange}{inst_str[1:]}"
+
+    return inst_str
+
+def load_generated_embedding(date_int: int, sample_n: int = None):
+    """Load generated embedding for a specific date."""
+    gen_path = Path('/home/guofu/Workspaces/alpha_lab/stock_1d/d033/alpha158_beta/data/embedding_0_7_beta.parquet')
+
+    lf = pl.scan_parquet(gen_path)
+    lf = lf.filter(pl.col('datetime') == date_int)
+
+    if sample_n:
+        lf = lf.head(sample_n)
+
+    df = lf.collect()
+
+    # Convert wide format (embedding_0, embedding_1, ...) to list format
+    embedding_cols = [c for c in df.columns if c.startswith('embedding_')]
+    embedding_cols.sort(key=lambda x: int(x.split('_')[1]))
+
+    embedding_structs = df.select(embedding_cols).to_struct()
+    embeddings_list = [[v for v in struct.values()] for struct in embedding_structs]
+
+    df = df.with_columns([
+        pl.Series('values', embeddings_list),
+        pl.col('datetime').cast(pl.UInt32).alias('datetime_uint32'),
+        pl.col('instrument').alias('instrument_orig'),
+        pl.col('instrument').cast(pl.String).alias('instrument_str'),
+        pl.col('instrument').map_elements(instrument_int_to_code, return_dtype=pl.String).alias('instrument_code')
+    ])
+
+    return df
+
+def load_database_embedding(date_str: str):
+    """Load database embedding for a specific date."""
+    db_path = Path(f'/data/parquet/dataset/dwm_1day_multicast_csencode_1D/version=csiallx_feature2_ntrla_flag_pnlnorm_vae4_dim32a_beta0001/datetime={date_str}/0.parquet')
+
+    if not db_path.exists():
+        return None
+
+    df = pl.read_parquet(db_path)
+    df = df.with_columns([
+        pl.col('datetime').cast(pl.Int64).alias('datetime_int')
+    ])
+    return df
+
+def analyze_instrument_mapping(date_int: int):
+    """Analyze the instrument mapping between generated and database embeddings."""
+    date_str = str(date_int)
+
+    print(f"\n{'='*80}")
+    print(f"Analyzing instrument mapping for date: {date_int}")
+    print(f"{'='*80}")
+
+    gen_df = load_generated_embedding(date_int)
+    db_df = load_database_embedding(date_str)
+
+    if db_df is None:
+        print(f"ERROR: Database embedding not found for {date_str}")
+        return
+
+    print(f"\nGenerated embeddings: {gen_df.shape[0]} rows")
+    print(f"Database embeddings: {db_df.shape[0]} rows")
+
+    # Show samples
+    print("\n--- Generated Embedding Sample ---")
+    sample_gen = gen_df.select(['datetime', 'instrument_orig', 'instrument_str', 'instrument_code', 'values']).head(10)
+    print(sample_gen)
+
+    print("\n--- Database Embedding Sample ---")
+    print(db_df.head(10))
+
+    # Try different matching strategies
+    gen_insts_set = set(gen_df['instrument_code'].to_list())
+    db_insts_set = set(db_df['instrument'].to_list())
+
+    common = gen_insts_set & db_insts_set
+    gen_only = gen_insts_set - db_insts_set
+    db_only = db_insts_set - gen_insts_set
+
+    print(f"\n--- Matching Results (with code conversion) ---")
+    print(f"Common instruments: {len(common)}")
+    print(f"Generated only: {len(gen_only)}")
+    print(f"Database only: {len(db_only)}")
+
+    if len(common) == 0:
+        print("\nNo common instruments found with code conversion!")
+        print("\nTrying to find mapping patterns...")
+
+        # Show some samples for analysis
+        print("\nGenerated instrument samples (original, converted):")
+        gen_samples = list(zip(gen_df['instrument_orig'].head(20).to_list(),
+                               gen_df['instrument_code'].head(20).to_list()))
+        for orig, conv in gen_samples:
+            print(f"  {orig} -> {conv}")
+
+        print("\nDatabase instrument samples:")
+        db_samples = db_df['instrument'].head(20).to_list()
+        for inst in db_samples:
+            print(f"  {inst}")
+
+        # Check if there's a position-based alignment possible
+        # Sort both and compare by position
+        gen_sorted = sorted(gen_df['instrument_orig'].to_list())
+        db_sorted = sorted([int(inst[2:]) for inst in db_df['instrument'].to_list()])
+
+        print("\n--- Attempting position-based matching ---")
+        print(f"Generated sorted (first 10): {gen_sorted[:10]}")
+        print(f"Database sorted (first 10): {db_sorted[:10]}")
+
+    else:
+        # We have matches, compare embeddings
+        print(f"\n--- Comparing embeddings for {len(common)} common instruments ---")
+
+        gen_common = gen_df.filter(pl.col('instrument_code').is_in(list(common)))
+        db_common = db_df.filter(pl.col('instrument').is_in(list(common)))
+
+        # Join and compare
+        comparison = gen_common.join(
+            db_common,
+            left_on='instrument_code',
+            right_on='instrument',
+            how='inner',
+            suffix='_db'
+        )
+
+        # Calculate differences
+        diffs = []
+        for row in comparison.iter_rows():
+            # Find indices for the values columns
+            gen_vals_idx = comparison.columns.index('values')
+            db_vals_idx = comparison.columns.index('values_db')
+
+            gen_emb = np.array(row[gen_vals_idx])
+            db_emb = np.array(row[db_vals_idx])
+
+            diff = gen_emb - db_emb
+            diff_norm = np.linalg.norm(diff)
+            rel_diff = diff_norm / (np.linalg.norm(db_emb) + 1e-10)
+
+            diffs.append({
+                'instrument': row[comparison.columns.index('instrument_code')],
+                'l2_norm_diff': diff_norm,
+                'relative_diff': rel_diff,
+                'max_abs_diff': np.max(np.abs(diff)),
+                'gen_emb_norm': np.linalg.norm(gen_emb),
+                'db_emb_norm': np.linalg.norm(db_emb)
+            })
+
+        if diffs:
+            diff_df = pl.DataFrame(diffs)
+            print("\nDifference statistics:")
+            print(diff_df.select(['l2_norm_diff', 'relative_diff', 'max_abs_diff']).describe())
+
+            max_rel_diff = diff_df['relative_diff'].max()
+            print(f"\nMax relative difference: {max_rel_diff:.6e}")
+
+            if max_rel_diff < 1e-5:
+                print("✓ Embeddings match within numerical precision!")
+            elif max_rel_diff < 0.01:
+                print("~ Embeddings are very similar")
+            else:
+                print("✗ Embeddings differ significantly")
+
+            # Show some comparison samples
+            print("\nSample comparison:")
+            for i in range(min(5, len(diffs))):
+                d = diffs[i]
+                print(f"  {d['instrument']}: gen_norm={d['gen_emb_norm']:.4f}, "
+                      f"db_norm={d['db_emb_norm']:.4f}, rel_diff={d['relative_diff']:.6e}")
+
+def calculate_correlation(date_int: int):
+    """Calculate correlation between generated and database embeddings."""
+    import numpy as np
+
+    date_str = str(date_int)
+
+    print(f"\n{'='*80}")
+    print(f"Correlation Analysis for date: {date_int}")
+    print(f"{'='*80}")
+
+    gen_df = load_generated_embedding(date_int)
+    db_df = load_database_embedding(date_str)
+
+    if db_df is None:
+        print(f"ERROR: Database embedding not found for {date_str}")
+        return
+
+    # Find common instruments
+    gen_insts = set(gen_df['instrument_code'].to_list())
+    db_insts = set(db_df['instrument'].to_list())
+    common = list(gen_insts & db_insts)
+
+    print(f"\nCommon instruments: {len(common)}")
+
+    if len(common) == 0:
+        print("No common instruments found!")
+        return
+
+    # Filter to common and sort
+    gen_common = gen_df.filter(pl.col('instrument_code').is_in(common)).sort('instrument_code')
+    db_common = db_df.filter(pl.col('instrument').is_in(common)).sort('instrument')
+
+    # Extract embedding matrices
+    gen_embs = np.array(gen_common['values'].to_list())
+    db_embs = np.array(db_common['values'].to_list())
+
+    print(f"Generated embeddings shape: {gen_embs.shape}")
+    print(f"Database embeddings shape: {db_embs.shape}")
+
+    # Calculate correlation per dimension
+    correlations = []
+    for i in range(32):
+        gen_dim = gen_embs[:, i]
+        db_dim = db_embs[:, i]
+        corr = np.corrcoef(gen_dim, db_dim)[0, 1]
+        correlations.append(corr)
+
+    print(f"\nCorrelation statistics across 32 dimensions:")
+    print(f"  Mean:   {np.mean(correlations):.4f}")
+    print(f"  Median: {np.median(correlations):.4f}")
+    print(f"  Min:    {np.min(correlations):.4f}")
+    print(f"  Max:    {np.max(correlations):.4f}")
+
+    # Overall correlation
+    overall_corr = np.corrcoef(gen_embs.flatten(), db_embs.flatten())[0, 1]
+    print(f"\nOverall correlation (all dims flattened): {overall_corr:.4f}")
+
+    # Interpretation
+    mean_corr = np.mean(correlations)
+    if abs(mean_corr) < 0.1:
+        print("\n✗ CONCLUSION: Embeddings are NOT correlated (essentially independent)")
+    elif abs(mean_corr) < 0.5:
+        print("\n~ CONCLUSION: Weak correlation between embeddings")
+    else:
+        print(f"\n✓ CONCLUSION: {'Strong' if abs(mean_corr) > 0.8 else 'Moderate'} correlation")
+
+if __name__ == '__main__':
+    # Analyze for a few dates
+    dates_to_compare = [20190102, 20200102, 20240102]
+
+    for date in dates_to_compare:
+        try:
+            analyze_instrument_mapping(date)
+            calculate_correlation(date)
+        except Exception as e:
+            print(f"\nError analyzing date {date}: {e}")
+            import traceback
+            traceback.print_exc()
diff --git a/cta_1d/03_baseline_xgb_executed.ipynb b/cta_1d/03_baseline_xgb_executed.ipynb
new file mode 100644
index 0000000..162f620
--- /dev/null
+++ b/cta_1d/03_baseline_xgb_executed.ipynb
@@ -0,0 +1,735 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# CTA 1D Baseline XGBoost Model\n",
+    "\n",
+    "Train and evaluate a baseline XGBoost model for CTA 1-day return prediction.\n",
+    "\n",
+    "**Purpose**: Establish a baseline performance benchmark with standard configuration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-14T08:12:19.244972Z",
+     "iopub.status.busy": "2026-02-14T08:12:19.244658Z",
+     "iopub.status.idle": "2026-02-14T08:12:20.730424Z",
+     "shell.execute_reply": "2026-02-14T08:12:20.729462Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import json\n",
+    "from datetime import datetime\n",
+    "\n",
+    "# Use the new API from src/\n",
+    "from src.loader_parquet import CTA1DLoaderParquet\n",
+    "from src.train import train_model, TrainConfig\n",
+    "from src.backtest import run_backtest, BacktestConfig\n",
+    "from src.labels import get_blend_weights\n",
+    "\n",
+    "import sys\n",
+    "sys.path.insert(0, '../')\n",
+    "from common.plotting import setup_plot_style, plot_ic_series, plot_cumulative_returns\n",
+    "from common.paths import create_experiment_dir\n",
+    "\n",
+    "setup_plot_style()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Configuration\n",
+    "\n",
+    "Edit this cell to modify experiment parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-14T08:12:20.733937Z",
+     "iopub.status.busy": "2026-02-14T08:12:20.733741Z",
+     "iopub.status.idle": "2026-02-14T08:12:20.739463Z",
+     "shell.execute_reply": "2026-02-14T08:12:20.738798Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Configuration:\n",
+      "  Experiment: baseline_xgb\n",
+      "  Train: 2020-01-01 to 2021-12-31\n",
+      "  Valid: 2022-01-01 to 2022-06-30\n",
+      "  Test:  2022-07-01 to 2023-12-31\n",
+      "  Fit:   2020-01-01 to 2021-12-31 (normalization)\n",
+      "  Blend: default: [0.2, 0.1, 0.3, 0.4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "CONFIG = {\n",
+    "    # Experiment\n",
+    "    'experiment_name': 'baseline_xgb',  # Will be appended with timestamp\n",
+    "    \n",
+    "    # Date ranges (YYYYMMDD format for Parquet loader)\n",
+    "    'dt_range': ['2020-01-01', '2023-12-31'],\n",
+    "    'train_range': ['2020-01-01', '2021-12-31'],\n",
+    "    'valid_range': ['2022-01-01', '2022-06-30'],\n",
+    "    'test_range': ['2022-07-01', '2023-12-31'],\n",
+    "    'fit_range': ['2020-01-01', '2021-12-31'],  # MUST match train_range - prevents data leakage\n",
+    "    \n",
+    "    # Data\n",
+    "    'feature_sets': ['alpha158', 'hffactor'],\n",
+    "    'return_type': 'o2c_twap1min',\n",
+    "    'normalization': 'dual',\n",
+    "    'blend_weights': None,  # Use default [0.2, 0.1, 0.3, 0.4] or specify name/list\n",
+    "    'weight_factors': {'positive': 1.0, 'negative': 2.0},\n",
+    "    \n",
+    "    # Model (XGBoost parameters with regularization)\n",
+    "    'model_params': {\n",
+    "        'objective': 'reg:squarederror',\n",
+    "        'eval_metric': 'rmse',\n",
+    "        'eta': 0.05,\n",
+    "        'max_depth': 4,  # Reduced to prevent overfitting\n",
+    "        'subsample': 0.8,\n",
+    "        'colsample_bytree': 0.8,\n",
+    "        'lambda': 1.0,  # L2 regularization\n",
+    "        'alpha': 0.1,   # L1 regularization\n",
+    "        'seed': 42\n",
+    "    },\n",
+    "    \n",
+    "    # Backtest\n",
+    "    'num_trades': 4,\n",
+    "    'signal_dist': 'normal',\n",
+    "    'pos_weight': True,\n",
+    "    \n",
+    "    # Output\n",
+    "    'save_results': True,\n",
+    "}\n",
+    "\n",
+    "print(\"Configuration:\")\n",
+    "print(f\"  Experiment: {CONFIG['experiment_name']}\")\n",
+    "print(f\"  Train: {CONFIG['train_range'][0]} to {CONFIG['train_range'][1]}\")\n",
+    "print(f\"  Valid: {CONFIG['valid_range'][0]} to {CONFIG['valid_range'][1]}\")\n",
+    "print(f\"  Test:  {CONFIG['test_range'][0]} to {CONFIG['test_range'][1]}\")\n",
+    "print(f\"  Fit:   {CONFIG['fit_range'][0]} to {CONFIG['fit_range'][1]} (normalization)\")\n",
+    "blend_desc = \"default: [0.2, 0.1, 0.3, 0.4]\" if CONFIG['blend_weights'] is None else str(CONFIG['blend_weights'])\n",
+    "print(f\"  Blend: {blend_desc}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Load Dataset and Train Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-14T08:12:20.797194Z",
+     "iopub.status.busy": "2026-02-14T08:12:20.796882Z",
+     "iopub.status.idle": "2026-02-14T08:13:57.887738Z",
+     "shell.execute_reply": "2026-02-14T08:13:57.886964Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading dataset and training model...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:src.train:Loaded 175 features\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:src.train:Train size: 29749, Valid: 7527, Test: 23799\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset loaded with 175 features\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:src.train:Training XGBoost model...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0]\ttrain-rmse:0.45902\tvalid-rmse:0.41803\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[50]\ttrain-rmse:0.44688\tvalid-rmse:0.41783\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[65]\ttrain-rmse:0.44472\tvalid-rmse:0.41812\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:src.train:train - IC: 0.2707, R²: 0.0596\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:src.train:valid - IC: 0.0799, R²: -0.0001\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:src.train:test - IC: 0.0898, R²: 0.0014\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Training metrics:\n",
+      "  train_ic: 0.2707\n",
+      "  train_r2: 0.0596\n",
+      "  valid_ic: 0.0799\n",
+      "  valid_r2: -0.0001\n",
+      "  test_ic: 0.0898\n",
+      "  test_r2: 0.0014\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Loading dataset and training model...\")\n",
+    "\n",
+    "# Load dataset first - we'll use this for both training and prediction\n",
+    "loader = CTA1DLoaderParquet(\n",
+    "    return_type=CONFIG['return_type'],\n",
+    "    normalization=CONFIG['normalization'],\n",
+    "    feature_sets=CONFIG['feature_sets'],\n",
+    "    blend_weights=CONFIG['blend_weights'],\n",
+    ")\n",
+    "\n",
+    "dataset = loader.load(\n",
+    "    dt_range=CONFIG['dt_range'],\n",
+    "    fit_range=CONFIG['train_range']  # Use train range for normalization - prevents data leakage\n",
+    ")\n",
+    "feature_cols = dataset.features\n",
+    "df_full = dataset.to_pandas().data\n",
+    "print(f\"Dataset loaded with {len(feature_cols)} features\")\n",
+    "\n",
+    "# Create training config\n",
+    "train_config = TrainConfig(\n",
+    "    dt_range=CONFIG['dt_range'],\n",
+    "    feature_sets=CONFIG['feature_sets'],\n",
+    "    normalization=CONFIG['normalization'],\n",
+    "    blend_weights=CONFIG['blend_weights'],\n",
+    "    model_type='xgb',\n",
+    "    model_params=CONFIG['model_params'],\n",
+    "    segments={\n",
+    "        'train': (CONFIG['train_range'][0], CONFIG['train_range'][1]),\n",
+    "        'valid': (CONFIG['valid_range'][0], CONFIG['valid_range'][1]),\n",
+    "        'test': (CONFIG['test_range'][0], CONFIG['test_range'][1]),\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "# Train model using the pre-loaded dataset to ensure feature consistency\n",
+    "model, metrics = train_model(\n",
+    "    config=train_config,\n",
+    "    output_dir=None,\n",
+    "    dataset=dataset  # Pass pre-loaded dataset\n",
+    ")\n",
+    "\n",
+    "print(f\"\\nTraining metrics:\")\n",
+    "for key, value in metrics.items():\n",
+    "    print(f\"  {key}: {value:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-14T08:13:57.889494Z",
+     "iopub.status.busy": "2026-02-14T08:13:57.889304Z",
+     "iopub.status.idle": "2026-02-14T08:13:58.092001Z",
+     "shell.execute_reply": "2026-02-14T08:13:58.091114Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Top 10 Features:\n",
+      "    feature  importance\n",
+      "57      f58   15.151920\n",
+      "22      f22   14.377318\n",
+      "23      f23   10.843798\n",
+      "21      f21   10.386007\n",
+      "64      f68    8.473670\n",
+      "99     f119    7.243452\n",
+      "96     f116    6.621992\n",
+      "97     f117    5.903418\n",
+      "19      f19    4.761685\n",
+      "101    f121    4.529542\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Feature importance\n",
+    "importance = model.get_score(importance_type='gain')\n",
+    "importance_df = pd.DataFrame([\n",
+    "    {'feature': k, 'importance': v}\n",
+    "    for k, v in importance.items()\n",
+    "]).sort_values('importance', ascending=False)\n",
+    "\n",
+    "print(\"\\nTop 10 Features:\")\n",
+    "print(importance_df.head(10))\n",
+    "\n",
+    "# Plot\n",
+    "fig, ax = plt.subplots(figsize=(10, 6))\n",
+    "importance_df.head(20).plot(x='feature', y='importance', kind='barh', ax=ax)\n",
+    "ax.set_title('Top 20 Feature Importance')\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Feature Importance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-14T08:13:58.094128Z",
+     "iopub.status.busy": "2026-02-14T08:13:58.093959Z",
+     "iopub.status.idle": "2026-02-14T08:13:58.526368Z",
+     "shell.execute_reply": "2026-02-14T08:13:58.525387Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running backtest on test set...\n",
+      "\n",
+      "Predictions generated: 23799 samples\n",
+      "Signal statistics:\n",
+      "  Mean: 0.0242\n",
+      "  Std:  0.0614\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"Running backtest on test set...\")\n",
+    "\n",
+    "# Filter test data by date (datetime index is now datetime64 type)\n",
+    "# Use string dates for comparison since pandas will convert them appropriately\n",
+    "test_start = CONFIG['test_range'][0]\n",
+    "test_end = CONFIG['test_range'][1]\n",
+    "\n",
+    "# Get test data by filtering the pandas DataFrame\n",
+    "df_test = df_full.loc[\n",
+    "    (df_full.index.get_level_values(0) >= test_start) &\n",
+    "    (df_full.index.get_level_values(0) <= test_end)\n",
+    "].copy()\n",
+    "\n",
+    "# Extract features and labels\n",
+    "X_test = df_test[feature_cols].values\n",
+    "y_test = df_test['label'].values\n",
+    "\n",
+    "# Get predictions\n",
+    "import xgboost as xgb\n",
+    "dtest = xgb.DMatrix(X_test)\n",
+    "predictions = model.predict(dtest)\n",
+    "\n",
+    "# Create signal Series with proper index for backtest\n",
+    "signal_series = pd.Series(predictions, index=df_test.index)\n",
+    "\n",
+    "print(f\"\\nPredictions generated: {len(predictions)} samples\")\n",
+    "print(f\"Signal statistics:\")\n",
+    "print(f\"  Mean: {predictions.mean():.4f}\")\n",
+    "print(f\"  Std:  {predictions.std():.4f}\")\n",
+    "\n",
+    "# Plot signal distribution\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(14, 4))\n",
+    "\n",
+    "axes[0].hist(predictions, bins=100, edgecolor='black')\n",
+    "axes[0].set_title('Signal Distribution')\n",
+    "axes[0].axvline(x=0, color='red', linestyle='--')\n",
+    "\n",
+    "# Group by date for mean signal plot\n",
+    "signal_by_date = signal_series.groupby(level=0).mean()\n",
+    "axes[1].plot(signal_by_date.index, signal_by_date.values)\n",
+    "axes[1].set_title('Mean Signal by Date')\n",
+    "axes[1].axhline(y=0, color='red', linestyle='--')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Generate Predictions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-14T08:13:58.528619Z",
+     "iopub.status.busy": "2026-02-14T08:13:58.528462Z",
+     "iopub.status.idle": "2026-02-14T08:13:58.798553Z",
+     "shell.execute_reply": "2026-02-14T08:13:58.797346Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Backtest Summary:\n",
+      "  0: ic_mean               0.074090\n",
+      "ic_std                0.196369\n",
+      "ic_ir                 0.377298\n",
+      "ic_positive_ratio     0.659401\n",
+      "annual_return        20.731708\n",
+      "annual_volatility     3.728406\n",
+      "sharpe_ratio          5.560475\n",
+      "max_drawdown         -0.758262\n",
+      "Name: 0, dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run backtest using CTABacktester\n",
+    "from qshare.eval.cta.backtest import CTABacktester\n",
+    "\n",
+    "# Create return Series from test data (need actual returns, not normalized labels)\n",
+    "# The 'return' column should have the raw returns if available\n",
+    "if 'return' in df_test.columns:\n",
+    "    return_series = df_test['return']\n",
+    "else:\n",
+    "    # Use label as proxy (it's normalized returns)\n",
+    "    return_series = df_test['label']\n",
+    "\n",
+    "backtester = CTABacktester(\n",
+    "    num_trades=CONFIG['num_trades'],\n",
+    "    signal_dist=CONFIG['signal_dist'],\n",
+    "    pos_weight=CONFIG['pos_weight']\n",
+    ")\n",
+    "\n",
+    "results = backtester.run(return_series, signal_series)\n",
+    "summary = backtester.summary()\n",
+    "\n",
+    "print(\"\\nBacktest Summary:\")\n",
+    "for key, value in summary.items():\n",
+    "    if isinstance(value, float):\n",
+    "        print(f\"  {key}: {value:.4f}\")\n",
+    "    else:\n",
+    "        print(f\"  {key}: {value}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-14T08:13:58.801046Z",
+     "iopub.status.busy": "2026-02-14T08:13:58.800882Z",
+     "iopub.status.idle": "2026-02-14T08:13:58.965447Z",
+     "shell.execute_reply": "2026-02-14T08:13:58.964134Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "IC Statistics:\n",
+      "  Mean: 0.0741\n",
+      "  Std:  0.1964\n",
+      "  IR:   0.3773\n"
+     ]
+    }
+   ],
+   "source": [
+    "# IC Analysis\n",
+    "# The results from CTABacktester is a dict, extract the IC series\n",
+    "if isinstance(results, dict):\n",
+    "    # Results is a dict with various metrics\n",
+    "    ic_by_date = results.get('df_ic', pd.Series())\n",
+    "else:\n",
+    "    # Try the old approach if results is a DataFrame\n",
+    "    ic_by_date = results.groupby(results.index.get_level_values(0))['ic'].mean()\n",
+    "\n",
+    "if len(ic_by_date) > 0:\n",
+    "    fig = plot_ic_series(ic_by_date, title=\"IC Over Time (Test Set)\")\n",
+    "    plt.show()\n",
+    "\n",
+    "    print(f\"\\nIC Statistics:\")\n",
+    "    print(f\"  Mean: {ic_by_date.mean():.4f}\")\n",
+    "    print(f\"  Std:  {ic_by_date.std():.4f}\")\n",
+    "    print(f\"  IR:   {ic_by_date.mean() / ic_by_date.std():.4f}\")\n",
+    "else:\n",
+    "    print(\"No IC data available in results\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-14T08:13:58.968285Z",
+     "iopub.status.busy": "2026-02-14T08:13:58.968127Z",
+     "iopub.status.idle": "2026-02-14T08:13:59.499839Z",
+     "shell.execute_reply": "2026-02-14T08:13:59.498582Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Return Statistics:\n",
+      "  Total Return: 2990.33%\n",
+      "  Annual Return: 954.65%\n",
+      "  Sharpe Ratio: 5.50\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Cumulative returns\n",
+    "# Get returns from the backtest results\n",
+    "daily_returns = results.get('df_return_accum', pd.Series())\n",
+    "if len(daily_returns) > 0:\n",
+    "    # If it's cumulative, calculate daily from it\n",
+    "    if hasattr(daily_returns, 'diff'):\n",
+    "        daily_rets = daily_returns.diff().fillna(daily_returns.iloc[0] if len(daily_returns) > 0 else 0)\n",
+    "    else:\n",
+    "        daily_rets = daily_returns\n",
+    "else:\n",
+    "    # Fallback to simple IC-based approximation\n",
+    "    daily_rets = results.get('df_ic', pd.Series())\n",
+    "    daily_rets = daily_rets * 0.01  # Rough approximation\n",
+    "\n",
+    "fig = plot_cumulative_returns(daily_rets, title=\"Cumulative Strategy Returns\")\n",
+    "plt.show()\n",
+    "\n",
+    "if len(daily_rets) > 0:\n",
+    "    total_return = daily_rets.sum() if not hasattr(daily_returns, 'iloc') else daily_returns.iloc[-1] if len(daily_returns) > 0 else 0\n",
+    "    annual_return = (1 + total_return) ** (252 / len(daily_rets)) - 1 if len(daily_rets) > 0 else 0\n",
+    "    sharpe = daily_rets.mean() / daily_rets.std() * np.sqrt(252) if daily_rets.std() > 0 else 0\n",
+    "\n",
+    "    print(f\"\\nReturn Statistics:\")\n",
+    "    print(f\"  Total Return: {total_return:.2%}\")\n",
+    "    print(f\"  Annual Return: {annual_return:.2%}\")\n",
+    "    print(f\"  Sharpe Ratio: {sharpe:.2f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Save Results\n",
+    "\n",
+    "Save model, predictions, and metrics for later analysis."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-14T08:13:59.502588Z",
+     "iopub.status.busy": "2026-02-14T08:13:59.502439Z",
+     "iopub.status.idle": "2026-02-14T08:13:59.564977Z",
+     "shell.execute_reply": "2026-02-14T08:13:59.564063Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving results to: /home/guofu/Workspaces/alpha_lab/cta_1d/../results/cta_1d/baseline_xgb\n",
+      "\n",
+      "Files saved:\n",
+      "  - model.json\n",
+      "  - backtest_df_short_accum.csv\n",
+      "  - summary.json\n",
+      "  - backtest_df_return_accum.csv\n",
+      "  - backtest_df_long_accum.csv\n",
+      "  - backtest_df_signal_dist.csv\n",
+      "  - predictions.csv\n",
+      "  - feature_importance.csv\n",
+      "  - backtest_df_num_trade_short.csv\n",
+      "  - backtest_df_return_per_trade.csv\n",
+      "  - backtest_df_num_trade_long.csv\n",
+      "  - backtest_df_ic.csv\n",
+      "  - backtest_df_num_trade.csv\n",
+      "  - config.json\n",
+      "  - backtest_df_ic_test.csv\n"
+     ]
+    }
+   ],
+   "source": [
+    "if CONFIG['save_results']:\n",
+    "    # Create output directory\n",
+    "    output_dir = create_experiment_dir('cta_1d', CONFIG['experiment_name'])\n",
+    "    print(f\"Saving results to: {output_dir}\")\n",
+    "    \n",
+    "    # Save config\n",
+    "    with open(output_dir / 'config.json', 'w') as f:\n",
+    "        json.dump(CONFIG, f, indent=2, default=str)\n",
+    "    \n",
+    "    # Save model\n",
+    "    model.save_model(str(output_dir / 'model.json'))\n",
+    "    \n",
+    "    # Save feature importance\n",
+    "    importance_df.to_csv(output_dir / 'feature_importance.csv', index=False)\n",
+    "    \n",
+    "    # Save predictions\n",
+    "    signal_series.to_csv(output_dir / 'predictions.csv')\n",
+    "    \n",
+    "    # Save backtest results (handle dict or DataFrame)\n",
+    "    if isinstance(results, dict):\n",
+    "        # Save each DataFrame in the results dict separately\n",
+    "        for key, value in results.items():\n",
+    "            if isinstance(value, pd.DataFrame):\n",
+    "                value.to_csv(output_dir / f'backtest_{key}.csv')\n",
+    "            elif isinstance(value, pd.Series):\n",
+    "                value.to_csv(output_dir / f'backtest_{key}.csv')\n",
+    "    else:\n",
+    "        results.to_csv(output_dir / 'backtest_results.csv')\n",
+    "    \n",
+    "    # Save summary\n",
+    "    with open(output_dir / 'summary.json', 'w') as f:\n",
+    "        json.dump(summary, f, indent=2, default=str)\n",
+    "    \n",
+    "    print(\"\\nFiles saved:\")\n",
+    "    for f in output_dir.iterdir():\n",
+    "        print(f\"  - {f.name}\")\n",
+    "else:\n",
+    "    print(\"Results not saved (save_results=False)\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/cta_1d/config.yaml b/cta_1d/config.yaml
new file mode 100644
index 0000000..7b45b5f
--- /dev/null
+++ b/cta_1d/config.yaml
@@ -0,0 +1,50 @@
+# CTA 1-Day Return Prediction - Experiment Configuration
+
+# Data Configuration
+data:
+  dt_range: ['2020-01-01', '2023-12-31']
+  feature_sets:
+    - alpha158
+    - hffactor
+  normalization: dual
+  blend_weights: equal  # Options: equal, zscore_heavy, rolling_heavy, cs_heavy, short_term, long_term
+
+# Data Segments (train/valid/test split)
+segments:
+  train: ['2020-01-01', '2022-06-30']
+  valid: ['2022-07-01', '2022-12-31']
+  test: ['2023-01-01', '2023-12-31']
+
+# Model Configuration
+model:
+  type: xgb
+  params:
+    objective: reg:squarederror
+    eval_metric: rmse
+    eta: 0.05
+    max_depth: 6
+    subsample: 0.8
+    colsample_bytree: 0.8
+    seed: 42
+  num_boost_round: 500
+  early_stopping_rounds: 50
+
+# Training Configuration
+training:
+  return_type: o2c_twap1min
+  weight_factors:
+    positive: 1.0
+    negative: 2.0
+
+# Backtest Configuration
+backtest:
+  num_trades: 4
+  signal_dist: normal
+  pos_weight: true
+
+# Output Configuration
+output:
+  base_dir: results/cta_1d
+  save_model: true
+  save_predictions: true
+  save_importance: true
diff --git a/stock_15m/config.yaml b/stock_15m/config.yaml
new file mode 100644
index 0000000..0cfc7ec
--- /dev/null
+++ b/stock_15m/config.yaml
@@ -0,0 +1,34 @@
+# Stock 15-Minute Return Prediction - Experiment Configuration
+
+# Data Configuration
+data:
+  dt_range: ['2020-01-01', '2023-12-31']
+  feature_path: /data/parquet/stock_1min_alpha158
+  kline_path: /data/parquet/stock_1min_kline
+  industry_path: /data/parquet/stock_industry  # Optional
+  normalization_mode: dual  # Options: industry, cs_zscore, dual
+
+# Model Configuration
+model:
+  type: xgb
+  params:
+    objective: reg:squarederror
+    eval_metric: rmse
+    eta: 0.05
+    max_depth: 6
+    subsample: 0.8
+    colsample_bytree: 0.8
+    seed: 42
+  num_boost_round: 500
+  early_stopping_rounds: 50
+
+# Training Configuration
+training:
+  positive_factor: 1.0  # Weight multiplier for positive returns
+  negative_factor: 2.0  # Weight multiplier for negative returns
+
+# Output Configuration
+output:
+  base_dir: results/stock_15m
+  save_model: true
+  save_predictions: true
diff --git a/stock_1d/d033/alpha158_beta/BUG_ANALYSIS.md b/stock_1d/d033/alpha158_beta/BUG_ANALYSIS.md
new file mode 100644
index 0000000..5ebda83
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/BUG_ANALYSIS.md
@@ -0,0 +1,123 @@
+# Data Pipeline Bug Analysis
+
+## Summary
+
+The generated embeddings do not match the database 0_7 embeddings due to multiple bugs in the data pipeline migration from qlib to standalone Polars implementation.
+
+---
+
+## Bugs Fixed
+
+### 1. Market Classification (`FlagMarketInjector`) ✓ FIXED
+
+**Original (incorrect):**
+```python
+market_0 = (instrument >= 600000)  # SH
+market_1 = (instrument < 600000)   # SZ
+```
+
+**Fixed:**
+```python
+inst_str = str(instrument).zfill(6)
+market_0 = inst_str.startswith('6')  # SH: 6xxxxx
+market_1 = inst_str.startswith('0') | inst_str.startswith('3')  # SZ: 0xxx, 3xxx
+market_2 = inst_str.startswith('4') | inst_str.startswith('8')  # NE: 4xxx, 8xxx
+```
+
+**Impact:** 167 instruments (4xxxxx, 8xxxxx - 新三板) were misclassified.
+
+---
+
+### 2. ColumnRemover Missing `IsN` ✓ FIXED
+
+**Original (incorrect):**
+```python
+columns_to_remove = ['TotalValue_diff', 'IsZt', 'IsDt']
+```
+
+**Fixed:**
+```python
+columns_to_remove = ['TotalValue_diff', 'IsN', 'IsZt', 'IsDt']
+```
+
+**Impact:** Extra column caused feature dimension mismatch.
+
+---
+
+### 3. RobustZScoreNorm Applied to Wrong Columns ✓ FIXED
+
+**Original (incorrect):**
+Applied normalization to ALL 341 features including market flags and indus_idx.
+
+**Fixed:**
+Only normalize `alpha158 + alpha158_ntrl + market_ext + market_ext_ntrl` (330 features), excluding:
+- Market flags (Limit, Stopping, IsTp, IsXD, IsXR, IsDR, market_0, market_1, market_2, IsST)
+- indus_idx
+
+---
+
+## Critical Remaining Issue: Data Schema Mismatch
+
+### `Limit` and `Stopping` Column Types Changed
+
+**Original qlib pipeline expected:**
+- `Limit`: **Boolean** flag (True = limit up)
+- `Stopping`: **Boolean** flag (True = suspended trading)
+
+**Current Parquet data has:**
+- `Limit`: **Float64** price change percentage (0.0 to 1301.3)
+- `Stopping`: **Float64** price change percentage
+
+**Evidence:**
+```
+Limit values sample: [8.86, 9.36, 31.0, 7.32, 2.28, 6.39, 5.38, 4.03, 3.86, 9.89]
+Limit == 0: only 2 rows
+Limit > 0: 3738 rows
+```
+
+This is a **fundamental data schema change**. The current Parquet files contain different data than what the original VAE model was trained on.
+
+**Possible fixes:**
+1. Convert `Limit` and `Stopping` to boolean flags using a threshold
+2. Find the original data source that had boolean flags
+3. Re-train the VAE model with the new data schema
+
+---
+
+## Correlation Results
+
+After fixing bugs 1-3, the embedding correlation with database 0_7:
+
+| Metric | Value |
+|--------|-------|
+| Mean correlation (32 dims) | 0.0068 |
+| Median correlation | 0.0094 |
+| Overall correlation | 0.2330 |
+
+**Conclusion:** Embeddings remain essentially uncorrelated (≈0).
+
+---
+
+## Root Cause
+
+The **Limit/Stopping data schema change** is the most likely root cause. The VAE model learned to encode features that included binary limit/stopping flags, but the standalone pipeline feeds it continuous price change percentages instead.
+
+---
+
+## Next Steps
+
+1. **Verify original data schema:**
+   - Check if the original DolphinDB table had boolean `Limit` and `Stopping` columns
+   - Compare with the current Parquet schema
+
+2. **Fix the data loading:**
+   - Either convert continuous values to binary flags
+   - Or use the correct boolean columns (`IsZt`, `IsDt`) for limit flags
+
+3. **Verify feature order:**
+   - Ensure the qlib RobustZScoreNorm parameters are applied in the correct order
+   - Check that `[alpha158, alpha158_ntrl, market_ext, market_ext_ntrl]` matches the 330-parameter shape
+
+4. **Re-run comparison:**
+   - Generate new embeddings with the corrected pipeline
+   - Compare correlation with database
diff --git a/stock_1d/d033/alpha158_beta/BUG_ANALYSIS_FINAL.md b/stock_1d/d033/alpha158_beta/BUG_ANALYSIS_FINAL.md
new file mode 100644
index 0000000..af21e95
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/BUG_ANALYSIS_FINAL.md
@@ -0,0 +1,85 @@
+# Data Pipeline Bug Analysis - Final Status
+
+## Summary
+
+After fixing all identified bugs, the feature count now matches (341), but the embeddings remain uncorrelated with the database 0_7 version.
+
+**Latest Version**: v5
+- Feature count: 341 ✓ (matches VAE input dim)
+- Mean correlation with DB: 0.0050 (essentially zero)
+- Status: All identified bugs fixed, but embeddings still differ
+
+---
+
+## Bugs Fixed
+
+### 1. Market Classification (`FlagMarketInjector`) ✓ FIXED
+- **Bug**: Used `instrument >= 600000` which misclassified 新三板 instruments
+- **Fix**: Use string prefix matching with vocab_size=2 (not 3)
+- **Impact**: 167 instruments corrected
+
+### 2. ColumnRemover Missing `IsN` ✓ FIXED
+- **Bug**: Only removed `IsZt, IsDt` but not `IsN`
+- **Fix**: Added `IsN` to removal list
+- **Impact**: Feature count alignment
+
+### 3. RobustZScoreNorm Scope ✓ FIXED
+- **Bug**: Applied normalization to all 341 features
+- **Fix**: Only normalize 330 features (alpha158 + market_ext, both original + neutralized)
+- **Impact**: Correct normalization scope
+
+### 4. Wrong Data Sources for Market Flags ✓ FIXED
+- **Bug**: Used `Limit, Stopping` (Float64) from kline_adjusted
+- **Fix**: Load from correct sources:
+  - kline_adjusted: `IsZt, IsDt, IsN, IsXD, IsXR, IsDR` (Boolean)
+  - market_flag: `open_limit, close_limit, low_limit, high_stop` (Boolean, 4 cols)
+- **Impact**: Correct boolean flag data
+
+### 5. Feature Count Mismatch ✓ FIXED
+- **Bug**: 344 features (3 extra)
+- **Fix**: vocab_size=2 + 4 market_flag cols = 341 features
+- **Impact**: VAE input dimension matches
+
+---
+
+## Correlation Results (v5)
+
+| Metric | Value |
+|--------|-------|
+| Mean correlation (32 dims) | 0.0050 |
+| Median correlation | 0.0079 |
+| Min | -0.0420 |
+| Max | 0.0372 |
+| Overall (flattened) | 0.2225 |
+
+**Conclusion**: Embeddings remain essentially uncorrelated with database.
+
+---
+
+## Possible Remaining Issues
+
+1. **Different input data values**: The alpha158_0_7_beta Parquet files may contain different values than the original DolphinDB data used to train the VAE.
+
+2. **Feature ordering mismatch**: The 330 RobustZScoreNorm parameters must be applied in the exact order:
+   - [0:158] = alpha158 original
+   - [158:316] = alpha158_ntrl
+   - [316:323] = market_ext original (7 cols)
+   - [323:330] = market_ext_ntrl (7 cols)
+
+3. **Industry neutralization differences**: Our `IndusNtrlInjector` implementation may differ from qlib's.
+
+4. **Missing transformations**: There may be additional preprocessing steps not captured in handler.yaml.
+
+5. **VAE model mismatch**: The VAE model may have been trained with different data than what handler.yaml specifies.
+
+---
+
+## Recommended Next Steps
+
+1. **Compare intermediate features**: Run both the qlib pipeline and our pipeline on the same input data and compare outputs at each step.
+
+2. **Verify RobustZScoreNorm parameter order**: Check if our feature ordering matches the order used during VAE training.
+
+3. **Compare predictions, not embeddings**: Instead of comparing VAE embeddings, compare the final d033 model predictions with the original 0_7 predictions.
+
+4. **Check alpha158 data source**: Verify that `stg_1day_wind_alpha158_0_7_beta_1D` contains the same data as the original DolphinDB `stg_1day_wind_alpha158_0_7_beta` table.
diff --git a/stock_1d/d033/alpha158_beta/config.yaml b/stock_1d/d033/alpha158_beta/config.yaml
new file mode 100644
index 0000000..da067a3
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/config.yaml
@@ -0,0 +1,146 @@
+# First, let me create a script to train a VAE model on the 0_7_beta data
+# This would need to be done separately as it's a prerequisite for the prediction script above
+
+"""
+Workflow configuration to train a VAE model on alpha158 0_7_beta data.
+This creates a VAE-encoded version of the 0_7_beta factors that can be used
+for prediction comparison with the original 0_7 model.
+"""
+
+experiment_name: vae_alpha158_0_7_beta
+
+qlib_init:
+    provider_uri: "~/.qlib/data_ops/target"
+    region: cn
+
+load_start: &load_start 2013-01-01
+load_end: &load_end 2023-09-30
+
+train_start: &train_start 2013-01-01
+train_end: &train_end 2018-12-31
+
+benchmark_name: &benchmark_name SH000985
+market: &market csiallx
+
+dataset_cache_path: &dataset_cache_path tasks/artifacts/csiallx_dataset_alpha158_0_7_beta_vae.pkl
+
+# DolphinDB configuration
+ddb_config: &ddb_config
+    host: 192.168.1.146
+    port: 8848
+    username: "admin"
+    password: "123456"
+
+data_handler_config: &data_handler_config
+    start_time: *load_start
+    end_time: *load_end
+    fit_start_time: *train_start
+    fit_end_time: *train_end
+    instruments: *market
+    ddb_config: *ddb_config
+    handler_list:
+        # Alpha158 0_7_beta features
+        - class: DDBZWindDataHandler
+          module_path: qlib.contrib.data.ddb_handlers.ddb_wind_handler
+          kwargs:
+            col_set: "feature"
+            query_config:
+              - db_path: "dfs://daily_stock_run"
+                dtype: "float32"
+                field_list: "alpha158"  # All alpha158 factors
+                table_name: "stg_1day_wind_alpha158_0_7_beta"  # Use the beta version
+        # Additional handlers as needed
+        - class: DDBZWindDataHandler
+          module_path: qlib.contrib.data.ddb_handlers.ddb_wind_handler
+          kwargs:
+            col_set: "risk_factor"
+            query_config:
+              - db_path: "dfs://daily_stock_run"
+                dtype: "float32"
+                field_list: ["MarketValue as total_size"]
+                table_name: "stg_1day_wind_kline_adjusted"
+        - class: DDBZWindDataHandler
+          module_path: qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler
+          kwargs:
+            col_set: "indus_flag"
+            query_config:
+              - db_path: "dfs://daily_stock_run"
+                dtype: "bool"
+                field_list: "industry_code_cc.csv"
+                table_name: "stg_1day_gds_indus_flag_cc1"
+        - class: DDBZWindDataHandler
+          module_path: qlib.contrib.data.ddb_handlers.ddb_st_flag_handler
+          kwargs:
+            col_set: "st_flag"
+            query_config:
+              - db_path: "dfs://daily_stock_run"
+                dtype: "bool"
+                field_list: ["ST_Y", "ST_S", "ST_T", "ST_L", "ST_Z", "ST_X"]
+                table_name: "stg_1day_wind_st_flag"
+    infer_processors:
+        - class: FlagToOnehot
+          module_path: qlib.contrib.data.processor_flag
+          kwargs:
+              fields_group: indus_flag
+              onehot_group: indus_idx
+        - class: FactorNtrlInjector
+          module_path: qlib.contrib.data.processor_ntrl
+          kwargs:
+              fields_group: "feature"
+              factor_col: "risk_factor"
+              dummy_col: "indus_idx"
+              ntrl_type: "size_indus"
+        - class: RobustZScoreNorm
+          kwargs:
+              fields_group: ["feature"]
+              clip_outlier: true
+        - class: Fillna
+          kwargs:
+              fields_group: ["feature"]
+
+task:
+    model:
+        class: VAEModel
+        module_path: qlib.contrib.model.task.task_vae_flat
+        kwargs:
+            model_config:
+                hidden_size: 32  # Same as the original model for consistency
+                nn_module:
+                    class: VAE
+                    module_path: qlib.contrib.model.module.module_vae
+                    kwargs:
+                        variational: true
+            optim_config:
+                seed: 1234567
+                bootstrap_config: 1.2
+                distort_config: 1e-3
+                beta: 1e-3  # KL divergence weight
+                n_epochs: 300
+                early_stop: 10
+                lr: 1e-3
+                optimizer: adamw
+                batch_size: 10000
+                n_jobs: 4
+                checkpoint:
+                    save_path: tasks/artifacts/checkpoints/csiallx_alpha158_0_7_beta_vae32
+    dataset:
+        class: DatasetH
+        module_path: qlib.data.dataset
+        kwargs:
+            config_module: qlib.contrib.data.config
+            from_cache: *dataset_cache_path
+            require_setup: true
+            handler:
+                class: AggHandler
+                module_path: qlib.contrib.data.agg_handler
+                kwargs: *data_handler_config
+            segments:
+                train: [*train_start, *train_end]
+                test: [*load_start, *load_end]
+    record:
+        - class: SignalRecord
+          module_path: qlib.contrib.workflow.record_temp
+          kwargs:
+            model: <MODEL>
+            dataset: <DATASET>
+            col_set: "feature"
\ No newline at end of file
diff --git a/stock_1d/d033/alpha158_beta/docs/VISUALIZATION_IMPROVEMENTS.md b/stock_1d/d033/alpha158_beta/docs/VISUALIZATION_IMPROVEMENTS.md
new file mode 100644
index 0000000..c86d234
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/docs/VISUALIZATION_IMPROVEMENTS.md
@@ -0,0 +1,58 @@
+# Analysis Report: Enhanced Prediction Comparison Visualization
+
+## Issue Identified
+The original `prediction_comparison.png` visualization lacked meaningful evaluation metrics such as:
+- IC (Information Coefficient) time series
+- RankIC (Rank Information Coefficient) time series
+- Top-tier return cumulative difference
+- Other requested financial metrics
+
+Instead, it only showed basic scatter plots and prediction distributions.
+
+## Solution Implemented
+Updated the `compare_predictions.py` script with enhanced visualization functionality that includes:
+
+### 1. IC Time Series Comparison
+- Calculates daily IC for both 0_7 and 0_7_beta prediction sets
+- Plots both series on the same chart for easy comparison
+- Shows temporal trends in predictive power
+
+### 2. RankIC Time Series Comparison
+- Calculates daily RankIC (Spearman correlation) for both versions
+- Displays time series comparison to show rank correlation trends
+- Helps evaluate monotonic relationships over time
+
+### 3. Cumulative Top-Tier Returns
+- Identifies top 10% of stocks based on predictions each day
+- Calculates cumulative returns for both prediction sets
+- Shows performance divergence over time
+
+### 4. Difference in Cumulative Returns
+- Visualizes the spread between 0_7 and 0_7_beta cumulative returns
+- Helps quantify the performance gap between the two approaches
+- Provides insight into which version performs better over time
+
+### 5. Additional Improvements
+- Fixed date type mismatch issues that prevented proper joins
+- Added graceful fallback to basic visualization when actual returns unavailable
+- Maintained all original basic comparison plots for comprehensive analysis
+
+## Files Updated
+- `compare_predictions.py` - Enhanced visualization functionality
+- `generate_mock_returns.py` - Script to create test returns data
+- `test_enhanced_visualization.py` - Verification script
+
+## Results
+The enhanced visualization now provides:
+- Meaningful financial metrics that directly address the comparison requirements
+- Time series analysis of IC and RankIC metrics
+- Cumulative performance comparison of top-tier selections
+- Proper error handling for different data formats
+- Comprehensive side-by-side comparison of both alpha versions
+
+## Verification
+Successfully tested the enhanced functionality with mock data, confirming that:
+- All requested metrics are now visualized
+- The plot contains 6 meaningful panels with financial insights
+- The output file `prediction_comparison.png` includes all requested metrics
+- Basic comparison functionality remains intact
\ No newline at end of file
diff --git a/stock_1d/d033/alpha158_beta/pipeline.py b/stock_1d/d033/alpha158_beta/pipeline.py
new file mode 100644
index 0000000..2419669
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/pipeline.py
@@ -0,0 +1,345 @@
+#!/usr/bin/env python
+"""
+Main pipeline orchestration script for Alpha158 0_7 vs 0_7_beta comparison.
+
+This script orchestrates the full workflow:
+1. Generate beta embeddings from alpha158_0_7_beta factors
+2. Fetch original 0_7 predictions from DolphinDB
+3. Generate predictions using beta embeddings
+4. Generate actual returns from kline data
+5. Compare predictions (IC, RankIC, correlation, etc.)
+
+Usage:
+    python pipeline.py --start-date 2019-01-01 --end-date 2020-11-30 --skip-embeddings --skip-fetch
+
+Arguments:
+    --start-date: Start date for data loading (default: 2019-01-01)
+    --end-date: End date for data loading (default: 2020-11-30)
+    --skip-embeddings: Skip embeddings generation (use existing)
+    --skip-fetch: Skip fetching original predictions (use existing)
+    --skip-returns: Skip returns generation (use existing)
+    --skip-comparison: Skip final comparison
+"""
+
+import os
+import sys
+import argparse
+from datetime import datetime
+from pathlib import Path
+
+# Add scripts directory to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'scripts'))
+
+
+def step_generate_embeddings(start_date: str, end_date: str, data_dir: str) -> bool:
+    """Step 1: Generate beta embeddings."""
+    print("\n" + "=" * 70)
+    print("STEP 1: Generate Beta Embeddings")
+    print("=" * 70)
+
+    embedding_file = os.path.join(data_dir, "embedding_0_7_beta.parquet")
+
+    if os.path.exists(embedding_file):
+        print(f"Embeddings file already exists: {embedding_file}")
+        response = input("Regenerate? (y/N): ").strip().lower()
+        if response != 'y':
+            print("Skipping embeddings generation.")
+            return True
+
+    try:
+        from generate_beta_embedding import generate_embeddings
+
+        df = generate_embeddings(
+            start_date=start_date,
+            end_date=end_date,
+            output_file=embedding_file,
+            use_vae=True
+        )
+
+        print(f"\nGenerated {len(df)} embeddings")
+        return True
+
+    except Exception as e:
+        print(f"Error generating embeddings: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def step_fetch_predictions(start_date: str, end_date: str, data_dir: str) -> bool:
+    """Step 2: Fetch original predictions from DolphinDB."""
+    print("\n" + "=" * 70)
+    print("STEP 2: Fetch Original Predictions from DolphinDB")
+    print("=" * 70)
+
+    predictions_file = os.path.join(data_dir, "original_predictions_0_7.parquet")
+
+    if os.path.exists(predictions_file):
+        print(f"Predictions file already exists: {predictions_file}")
+        response = input("Refetch? (y/N): ").strip().lower()
+        if response != 'y':
+            print("Skipping fetch.")
+            return True
+
+    try:
+        from fetch_predictions import fetch_original_predictions
+
+        df = fetch_original_predictions(
+            start_date=start_date,
+            end_date=end_date,
+            output_file=predictions_file
+        )
+
+        print(f"\nFetched {len(df)} predictions")
+        return True
+
+    except Exception as e:
+        print(f"Error fetching predictions: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def step_generate_beta_predictions(data_dir: str) -> bool:
+    """Step 3: Generate predictions using beta embeddings."""
+    print("\n" + "=" * 70)
+    print("STEP 3: Generate Predictions with Beta Embeddings")
+    print("=" * 70)
+
+    embedding_file = os.path.join(data_dir, "embedding_0_7_beta.parquet")
+    predictions_file = os.path.join(data_dir, "predictions_beta_embedding.parquet")
+
+    if not os.path.exists(embedding_file):
+        print(f"Embeddings file not found: {embedding_file}")
+        print("Run step 1 first.")
+        return False
+
+    if os.path.exists(predictions_file):
+        print(f"Beta predictions file already exists: {predictions_file}")
+        response = input("Regenerate? (y/N): ").strip().lower()
+        if response != 'y':
+            print("Skipping prediction generation.")
+            return True
+
+    try:
+        from predict_with_embedding import generate_predictions
+
+        df = generate_predictions(
+            embedding_file=embedding_file,
+            output_file=predictions_file,
+            seq_len=40,
+            batch_size=1000
+        )
+
+        print(f"\nGenerated {len(df)} predictions")
+        return True
+
+    except Exception as e:
+        print(f"Error generating predictions: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def step_generate_returns(data_dir: str) -> bool:
+    """Step 4: Generate actual returns from kline data."""
+    print("\n" + "=" * 70)
+    print("STEP 4: Generate Actual Returns")
+    print("=" * 70)
+
+    predictions_file = os.path.join(data_dir, "original_predictions_0_7.parquet")
+    returns_file = os.path.join(data_dir, "actual_returns.parquet")
+
+    if os.path.exists(returns_file):
+        print(f"Returns file already exists: {returns_file}")
+        response = input("Regenerate? (y/N): ").strip().lower()
+        if response != 'y':
+            print("Skipping returns generation.")
+            return True
+
+    try:
+        from generate_returns import generate_real_returns_from_kline
+
+        # Use prediction file to determine date range if available
+        prediction_file = predictions_file if os.path.exists(predictions_file) else None
+
+        df = generate_real_returns_from_kline(
+            input_kline_path="/data/parquet/dataset/stg_1day_wind_kline_adjusted_1D/",
+            prediction_file=prediction_file,
+            output_file=returns_file,
+            return_days=5
+        )
+
+        if df is not None:
+            print(f"\nGenerated {len(df)} returns")
+            return True
+        else:
+            print("\nFailed to generate returns")
+            return False
+
+    except Exception as e:
+        print(f"Error generating returns: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def step_compare_predictions(data_dir: str) -> bool:
+    """Step 5: Compare 0_7 vs 0_7_beta predictions."""
+    print("\n" + "=" * 70)
+    print("STEP 5: Compare Predictions")
+    print("=" * 70)
+
+    required_files = [
+        os.path.join(data_dir, "original_predictions_0_7.parquet"),
+        os.path.join(data_dir, "predictions_beta_embedding.parquet"),
+    ]
+
+    for f in required_files:
+        if not os.path.exists(f):
+            print(f"Required file not found: {f}")
+            return False
+
+    try:
+        # Import and run comparison
+        from compare_predictions import main as compare_main
+
+        compare_main()
+        return True
+
+    except Exception as e:
+        print(f"Error comparing predictions: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def main():
+    """Main pipeline orchestration."""
+    parser = argparse.ArgumentParser(
+        description="Alpha158 0_7 vs 0_7_beta Comparison Pipeline"
+    )
+    parser.add_argument(
+        "--start-date",
+        type=str,
+        default="2019-01-01",
+        help="Start date (YYYY-MM-DD)"
+    )
+    parser.add_argument(
+        "--end-date",
+        type=str,
+        default="2020-11-30",
+        help="End date (YYYY-MM-DD)"
+    )
+    parser.add_argument(
+        "--skip-embeddings",
+        action="store_true",
+        help="Skip embeddings generation"
+    )
+    parser.add_argument(
+        "--skip-fetch",
+        action="store_true",
+        help="Skip fetching original predictions"
+    )
+    parser.add_argument(
+        "--skip-returns",
+        action="store_true",
+        help="Skip returns generation"
+    )
+    parser.add_argument(
+        "--skip-comparison",
+        action="store_true",
+        help="Skip final comparison"
+    )
+    parser.add_argument(
+        "--data-dir",
+        type=str,
+        default=None,
+        help="Data directory (default: ./data)"
+    )
+
+    args = parser.parse_args()
+
+    # Determine data directory
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    data_dir = args.data_dir or os.path.join(script_dir, "data")
+
+    print("=" * 70)
+    print("Alpha158 0_7 vs 0_7_beta Comparison Pipeline")
+    print("=" * 70)
+    print(f"Date range: {args.start_date} to {args.end_date}")
+    print(f"Data directory: {data_dir}")
+
+    # Ensure data directory exists
+    os.makedirs(data_dir, exist_ok=True)
+
+    # Track results
+    results = {}
+
+    # Step 1: Generate embeddings
+    if not args.skip_embeddings:
+        results['embeddings'] = step_generate_embeddings(
+            args.start_date, args.end_date, data_dir
+        )
+    else:
+        print("\nSkipping embeddings generation (as requested)")
+        results['embeddings'] = True
+
+    # Step 2: Fetch original predictions
+    if not args.skip_fetch:
+        results['fetch'] = step_fetch_predictions(
+            args.start_date, args.end_date, data_dir
+        )
+    else:
+        print("\nSkipping fetch (as requested)")
+        results['fetch'] = True
+
+    # Step 3: Generate beta predictions
+    if results.get('embeddings', True):
+        results['beta_predictions'] = step_generate_beta_predictions(data_dir)
+    else:
+        print("\nSkipping beta predictions (embeddings generation failed)")
+        results['beta_predictions'] = False
+
+    # Step 4: Generate returns
+    if not args.skip_returns:
+        results['returns'] = step_generate_returns(data_dir)
+    else:
+        print("\nSkipping returns generation (as requested)")
+        results['returns'] = True
+
+    # Step 5: Compare predictions
+    if not args.skip_comparison:
+        if all([
+            results.get('fetch', True),
+            results.get('beta_predictions', True)
+        ]):
+            results['comparison'] = step_compare_predictions(data_dir)
+        else:
+            print("\nSkipping comparison (previous steps failed)")
+            results['comparison'] = False
+    else:
+        print("\nSkipping comparison (as requested)")
+        results['comparison'] = True
+
+    # Summary
+    print("\n" + "=" * 70)
+    print("PIPELINE SUMMARY")
+    print("=" * 70)
+
+    for step, success in results.items():
+        status = "✓ PASSED" if success else "✗ FAILED"
+        print(f"  {step:20s}: {status}")
+
+    all_passed = all(results.values())
+
+    print("=" * 70)
+    if all_passed:
+        print("Pipeline completed successfully!")
+    else:
+        print("Pipeline completed with errors.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/stock_1d/d033/alpha158_beta/scripts/compare_gold_standard.py b/stock_1d/d033/alpha158_beta/scripts/compare_gold_standard.py
new file mode 100644
index 0000000..22a539b
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/compare_gold_standard.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python
+"""
+Compare generated embeddings with gold standard embeddings from DolphinDB.
+"""
+
+import polars as pl
+import numpy as np
+from pathlib import Path
+
+DATA_DIR = Path(__file__).parent / "../data"
+
+
+def compare_embeddings():
+    """Compare generated and gold standard embeddings."""
+
+    # Load data
+    gold_path = DATA_DIR / "embedding_0_7_beta_gold_standard.parquet"
+    gen_path = DATA_DIR / "embedding_0_7_beta_sample.parquet"
+
+    print("=" * 60)
+    print("Loading embeddings")
+    print("=" * 60)
+
+    gold = pl.read_parquet(gold_path)
+    gen = pl.read_parquet(gen_path)
+
+    print(f"Gold standard: {gold.shape}")
+    print(f"Generated: {gen.shape}")
+
+    # Get embedding columns
+    emb_cols = [f"embedding_{i}" for i in range(32)]
+
+    # Compare by date
+    dates = sorted(gold["datetime"].unique().to_list())
+
+    print("\n" + "=" * 60)
+    print("Comparison by date")
+    print("=" * 60)
+
+    for dt in dates:
+        gold_dt = gold.filter(pl.col("datetime") == dt)
+        gen_dt = gen.filter(pl.col("datetime") == dt)
+
+        print(f"\nDate: {dt}")
+        print(f"  Gold instruments: {gold_dt.height}, Generated instruments: {gen_dt.height}")
+        print(f"  Gold instrument sample: {gold_dt['instrument'].head(5).to_list()}")
+        print(f"  Gen instrument sample: {gen_dt['instrument'].head(5).to_list()}")
+
+        # Check for common instruments
+        gold_insts = set(gold_dt["instrument"].to_list())
+        gen_insts = set(gen_dt["instrument"].to_list())
+        common = gold_insts & gen_insts
+
+        print(f"  Common instruments: {len(common)}")
+
+        if len(common) > 0:
+            # Compare embeddings for common instruments
+            gold_common = gold_dt.filter(pl.col("instrument").is_in(list(common))).sort("instrument")
+            gen_common = gen_dt.filter(pl.col("instrument").is_in(list(common))).sort("instrument")
+
+            # Calculate embedding differences
+            diffs = []
+            for i in range(len(gold_common)):
+                gold_emb = np.array([gold_common[col][i] for col in emb_cols])
+                gen_emb = np.array([gen_common[col][i] for col in emb_cols])
+
+                diff = gold_emb - gen_emb
+                l2_norm = np.linalg.norm(diff)
+                rel_diff = l2_norm / (np.linalg.norm(gold_emb) + 1e-8)
+                max_abs_diff = np.max(np.abs(diff))
+
+                diffs.append({
+                    "l2_norm": l2_norm,
+                    "rel_diff": rel_diff,
+                    "max_abs_diff": max_abs_diff,
+                    "gold_norm": np.linalg.norm(gold_emb),
+                    "gen_norm": np.linalg.norm(gen_emb)
+                })
+
+            diff_df = pl.DataFrame(diffs)
+            print(f"\n  Embedding comparison:")
+            print(f"    Mean L2 norm diff: {diff_df['l2_norm'].mean():.4f}")
+            print(f"    Mean rel diff: {diff_df['rel_diff'].mean():.4%}")
+            print(f"    Mean max abs diff: {diff_df['max_abs_diff'].mean():.4f}")
+            print(f"    Gold emb norm (mean): {diff_df['gold_norm'].mean():.4f}")
+            print(f"    Gen emb norm (mean): {diff_df['gen_norm'].mean():.4f}")
+
+            # Correlation analysis
+            gold_embs = np.array([[gold_common[col][i] for col in emb_cols] for i in range(len(gold_common))])
+            gen_embs = np.array([[gen_common[col][i] for col in emb_cols] for i in range(len(gen_common))])
+
+            correlations = []
+            for d in range(32):
+                corr = np.corrcoef(gold_embs[:, d], gen_embs[:, d])[0, 1]
+                correlations.append(corr)
+
+            print(f"\n  Correlation by dimension:")
+            print(f"    Mean: {np.mean(correlations):.4f}")
+            print(f"    Median: {np.median(correlations):.4f}")
+            print(f"    Min: {np.min(correlations):.4f}")
+            print(f"    Max: {np.max(correlations):.4f}")
+
+            # Overall correlation
+            overall_corr = np.corrcoef(gold_embs.flatten(), gen_embs.flatten())[0, 1]
+            print(f"    Overall (flattened): {overall_corr:.4f}")
+
+    print("\n" + "=" * 60)
+    print("Summary Statistics")
+    print("=" * 60)
+
+    # Gold standard stats
+    gold_embs = gold.select(emb_cols).to_numpy()
+    print("\nGold standard embeddings:")
+    print(f"  Mean: {np.mean(gold_embs):.6f}")
+    print(f"  Std: {np.std(gold_embs):.6f}")
+    print(f"  Min: {np.min(gold_embs):.6f}")
+    print(f"  Max: {np.max(gold_embs):.6f}")
+
+    # Generated stats
+    gen_embs = gen.select(emb_cols).to_numpy()
+    print("\nGenerated embeddings:")
+    print(f"  Mean: {np.mean(gen_embs):.6f}")
+    print(f"  Std: {np.std(gen_embs):.6f}")
+    print(f"  Min: {np.min(gen_embs):.6f}")
+    print(f"  Max: {np.max(gen_embs):.6f}")
+
+
+if __name__ == "__main__":
+    compare_embeddings()
diff --git a/stock_1d/d033/alpha158_beta/scripts/compare_predictions.py b/stock_1d/d033/alpha158_beta/scripts/compare_predictions.py
new file mode 100644
index 0000000..9cc32de
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/compare_predictions.py
@@ -0,0 +1,306 @@
+#!/usr/bin/env python
+"""
+Compare 0_7 vs 0_7_beta predictions.
+
+This script:
+1. Loads original 0_7 predictions (from DDB)
+2. Loads 0_7_beta predictions (from new embeddings)
+3. Calculates correlation between predictions
+4. Compares metrics (IC, RankIC, etc.) if actual returns available
+"""
+
+import os
+import numpy as np
+import polars as pl
+import pandas as pd
+from scipy.stats import spearmanr
+from typing import Optional, Dict
+
+# File paths
+PRED_0_7_FILE = "../data/original_predictions_0_7.parquet"
+PRED_0_7_BETA_FILE = "../data/predictions_beta_embedding.parquet"
+ACTUAL_RETURNS_FILE = "../data/actual_returns.parquet"
+
+
+def load_and_align_predictions():
+    """Load both prediction files and align them by datetime and instrument."""
+    print("Loading predictions...")
+
+    # Load 0_7 predictions
+    df_0_7 = pl.read_parquet(PRED_0_7_FILE)
+    print(f"0_7 predictions: {df_0_7.shape}")
+    print(f"  Date range: {df_0_7['datetime'].min()} to {df_0_7['datetime'].max()}")
+    print(f"  Unique instruments: {df_0_7['instrument'].n_unique()}")
+
+    # Load 0_7_beta predictions
+    df_beta = pl.read_parquet(PRED_0_7_BETA_FILE)
+    print(f"\n0_7_beta predictions: {df_beta.shape}")
+    print(f"  Date range: {df_beta['datetime'].min()} to {df_beta['datetime'].max()}")
+    print(f"  Unique instruments: {df_beta['instrument'].n_unique()}")
+
+    # Ensure compatible types
+    df_0_7 = df_0_7.with_columns([
+        pl.col('datetime').cast(pl.Int64),
+        pl.col('instrument').cast(pl.Int64)
+    ])
+    df_beta = df_beta.with_columns([
+        pl.col('datetime').cast(pl.Int64),
+        pl.col('instrument').cast(pl.Int64)
+    ])
+
+    # Rename prediction columns
+    df_0_7 = df_0_7.rename({'prediction': 'pred_0_7'})
+    df_beta = df_beta.rename({'prediction': 'pred_beta'})
+
+    # Join on datetime and instrument
+    df_joined = df_0_7.join(
+        df_beta,
+        on=['datetime', 'instrument'],
+        how='inner'
+    )
+
+    print(f"\nJoined predictions: {df_joined.shape}")
+    print(f"  Overlapping dates: {df_joined['datetime'].n_unique()}")
+    print(f"  Overlapping instruments: {df_joined['instrument'].n_unique()}")
+
+    return df_joined
+
+
+def calculate_correlation(df: pl.DataFrame) -> Dict[str, float]:
+    """Calculate correlation between 0_7 and 0_7_beta predictions."""
+    df_pd = df.to_pandas()
+
+    # Overall correlation
+    pearson_corr = df_pd['pred_0_7'].corr(df_pd['pred_beta'])
+    spearman_corr, _ = spearmanr(df_pd['pred_0_7'], df_pd['pred_beta'])
+
+    # Correlation by date
+    daily_corrs = []
+    for date, group in df_pd.groupby('datetime'):
+        if len(group) >= 2:
+            corr = group['pred_0_7'].corr(group['pred_beta'])
+            daily_corrs.append(corr)
+
+    daily_corr_mean = np.mean(daily_corrs)
+    daily_corr_std = np.std(daily_corrs)
+
+    return {
+        'pearson_corr': pearson_corr,
+        'spearman_corr': spearman_corr,
+        'daily_corr_mean': daily_corr_mean,
+        'daily_corr_std': daily_corr_std
+    }
+
+
+def calculate_ic_metrics(df: pl.DataFrame, actual_returns: pl.DataFrame) -> Dict:
+    """Calculate IC metrics for both prediction sets."""
+
+    # Join with actual returns
+    df_joined = df.join(
+        actual_returns,
+        on=['datetime', 'instrument'],
+        how='inner'
+    )
+
+    print(f"\nJoined with returns: {df_joined.shape}")
+
+    df_pd = df_joined.to_pandas()
+
+    # Find return column
+    return_col = None
+    for col in ['v2v_5d', 'return', 'actual_return', 'ret']:
+        if col in df_pd.columns:
+            return_col = col
+            break
+
+    if return_col is None:
+        print("No return column found!")
+        return {}
+
+    print(f"Using return column: {return_col}")
+
+    # Calculate daily IC for both predictions
+    results_0_7 = []
+    results_beta = []
+
+    for date, group in df_pd.groupby('datetime'):
+        if len(group) < 5:  # Need enough samples
+            continue
+
+        # IC (Pearson)
+        ic_0_7 = group['pred_0_7'].corr(group[return_col])
+        ic_beta = group['pred_beta'].corr(group[return_col])
+
+        # RankIC (Spearman)
+        rankic_0_7, _ = spearmanr(group['pred_0_7'], group[return_col])
+        rankic_beta, _ = spearmanr(group['pred_beta'], group[return_col])
+
+        results_0_7.append({'date': date, 'ic': ic_0_7, 'rankic': rankic_0_7})
+        results_beta.append({'date': date, 'ic': ic_beta, 'rankic': rankic_beta})
+
+    df_ic_0_7 = pd.DataFrame(results_0_7)
+    df_ic_beta = pd.DataFrame(results_beta)
+
+    metrics = {
+        '0_7': {
+            'ic_mean': df_ic_0_7['ic'].mean(),
+            'ic_std': df_ic_0_7['ic'].std(),
+            'ic_ir': df_ic_0_7['ic'].mean() / df_ic_0_7['ic'].std() if df_ic_0_7['ic'].std() > 0 else 0,
+            'rankic_mean': df_ic_0_7['rankic'].mean(),
+            'rankic_std': df_ic_0_7['rankic'].std(),
+            'rankic_ir': df_ic_0_7['rankic'].mean() / df_ic_0_7['rankic'].std() if df_ic_0_7['rankic'].std() > 0 else 0,
+        },
+        '0_7_beta': {
+            'ic_mean': df_ic_beta['ic'].mean(),
+            'ic_std': df_ic_beta['ic'].std(),
+            'ic_ir': df_ic_beta['ic'].mean() / df_ic_beta['ic'].std() if df_ic_beta['ic'].std() > 0 else 0,
+            'rankic_mean': df_ic_beta['rankic'].mean(),
+            'rankic_std': df_ic_beta['rankic'].std(),
+            'rankic_ir': df_ic_beta['rankic'].mean() / df_ic_beta['rankic'].std() if df_ic_beta['rankic'].std() > 0 else 0,
+        }
+    }
+
+    return metrics
+
+
+def calculate_top_tier_return(df: pl.DataFrame, actual_returns: pl.DataFrame, top_pct: float = 0.1) -> Dict:
+    """Calculate top-tier returns for both predictions."""
+
+    # Join with actual returns
+    df_joined = df.join(
+        actual_returns,
+        on=['datetime', 'instrument'],
+        how='inner'
+    )
+
+    df_pd = df_joined.to_pandas()
+
+    # Find return column
+    return_col = None
+    for col in ['v2v_5d', 'return', 'actual_return', 'ret']:
+        if col in df_pd.columns:
+            return_col = col
+            break
+
+    if return_col is None:
+        return {}
+
+    # Calculate top-tier returns
+    top_returns_0_7 = []
+    top_returns_beta = []
+
+    for date, group in df_pd.groupby('datetime'):
+        if len(group) < 10:
+            continue
+
+        n_top = max(1, int(len(group) * top_pct))
+
+        # Top predictions from 0_7
+        top_0_7 = group.nlargest(n_top, 'pred_0_7')
+        top_returns_0_7.append(top_0_7[return_col].mean())
+
+        # Top predictions from beta
+        top_beta = group.nlargest(n_top, 'pred_beta')
+        top_returns_beta.append(top_beta[return_col].mean())
+
+    return {
+        '0_7': {
+            'top_tier_return': np.mean(top_returns_0_7),
+            'top_tier_std': np.std(top_returns_0_7)
+        },
+        '0_7_beta': {
+            'top_tier_return': np.mean(top_returns_beta),
+            'top_tier_std': np.std(top_returns_beta)
+        }
+    }
+
+
+def main():
+    """Main comparison function."""
+    print("=" * 70)
+    print("COMPARISON: Alpha158 0_7 vs 0_7_beta Predictions")
+    print("=" * 70)
+
+    # Load and align predictions
+    df_joined = load_and_align_predictions()
+
+    if len(df_joined) == 0:
+        print("\nERROR: No overlapping predictions found!")
+        return
+
+    # Calculate correlation
+    print("\n" + "-" * 70)
+    print("PREDICTION CORRELATION")
+    print("-" * 70)
+
+    corr_metrics = calculate_correlation(df_joined)
+    print(f"Overall Pearson correlation: {corr_metrics['pearson_corr']:.4f}")
+    print(f"Overall Spearman correlation: {corr_metrics['spearman_corr']:.4f}")
+    print(f"Daily correlation mean: {corr_metrics['daily_corr_mean']:.4f}")
+    print(f"Daily correlation std: {corr_metrics['daily_corr_std']:.4f}")
+
+    # Prediction statistics
+    print("\n" + "-" * 70)
+    print("PREDICTION STATISTICS")
+    print("-" * 70)
+
+    df_pd = df_joined.to_pandas()
+    print(f"0_7 predictions:")
+    print(f"  Mean: {df_pd['pred_0_7'].mean():.6f}")
+    print(f"  Std:  {df_pd['pred_0_7'].std():.6f}")
+    print(f"  Min:  {df_pd['pred_0_7'].min():.6f}")
+    print(f"  Max:  {df_pd['pred_0_7'].max():.6f}")
+
+    print(f"\n0_7_beta predictions:")
+    print(f"  Mean: {df_pd['pred_beta'].mean():.6f}")
+    print(f"  Std:  {df_pd['pred_beta'].std():.6f}")
+    print(f"  Min:  {df_pd['pred_beta'].min():.6f}")
+    print(f"  Max:  {df_pd['pred_beta'].max():.6f}")
+
+    # Load actual returns and calculate IC metrics if available
+    if os.path.exists(ACTUAL_RETURNS_FILE):
+        print("\n" + "-" * 70)
+        print("IC METRICS (with actual returns)")
+        print("-" * 70)
+
+        actual_returns = pl.read_parquet(ACTUAL_RETURNS_FILE)
+        print(f"Loaded actual returns: {actual_returns.shape}")
+
+        ic_metrics = calculate_ic_metrics(df_joined, actual_returns)
+
+        if ic_metrics:
+            print(f"\n{'Metric':<20} {'0_7':<12} {'0_7_beta':<12} {'Diff':<12}")
+            print("-" * 56)
+
+            for metric in ['ic_mean', 'ic_std', 'ic_ir', 'rankic_mean', 'rankic_std', 'rankic_ir']:
+                v0 = ic_metrics['0_7'][metric]
+                v1 = ic_metrics['0_7_beta'][metric]
+                diff = v1 - v0
+                print(f"{metric:<20} {v0:>11.4f} {v1:>11.4f} {diff:>+11.4f}")
+
+        # Top-tier returns
+        print("\n" + "-" * 70)
+        print("TOP-TIER RETURNS (top 10%)")
+        print("-" * 70)
+
+        top_tier = calculate_top_tier_return(df_joined, actual_returns, top_pct=0.1)
+
+        if top_tier:
+            print(f"{'':<20} {'0_7':<12} {'0_7_beta':<12} {'Diff':<12}")
+            print("-" * 56)
+
+            t0 = top_tier['0_7']['top_tier_return']
+            t1 = top_tier['0_7_beta']['top_tier_return']
+            diff = t1 - t0
+            print(f"{'Top-tier return':<20} {t0:>11.4f} {t1:>11.4f} {diff:>+11.4f}")
+    else:
+        print(f"\nActual returns file not found: {ACTUAL_RETURNS_FILE}")
+        print("Skipping IC metrics calculation.")
+
+    print("\n" + "=" * 70)
+    print("Comparison complete!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/stock_1d/d033/alpha158_beta/scripts/dump_qlib_gold_standard.py b/stock_1d/d033/alpha158_beta/scripts/dump_qlib_gold_standard.py
new file mode 100644
index 0000000..f311500
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/dump_qlib_gold_standard.py
@@ -0,0 +1,421 @@
+#!/usr/bin/env python
+"""
+Dump Gold-Standard Data from Qlib Pipeline
+
+This script exports processed feature data from the original Qlib pipeline
+in multiple formats for debugging and comparison with the standalone Polars implementation.
+
+Usage:
+    python dump_qlib_gold_standard.py --start-date 2020-01-02 --end-date 2020-01-10 --output-dir ../data/
+"""
+
+import argparse
+import os
+import sys
+import pickle as pkl
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import pandas as pd
+import polars as pl
+import numpy as np
+
+# Patch NumPy 2.0 compatibility: np.NaN was removed, use np.nan
+if not hasattr(np, 'NaN'):
+    np.NaN = np.nan
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Dump gold-standard data from Qlib pipeline"
+    )
+    parser.add_argument(
+        "--start-date",
+        type=str,
+        default="2020-01-02",
+        help="Start date for data export (YYYY-MM-DD)",
+    )
+    parser.add_argument(
+        "--end-date",
+        type=str,
+        default="2020-01-10",
+        help="End date for data export (YYYY-MM-DD)",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default="../data/",
+        help="Output directory for exported files",
+    )
+    parser.add_argument(
+        "--qlib-dataset-path",
+        type=str,
+        default="/home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/",
+        help="Path to Qlib dataset module",
+    )
+    return parser.parse_args()
+
+
+def load_qlib_data(qlib_dataset_path, since_date):
+    """
+    Load processed data from Qlib pipeline.
+
+    This function loads data using the original Qlib pipeline and handles
+    the SepDataFrame return type by concatenating column groups.
+
+    Args:
+        qlib_dataset_path: Path to the Qlib dataset module
+        since_date: Start date for loading data (YYYY-MM-DD)
+
+    Returns:
+        pd.DataFrame: Processed DataFrame from Qlib pipeline with all column groups concatenated
+    """
+    import importlib.util
+    import datetime as dt
+
+    # Patch ruamel.yaml to provide safe_load compatibility
+    import ruamel.yaml as yaml
+
+    # Create a YAML instance with safe loader for backward compatibility
+    _yaml = yaml.YAML(typ='safe', pure=True)
+
+    # Monkey-patch safe_load to use the new API
+    def patched_safe_load(stream):
+        import io
+        if isinstance(stream, str):
+            stream = io.StringIO(stream)
+        return _yaml.load(stream)
+
+    yaml.safe_load = patched_safe_load
+
+    # Load the module directly
+    spec = importlib.util.spec_from_file_location(
+        "qlib_dataset",
+        os.path.join(qlib_dataset_path, "__init__.py")
+    )
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    # Parse since_date
+    since_date_dt = pd.to_datetime(since_date)
+    # Load with extra history for Diff processor
+    load_start = (since_date_dt - dt.timedelta(days=20)).strftime("%Y-%m-%d")
+
+    print(f"  Loading data with handler (load_start={load_start})...")
+
+    # Use _load_from_yaml to get raw handler data (SepDataFrame)
+    handler_data = module._load_from_yaml(
+        os.path.join(qlib_dataset_path, "handler.yaml"),
+        load_start
+    )
+
+    # Handle SepDataFrame - extract and concatenate column groups
+    if hasattr(handler_data, '_data') or hasattr(handler_data, '_df_dict'):
+        # It's a SepDataFrame from AggHandler
+        df_dict = getattr(handler_data, '_data', None) or getattr(handler_data, '_df_dict', {})
+        group_names = list(df_dict.keys())
+        print(f"  Handler returned SepDataFrame with groups: {group_names}")
+
+        # Concatenate all column groups into a single DataFrame
+        all_dfs = []
+        for group in group_names:
+            df = df_dict[group]
+            if df is not None and len(df.columns) > 0:
+                df_copy = df.copy()
+                # Add group prefix to columns
+                df_copy.columns = [f"{group}::{col}" for col in df_copy.columns]
+                all_dfs.append(df_copy)
+                print(f"    Group '{group}': {df_copy.shape}")
+
+        # Concatenate all groups along axis 1
+        raw_df = pd.concat(all_dfs, axis=1)
+        print(f"  Concatenated raw data shape: {raw_df.shape}")
+    else:
+        raw_df = handler_data
+        print(f"  Raw data shape: {raw_df.shape}")
+
+    # Load processor list
+    proc_path = os.path.join(qlib_dataset_path, "proc_list.proc")
+    print(f"  Loading processor list from: {proc_path}")
+    with open(proc_path, "rb") as f:
+        proc_list = pkl.load(f)
+    print(f"  Processor list has {len(proc_list)} processors")
+    for i, proc in enumerate(proc_list):
+        print(f"    {i+1}. {type(proc).__name__}")
+
+    # Apply processors
+    from qlib.contrib.data.utils import apply_proc_list
+    print(f"  Applying processor list (with_fit=False)...")
+
+    # The processor list expects columns without the group prefix
+    # We need to strip the prefix before applying processors
+    # Create a mapping and restore original column names
+    col_mapping = {}
+    for col in raw_df.columns:
+        if '::' in col:
+            original = col.split('::', 1)[1]
+            col_mapping[col] = original
+
+    # Rename columns back to original names for processor application
+    raw_df_renamed = raw_df.rename(columns=col_mapping)
+    print(f"  Renamed columns for processor compatibility. Shape: {raw_df_renamed.shape}")
+
+    # Convert boolean columns to object to avoid NaN -> int conversion issues
+    bool_cols = raw_df_renamed.select_dtypes(include=['bool']).columns
+    print(f"  Converting {len(bool_cols)} boolean columns to object dtype")
+    for col in bool_cols:
+        raw_df_renamed[col] = raw_df_renamed[col].astype(object)
+
+    # Apply processors
+    df = apply_proc_list(raw_df_renamed, proc_list=proc_list, with_fit=False)
+    print(f"  Applied processor list. Result shape: {df.shape}")
+
+    # Add back group prefixes to columns
+    new_col_mapping = {v: k for k, v in col_mapping.items()}
+    df = df.rename(columns=new_col_mapping)
+    print(f"  Restored column group prefixes. Shape: {df.shape}")
+
+    # Filter to requested date range
+    df = df.loc(axis=0)[slice(since_date_dt, None)]
+    print(f"  Filtered to since_date={since_date}. Final shape: {df.shape}")
+
+    return df
+
+
+def export_column_groups(df, output_dir, prefix="gold_standard"):
+    """
+    Export separate files for different column groups.
+
+    Column groups:
+    - feature: alpha158 + alpha158_ntrl
+    - feature_ext: extended features (log_size_diff, etc.)
+    - feature_flag: market flags (IsST, IsN, IsZt, IsDt, etc.)
+    - indus_idx: industry index columns
+    """
+    # Identify column groups based on naming conventions
+    feature_cols = [c for c in df.columns if c.startswith("feature::")]
+    feature_ext_cols = [c for c in df.columns if c.startswith("feature_ext::")]
+    feature_flag_cols = [c for c in df.columns if c.startswith("feature_flag::")]
+    indus_idx_cols = [c for c in df.columns if c.startswith("indus_idx::")]
+
+    # Also include the ntrl suffixed columns
+    feature_ntrl_cols = [c for c in df.columns if c.endswith("_ntrl")]
+
+    export_paths = {}
+
+    # Export feature columns (alpha158 + alpha158_ntrl)
+    if feature_cols:
+        feature_df = df[feature_cols]
+        path = os.path.join(output_dir, f"{prefix}_feature.parquet")
+        feature_df.to_parquet(path)
+        export_paths["feature"] = path
+        print(f"  Exported feature columns ({len(feature_cols)}): {path}")
+
+    # Export feature_ext columns
+    if feature_ext_cols:
+        feature_ext_df = df[feature_ext_cols]
+        path = os.path.join(output_dir, f"{prefix}_feature_ext.parquet")
+        feature_ext_df.to_parquet(path)
+        export_paths["feature_ext"] = path
+        print(f"  Exported feature_ext columns ({len(feature_ext_cols)}): {path}")
+
+    # Export feature_flag columns
+    if feature_flag_cols:
+        feature_flag_df = df[feature_flag_cols]
+        path = os.path.join(output_dir, f"{prefix}_feature_flag.parquet")
+        feature_flag_df.to_parquet(path)
+        export_paths["feature_flag"] = path
+        print(f"  Exported feature_flag columns ({len(feature_flag_cols)}): {path}")
+
+    # Export indus_idx columns
+    if indus_idx_cols:
+        indus_idx_df = df[indus_idx_cols]
+        path = os.path.join(output_dir, f"{prefix}_indus_idx.parquet")
+        indus_idx_df.to_parquet(path)
+        export_paths["indus_idx"] = path
+        print(f"  Exported indus_idx columns ({len(indus_idx_cols)}): {path}")
+
+    # Export feature_ntrl columns separately
+    if feature_ntrl_cols:
+        feature_ntrl_df = df[feature_ntrl_cols]
+        path = os.path.join(output_dir, f"{prefix}_feature_ntrl.parquet")
+        feature_ntrl_df.to_parquet(path)
+        export_paths["feature_ntrl"] = path
+        print(f"  Exported feature_ntrl columns ({len(feature_ntrl_cols)}): {path}")
+
+    return export_paths
+
+
+def export_metadata(df, output_dir, prefix="gold_standard", proc_list_path=None):
+    """
+    Export metadata about the dataset.
+
+    Includes:
+    - Column names and shapes
+    - Processor list configuration
+    - Date range coverage
+    - NaN value statistics
+    """
+    metadata_path = os.path.join(output_dir, f"{prefix}_metadata.txt")
+
+    with open(metadata_path, "w") as f:
+        f.write("=" * 80 + "\n")
+        f.write("GOLD-STANDARD QLIB PIPELINE OUTPUT - METADATA\n")
+        f.write("=" * 80 + "\n\n")
+
+        f.write(f"Export Date: {datetime.now().isoformat()}\n\n")
+
+        f.write("DATAFRAME SHAPE\n")
+        f.write("-" * 40 + "\n")
+        f.write(f"Shape: {df.shape}\n")
+        f.write(f"Rows: {len(df)}\n")
+        f.write(f"Columns: {len(df.columns)}\n\n")
+
+        f.write("DATE RANGE\n")
+        f.write("-" * 40 + "\n")
+        dates = df.index.get_level_values("datetime").unique()
+        f.write(f"Min Date: {dates.min()}\n")
+        f.write(f"Max Date: {dates.max()}\n")
+        f.write(f"Unique Dates: {len(dates)}\n\n")
+
+        f.write("INSTRUMENTS\n")
+        f.write("-" * 40 + "\n")
+        instruments = df.index.get_level_values("instrument").unique()
+        f.write(f"Unique Instruments: {len(instruments)}\n")
+        f.write(f"Sample Instruments: {list(instruments[:10])}\n\n")
+
+        f.write("COLUMN GROUPS\n")
+        f.write("-" * 40 + "\n")
+
+        # Categorize columns
+        feature_cols = [c for c in df.columns if c.startswith("feature::")]
+        feature_ext_cols = [c for c in df.columns if c.startswith("feature_ext::")]
+        feature_flag_cols = [c for c in df.columns if c.startswith("feature_flag::")]
+        indus_idx_cols = [c for c in df.columns if c.startswith("indus_idx::")]
+        feature_ntrl_cols = [c for c in df.columns if c.endswith("_ntrl")]
+
+        f.write(f"feature:: columns: {len(feature_cols)}\n")
+        f.write(f"feature_ext:: columns: {len(feature_ext_cols)}\n")
+        f.write(f"feature_flag:: columns: {len(feature_flag_cols)}\n")
+        f.write(f"indus_idx:: columns: {len(indus_idx_cols)}\n")
+        f.write(f"*_ntrl columns: {len(feature_ntrl_cols)}\n\n")
+
+        f.write("COLUMN DTYPES\n")
+        f.write("-" * 40 + "\n")
+        dtype_counts = df.dtypes.value_counts()
+        for dtype, count in dtype_counts.items():
+            f.write(f"{dtype}: {count}\n")
+        f.write("\n")
+
+        f.write("NAN STATISTICS\n")
+        f.write("-" * 40 + "\n")
+        nan_counts = df.isna().sum()
+        cols_with_nan = nan_counts[nan_counts > 0]
+        f.write(f"Columns with NaN: {len(cols_with_nan)}\n")
+        f.write(f"Total NaN values: {df.isna().sum().sum()}\n\n")
+
+        if len(cols_with_nan) > 0:
+            f.write("NaN per column (top 20):\n")
+            for col, cnt in cols_with_nan.nlargest(20).items():
+                f.write(f"  {col}: {cnt} ({100*cnt/len(df):.2f}%)\n")
+        f.write("\n")
+
+        f.write("ALL COLUMN NAMES\n")
+        f.write("-" * 40 + "\n")
+        for i, col in enumerate(df.columns):
+            f.write(f"  {i+1}. {col}\n")
+        f.write("\n")
+
+        if proc_list_path and os.path.exists(proc_list_path):
+            f.write("PROCESSOR LIST\n")
+            f.write("-" * 40 + "\n")
+            f.write(f"Source: {proc_list_path}\n")
+            try:
+                with open(proc_list_path, "rb") as pf:
+                    proc_list = pkl.load(pf)
+                f.write(f"Number of processors: {len(proc_list)}\n\n")
+                for i, proc in enumerate(proc_list):
+                    f.write(f"  {i+1}. {proc}\n")
+            except Exception as e:
+                f.write(f"Could not load processor list: {e}\n")
+            f.write("\n")
+
+    print(f"Exported metadata: {metadata_path}")
+    return metadata_path
+
+
+def main():
+    args = parse_args()
+
+    # Parse dates
+    start_date = pd.to_datetime(args.start_date)
+    end_date = pd.to_datetime(args.end_date)
+
+    # Create output directory if it doesn't exist
+    output_dir = Path(args.output_dir).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print("=" * 80)
+    print("DUMP GOLD-STANDARD DATA FROM QLIB PIPELINE")
+    print("=" * 80)
+    print(f"Date Range: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
+    print(f"Output Directory: {output_dir}")
+    print(f"Qlib Dataset Path: {args.qlib_dataset_path}")
+    print()
+
+    # Load data from Qlib pipeline
+    print("Step 1: Loading data from Qlib pipeline...")
+    print(f"  Loading since_date={start_date.strftime('%Y-%m-%d')}")
+
+    try:
+        df = load_qlib_data(args.qlib_dataset_path, start_date.strftime("%Y-%m-%d"))
+        print(f"  Loaded DataFrame with shape: {df.shape}")
+    except Exception as e:
+        print(f"  ERROR: Failed to load data from Qlib pipeline: {e}")
+        sys.exit(1)
+
+    # Filter to requested date range
+    print("\nStep 2: Filtering to requested date range...")
+    df = df.loc(axis=0)[slice(start_date, end_date)]
+    print(f"  Filtered shape: {df.shape}")
+
+    # Export full DataFrame
+    print("\nStep 3: Exporting full DataFrame...")
+    prefix = f"gold_standard_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}"
+
+    parquet_path = output_dir / f"{prefix}.parquet"
+    df.to_parquet(parquet_path)
+    print(f"  Exported parquet: {parquet_path}")
+
+    pkl_path = output_dir / f"{prefix}.pkl"
+    df.to_pickle(pkl_path)
+    print(f"  Exported pickle: {pkl_path}")
+
+    # Export column groups
+    print("\nStep 4: Exporting column groups...")
+    export_paths = export_column_groups(df, str(output_dir), prefix=prefix)
+
+    # Export metadata
+    print("\nStep 5: Exporting metadata...")
+    proc_list_path = os.path.join(args.qlib_dataset_path, "proc_list.proc")
+    export_metadata(df, str(output_dir), prefix=prefix, proc_list_path=proc_list_path)
+
+    # Summary
+    print("\n" + "=" * 80)
+    print("EXPORT SUMMARY")
+    print("=" * 80)
+    print(f"Date range: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
+    print(f"Output directory: {output_dir}")
+    print(f"Total rows: {len(df)}")
+    print(f"Total columns: {len(df.columns)}")
+    print(f"\nFiles exported:")
+    print(f"  - {prefix}.parquet (full DataFrame)")
+    print(f"  - {prefix}.pkl (pickle, preserves dtypes)")
+    print(f"  - {prefix}_metadata.txt (column info, statistics)")
+    for group, path in export_paths.items():
+        print(f"  - {os.path.basename(path)} ({group} columns)")
+    print("\nDone!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/stock_1d/d033/alpha158_beta/scripts/dump_qlib_gold_standard_simple.py b/stock_1d/d033/alpha158_beta/scripts/dump_qlib_gold_standard_simple.py
new file mode 100644
index 0000000..d475d30
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/dump_qlib_gold_standard_simple.py
@@ -0,0 +1,270 @@
+#!/usr/bin/env python
+"""
+Dump Gold-Standard Data from Qlib Pipeline (Simple Version)
+
+This script exports the RAW feature data from the Qlib pipeline BEFORE
+any processors are applied. This is useful for debugging and comparison.
+
+NOTE: This script loads ALL data from DolphinDB and then filters to the
+requested date range. For large date ranges, this may require significant memory.
+
+Usage:
+    python dump_qlib_gold_standard_simple.py --start-date 2020-01-02 --end-date 2020-01-10
+"""
+
+import argparse
+import os
+import sys
+import pickle as pkl
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import pandas as pd
+import numpy as np
+
+# Patch NumPy 2.0 compatibility: np.NaN was removed, use np.nan
+if not hasattr(np, 'NaN'):
+    np.NaN = np.nan
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Dump gold-standard raw data from Qlib pipeline",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Export a few days for debugging (recommended)
+    python dump_qlib_gold_standard_simple.py --start-date 2020-01-02 --end-date 2020-01-10
+
+    # Export with custom output directory
+    python dump_qlib_gold_standard_simple.py --start-date 2020-01-02 --end-date 2020-01-10 --output-dir /path/to/output
+        """
+    )
+    parser.add_argument(
+        "--start-date",
+        type=str,
+        default="2020-01-02",
+        help="Start date for data export (YYYY-MM-DD)",
+    )
+    parser.add_argument(
+        "--end-date",
+        type=str,
+        default="2020-01-10",
+        help="End date for data export (YYYY-MM-DD)",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default="../data/",
+        help="Output directory for exported files",
+    )
+    parser.add_argument(
+        "--qlib-dataset-path",
+        type=str,
+        default="/home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/",
+        help="Path to Qlib dataset module",
+    )
+    parser.add_argument(
+        "--instruments",
+        type=str,
+        default=None,
+        help="Comma-separated list of instrument codes to export (default: all)",
+    )
+    return parser.parse_args()
+
+
+def load_raw_data(qlib_dataset_path, since_date, instruments=None):
+    """
+    Load RAW data from Qlib pipeline (before processor list is applied).
+
+    Returns a dict of DataFrames, one per column group.
+
+    Args:
+        qlib_dataset_path: Path to Qlib dataset module
+        since_date: Start date for loading (needs history before for Diff)
+        instruments: Optional list of instrument codes to filter
+    """
+    import importlib.util
+    import ruamel.yaml as yaml
+
+    # Create a YAML instance with safe loader for backward compatibility
+    _yaml = yaml.YAML(typ='safe', pure=True)
+
+    def patched_safe_load(stream):
+        import io
+        if isinstance(stream, str):
+            stream = io.StringIO(stream)
+        return _yaml.load(stream)
+
+    yaml.safe_load = patched_safe_load
+
+    # Load the module directly
+    spec = importlib.util.spec_from_file_location(
+        "qlib_dataset",
+        os.path.join(qlib_dataset_path, "__init__.py")
+    )
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    # Parse since_date
+    since_date_dt = pd.to_datetime(since_date)
+    # Load with extra history for Diff processor
+    load_start = (since_date_dt - timedelta(days=20)).strftime("%Y-%m-%d")
+
+    print(f"  Loading raw data from handler (load_start={load_start})...")
+    if instruments:
+        print(f"  Filtering instruments: {instruments[:5]}... ({len(instruments)} total)")
+
+    # Use _load_from_yaml to get raw handler data (SepDataFrame)
+    handler_data = module._load_from_yaml(
+        os.path.join(qlib_dataset_path, "handler.yaml"),
+        load_start
+    )
+
+    # Handle SepDataFrame - extract column groups
+    if hasattr(handler_data, '_data') or hasattr(handler_data, '_df_dict'):
+        df_dict = getattr(handler_data, '_data', None) or getattr(handler_data, '_df_dict', {})
+        group_names = list(df_dict.keys())
+        print(f"  Handler returned SepDataFrame with groups: {group_names}")
+
+        # Filter instruments if specified
+        if instruments:
+            print(f"  Filtering to specified instruments...")
+            for group in group_names:
+                if df_dict[group] is not None:
+                    df = df_dict[group]
+                    # Filter by instrument level
+                    if isinstance(df.index, pd.MultiIndex):
+                        mask = df.index.get_level_values('instrument').isin(instruments)
+                        df_dict[group] = df[mask]
+                        print(f"    Group '{group}': {df_dict[group].shape} (filtered)")
+
+        for group in group_names:
+            df = df_dict[group]
+            if df is not None:
+                print(f"    Group '{group}': shape={df.shape}, columns={len(df.columns)}")
+
+        return df_dict, handler_data.index
+    else:
+        print(f"  Handler returned DataFrame: shape={handler_data.shape}")
+        return {"default": handler_data}, handler_data.index
+
+
+def export_data(df_dict, index, output_dir, start_date, end_date):
+    """Export data to parquet and pickle files."""
+    output_dir = Path(output_dir).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    start_date = pd.to_datetime(start_date)
+    end_date = pd.to_datetime(end_date)
+
+    # Filter index
+    mask = (index >= start_date) & (index <= end_date)
+    filtered_index = index[mask]
+
+    print(f"\nExporting data for date range: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
+    print(f"  Filtered index has {len(filtered_index)} dates")
+
+    prefix = f"gold_standard_raw_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}"
+
+    exported_files = []
+
+    # Export each group separately
+    for group, df in df_dict.items():
+        if df is None or len(df.columns) == 0:
+            print(f"  Skipping empty group '{group}'")
+            continue
+
+        # Filter by date
+        df_filtered = df.loc[df.index.isin(filtered_index)]
+        print(f"  Group '{group}': {df_filtered.shape}")
+
+        # Export to parquet
+        parquet_path = output_dir / f"{prefix}_{group}.parquet"
+        df_filtered.to_parquet(parquet_path)
+        exported_files.append(str(parquet_path))
+        print(f"    -> {parquet_path}")
+
+        # Export to pickle (preserves dtypes)
+        pkl_path = output_dir / f"{prefix}_{group}.pkl"
+        df_filtered.to_pickle(pkl_path)
+        exported_files.append(str(pkl_path))
+
+    # Also create a metadata file
+    metadata_path = output_dir / f"{prefix}_metadata.txt"
+    with open(metadata_path, "w") as f:
+        f.write("=" * 80 + "\n")
+        f.write("GOLD-STANDARD RAW DATA - METADATA\n")
+        f.write("=" * 80 + "\n\n")
+        f.write(f"Export Date: {datetime.now().isoformat()}\n")
+        f.write(f"Date Range: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}\n")
+        f.write(f"Total Dates: {len(filtered_index)}\n\n")
+
+        f.write("COLUMN GROUPS:\n")
+        f.write("-" * 40 + "\n")
+        for group, df in df_dict.items():
+            if df is not None:
+                f.write(f"  {group}:\n")
+                f.write(f"    Shape: {df.shape}\n")
+                f.write(f"    Columns: {len(df.columns)}\n")
+                f.write(f"    Sample columns: {list(df.columns[:5])}...\n\n")
+
+        f.write("\nPROCESSOR LIST (for reference):\n")
+        f.write("-" * 40 + "\n")
+        proc_path = "/home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/proc_list.proc"
+        if os.path.exists(proc_path):
+            with open(proc_path, "rb") as pf:
+                proc_list = pkl.load(pf)
+            f.write(f"Number of processors: {len(proc_list)}\n\n")
+            for i, proc in enumerate(proc_list):
+                f.write(f"  {i+1}. {type(proc).__module__}.{type(proc).__name__}\n")
+        else:
+            f.write(f"Processor list not found: {proc_path}\n")
+
+    exported_files.append(str(metadata_path))
+
+    return exported_files
+
+
+def main():
+    args = parse_args()
+
+    print("=" * 80)
+    print("DUMP GOLD-STANDARD RAW DATA FROM QLIB PIPELINE")
+    print("=" * 80)
+    print(f"Date Range: {args.start_date} to {args.end_date}")
+    print(f"Output Directory: {args.output_dir}")
+    print(f"Qlib Dataset Path: {args.qlib_dataset_path}")
+    print()
+
+    # Load raw data
+    print("Step 1: Loading raw data from Qlib pipeline...")
+    try:
+        instruments = None
+        if args.instruments:
+            instruments = args.instruments.split(',')
+        df_dict, index = load_raw_data(args.qlib_dataset_path, args.start_date, instruments=instruments)
+    except Exception as e:
+        print(f"  ERROR: Failed to load data: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+    # Export data
+    print("\nStep 2: Exporting data...")
+    exported_files = export_data(df_dict, index, args.output_dir, args.start_date, args.end_date)
+
+    # Summary
+    print("\n" + "=" * 80)
+    print("EXPORT SUMMARY")
+    print("=" * 80)
+    print(f"Date range: {args.start_date} to {args.end_date}")
+    print(f"Output directory: {Path(args.output_dir).resolve()}")
+    print(f"\nFiles exported ({len(exported_files)}):")
+    for f in exported_files:
+        print(f"  - {f}")
+    print("\nDone!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/stock_1d/d033/alpha158_beta/scripts/fetch_embeddings.py b/stock_1d/d033/alpha158_beta/scripts/fetch_embeddings.py
new file mode 100755
index 0000000..4b4f5d4
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/fetch_embeddings.py
@@ -0,0 +1,210 @@
+#!/usr/bin/env python
+"""
+Fetch embedding data from DolphinDB and save to parquet.
+
+This script:
+1. Connects to DolphinDB
+2. Queries the dwm_1day_multicast_csencode table
+3. Filters by version (default: 'csiallx_feature2_ntrla_flag_pnlnorm')
+4. Filters by date range
+5. Transforms columns (m_nDate -> datetime, code -> instrument)
+6. Saves to local parquet file
+"""
+
+import os
+import polars as pl
+import pandas as pd
+from datetime import datetime
+from typing import Optional
+
+# DolphinDB config (from CLAUDE.md)
+DDB_CONFIG = {
+    "host": "192.168.1.146",
+    "port": 8848,
+    "username": "admin",
+    "password": "123456"
+}
+
+DB_PATH = "dfs://daily_stock_run_multicast"
+TABLE_NAME = "dwm_1day_multicast_csencode"
+DEFAULT_VERSION = "csix_alpha158b_ext2_zscore_vae4"
+DEFAULT_START_DATE = "2019-01-01"
+DEFAULT_END_DATE = "2025-12-31"
+OUTPUT_FILE = "../data/embeddings_from_ddb.parquet"
+
+
+def fetch_embeddings(
+    start_date: str = DEFAULT_START_DATE,
+    end_date: str = DEFAULT_END_DATE,
+    version: str = DEFAULT_VERSION,
+    output_file: str = OUTPUT_FILE
+) -> pl.DataFrame:
+    """
+    Fetch embedding data from DolphinDB.
+
+    Args:
+        start_date: Start date filter (YYYY-MM-DD)
+        end_date: End date filter (YYYY-MM-DD)
+        version: Version string to filter by
+        output_file: Output parquet file path
+
+    Returns:
+        Polars DataFrame with columns: [datetime, instrument, embedding_0, embedding_1, ...]
+    """
+    print("=" * 60)
+    print("Fetching embedding data from DolphinDB")
+    print("=" * 60)
+    print(f"Database: {DB_PATH}")
+    print(f"Table: {TABLE_NAME}")
+    print(f"Version: {version}")
+    print(f"Date range: {start_date} to {end_date}")
+
+    # Connect to DolphinDB
+    try:
+        from qshare.io.ddb import get_ddb_sess
+        sess = get_ddb_sess(host=DDB_CONFIG["host"], port=DDB_CONFIG["port"])
+        print(f"Connected to DolphinDB at {DDB_CONFIG['host']}:{DDB_CONFIG['port']}")
+    except Exception as e:
+        print(f"Error connecting to DolphinDB: {e}")
+        raise
+
+    # Convert date strings to DolphinDB date format (YYYY.MM.DD)
+    start_ddb = start_date.replace("-", ".")
+    end_ddb = end_date.replace("-", ".")
+
+    # Build SQL query with filters in the WHERE clause
+    # Note: DolphinDB requires date() function for date literals
+    # Use single-line SQL to avoid parsing issues
+    sql = f'select * from loadTable("{DB_PATH}", "{TABLE_NAME}") where version = "{version}" and m_nDate >= date({start_ddb}) and m_nDate <= date({end_ddb})'
+
+    print(f"Executing SQL: {sql.strip()}")
+
+    try:
+        # Execute query and get pandas DataFrame
+        df_pd = sess.run(sql)
+        print(f"Fetched {len(df_pd)} rows from DolphinDB")
+        print(f"Columns: {df_pd.columns.tolist()}")
+        if len(df_pd) > 0:
+            print(f"Sample:\n{df_pd.head()}")
+    except Exception as e:
+        print(f"Error executing query: {e}")
+        raise
+    finally:
+        sess.close()
+
+    # Convert to Polars
+    df = pl.from_pandas(df_pd)
+    print(f"Columns in result: {df.columns}")
+
+    # Transform columns
+    # Rename m_nDate -> datetime and convert to uint32 (YYYYMMDD)
+    if 'm_nDate' in df.columns:
+        df = df.rename({"m_nDate": "datetime"})
+
+        if df["datetime"].dtype == pl.Datetime:
+            df = df.with_columns([
+                pl.col("datetime").dt.strftime("%Y%m%d").cast(pl.UInt32).alias("datetime")
+            ])
+        elif df["datetime"].dtype == pl.Date:
+            df = df.with_columns([
+                pl.col("datetime").dt.strftime("%Y%m%d").cast(pl.UInt32).alias("datetime")
+            ])
+        elif df["datetime"].dtype in [pl.Utf8, pl.String]:
+            df = df.with_columns([
+                pl.col("datetime").str.replace("-", "").cast(pl.UInt32).alias("datetime")
+            ])
+        else:
+            df = df.with_columns([pl.col("datetime").cast(pl.UInt32).alias("datetime")])
+
+    # Rename code -> instrument and convert to uint32
+    if 'code' in df.columns:
+        df = df.rename({"code": "instrument"})
+
+        # Convert TS code (e.g., 'SH600085') to uint32 by removing prefix and casting
+        df = df.with_columns([
+            pl.col("instrument")
+            .str.replace("SH", "")
+            .str.replace("SZ", "")
+            .str.replace("BJ", "")
+            .cast(pl.UInt32)
+            .alias("instrument")
+        ])
+
+    # Drop version column if present (no longer needed)
+    if 'version' in df.columns:
+        df = df.drop('version')
+
+    # Check if 'values' column contains lists (embedding vectors)
+    if 'values' in df.columns and df['values'].dtype == pl.List:
+        # Get the embedding dimension from the first row
+        first_val = df['values'][0]
+        if first_val is not None:
+            emb_dim = len(first_val)
+            print(f"Detected embedding dimension: {emb_dim}")
+
+            # Expand the list column to separate embedding columns
+            embedding_cols = []
+            for i in range(emb_dim):
+                col_name = f"embedding_{i}"
+                embedding_cols.append(col_name)
+                df = df.with_columns([
+                    pl.col('values').list.get(i).alias(col_name)
+                ])
+
+            # Drop the original values column
+            df = df.drop('values')
+
+            # Reorder columns: datetime, instrument, embedding_0, embedding_1, ...
+            core_cols = ['datetime', 'instrument']
+            final_cols = core_cols + embedding_cols
+            df = df.select(final_cols)
+
+            print(f"Expanded embeddings into {emb_dim} columns")
+    else:
+        # Identify embedding columns (typically named 'feature_0', 'feature_1', etc. or 'emb_0', 'emb_1', etc.)
+        # Keep datetime, instrument, and any embedding/feature columns
+        core_cols = ['datetime', 'instrument']
+        embedding_cols = [c for c in df.columns if c not in core_cols + ['version']]
+
+        # Select and order columns
+        final_cols = core_cols + sorted(embedding_cols)
+        df = df.select(final_cols)
+
+    print(f"\nTransformed data:")
+    print(f"  Shape: {df.shape}")
+    print(f"  Columns: {df.columns[:10]}..." if len(df.columns) > 10 else f"  Columns: {df.columns}")
+    print(f"  Date range: {df['datetime'].min()} to {df['datetime'].max()}")
+    print(f"  Instrument count: {df['instrument'].n_unique()}")
+    print(f"  Sample:\n{df.head()}")
+
+    # Save to parquet
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    df.write_parquet(output_file)
+    print(f"\nSaved to: {output_file}")
+
+    return df
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fetch embedding data from DolphinDB")
+    parser.add_argument("--start-date", type=str, default=DEFAULT_START_DATE,
+                        help="Start date (YYYY-MM-DD)")
+    parser.add_argument("--end-date", type=str, default=DEFAULT_END_DATE,
+                        help="End date (YYYY-MM-DD)")
+    parser.add_argument("--version", type=str, default=DEFAULT_VERSION,
+                        help="Version string to filter by")
+    parser.add_argument("--output", type=str, default=OUTPUT_FILE,
+                        help="Output parquet file")
+
+    args = parser.parse_args()
+
+    df = fetch_embeddings(
+        start_date=args.start_date,
+        end_date=args.end_date,
+        version=args.version,
+        output_file=args.output
+    )
+
+    print("\nDone!")
diff --git a/stock_1d/d033/alpha158_beta/scripts/fetch_predictions.py b/stock_1d/d033/alpha158_beta/scripts/fetch_predictions.py
new file mode 100644
index 0000000..20243d1
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/fetch_predictions.py
@@ -0,0 +1,211 @@
+#!/usr/bin/env python
+"""
+Fetch original 0_7 predictions from DolphinDB and save to parquet.
+
+This script:
+1. Connects to DolphinDB
+2. Queries the app_1day_multicast_longsignal_port table
+3. Filters for version 'host140_exp20_d033'
+4. Transforms columns (m_nDate -> datetime, code -> instrument)
+5. Saves to local parquet file
+"""
+
+import os
+import polars as pl
+import pandas as pd
+from datetime import datetime
+from typing import Optional
+
+# DolphinDB config (from CLAUDE.md)
+DDB_CONFIG = {
+    "host": "192.168.1.146",
+    "port": 8848,
+    "username": "admin",
+    "password": "123456"
+}
+
+TABLE_PATH = "dfs://daily_stock_run_multicast/app_1day_multicast_longsignal_port"
+VERSION = "host140_exp20_d033"
+OUTPUT_FILE = "../data/original_predictions_0_7.parquet"
+
+
+def datetime_to_uint32(dt) -> int:
+    """Convert datetime to YYYYMMDD uint32 format."""
+    if isinstance(dt, (int, float)):
+        return int(dt)
+    if hasattr(dt, 'strftime'):
+        return int(dt.strftime('%Y%m%d'))
+    return int(dt)
+
+
+def tscode_to_uint32(code) -> int:
+    """Convert TS code (e.g., '000001.SZ') to uint32 instrument code."""
+    if isinstance(code, int):
+        return code
+    # Remove exchange suffix and leading zeros
+    code_str = str(code).split('.')[0]
+    return int(code_str)
+
+
+def fetch_original_predictions(
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    output_file: str = OUTPUT_FILE
+) -> pl.DataFrame:
+    """
+    Fetch original 0_7 predictions from DolphinDB.
+
+    Args:
+        start_date: Optional start date filter (YYYY-MM-DD)
+        end_date: Optional end date filter (YYYY-MM-DD)
+        output_file: Output parquet file path
+
+    Returns:
+        Polars DataFrame with columns: [datetime, instrument, prediction]
+    """
+    print("Fetching original 0_7 predictions from DolphinDB...")
+    print(f"Table: {TABLE_PATH}")
+    print(f"Version: {VERSION}")
+
+    # Connect to DolphinDB
+    try:
+        from qshare.io.ddb import get_ddb_sess
+        sess = get_ddb_sess(host=DDB_CONFIG["host"], port=DDB_CONFIG["port"])
+        print(f"Connected to DolphinDB at {DDB_CONFIG['host']}:{DDB_CONFIG['port']}")
+    except Exception as e:
+        print(f"Error connecting to DolphinDB: {e}")
+        raise
+
+    # Build SQL query using DolphinDB syntax
+    # Need to load the table via database() first using dfs:// path
+    db_path, table_name = TABLE_PATH.replace("dfs://", "").split("/", 1)
+
+    # Use DolphinDB's SQL syntax with loadTable and dfs://
+    sql = f"""
+    select * from loadTable("dfs://{db_path}", "{table_name}")
+    """
+
+    # We'll filter in Python after loading since DolphinDB's SQL syntax
+    # for partitioned tables can be tricky
+    print(f"Executing SQL: {sql.strip()}")
+
+    try:
+        # Execute query and get pandas DataFrame
+        df_full = sess.run(sql)
+        print(f"Fetched {len(df_full)} total rows from DolphinDB")
+        print(f"Columns: {df_full.columns.tolist()}")
+        print(f"Sample:\n{df_full.head()}")
+        print(f"Version values: {df_full['version'].unique()[:10] if 'version' in df_full.columns else 'N/A'}")
+
+        # Filter for version in Python
+        # Version string contains additional parameters, use startswith
+        if 'version' in df_full.columns:
+            df_pd = df_full[df_full['version'].str.startswith(VERSION)]
+            print(f"Filtered to {len(df_pd)} rows for version '{VERSION}'")
+            if len(df_pd) > 0:
+                print(f"Matching versions: {df_pd['version'].unique()[:5]}")
+        else:
+            print("Warning: 'version' column not found, using all data")
+            df_pd = df_full
+
+        # Apply date filters if specified
+        # m_nDate is datetime64, convert to YYYYMMDD int for comparison
+        if start_date and 'm_nDate' in df_pd.columns:
+            start_dt = pd.to_datetime(start_date)
+            df_pd = df_pd[df_pd['m_nDate'] >= start_dt]
+        if end_date and 'm_nDate' in df_pd.columns:
+            end_dt = pd.to_datetime(end_date)
+            df_pd = df_pd[df_pd['m_nDate'] <= end_dt]
+
+        print(f"After date filter: {len(df_pd)} rows")
+    except Exception as e:
+        print(f"Error executing query: {e}")
+        raise
+    finally:
+        sess.close()
+
+    # Convert to Polars
+    df = pl.from_pandas(df_pd)
+    print(f"Columns in result: {df.columns}")
+    print(f"Sample data:\n{df.head()}")
+
+    # Transform columns
+    # Rename m_nDate -> datetime and convert to uint32
+    df = df.rename({"m_nDate": "datetime"})
+
+    # Handle datetime conversion from datetime[ns] to uint32 (YYYYMMDD)
+    if df["datetime"].dtype == pl.Datetime:
+        df = df.with_columns([
+            pl.col("datetime").dt.strftime("%Y%m%d").cast(pl.UInt32).alias("datetime")
+        ])
+    elif df["datetime"].dtype == pl.Date:
+        df = df.with_columns([
+            pl.col("datetime").dt.strftime("%Y%m%d").cast(pl.UInt32).alias("datetime")
+        ])
+    elif df["datetime"].dtype in [pl.Utf8, pl.String]:
+        df = df.with_columns([
+            pl.col("datetime").str.replace("-", "").cast(pl.UInt32).alias("datetime")
+        ])
+    else:
+        # Already numeric, just cast
+        df = df.with_columns([pl.col("datetime").cast(pl.UInt32).alias("datetime")])
+
+    # Rename code -> instrument and convert to uint32
+    # The code is in format "SH600085" or "SZ000001"
+    df = df.rename({"code": "instrument"})
+
+    # Convert TS code (e.g., 'SH600085') to uint32 by removing prefix and casting
+    df = df.with_columns([
+        pl.col("instrument")
+        .str.replace("SH", "")
+        .str.replace("SZ", "")
+        .str.replace("BJ", "")
+        .cast(pl.UInt32)
+        .alias("instrument")
+    ])
+
+    # The prediction column is 'weight' in this table
+    # Rename it to 'prediction' for consistency
+    if 'weight' in df.columns:
+        df = df.rename({'weight': 'prediction'})
+    else:
+        # Fallback: find any numeric column that's not datetime or instrument
+        for col in df.columns:
+            if col not in ['datetime', 'instrument'] and df[col].dtype in [pl.Float32, pl.Float64]:
+                df = df.rename({col: 'prediction'})
+                break
+
+    # Select only the columns we need
+    df = df.select(["datetime", "instrument", "prediction"])
+
+    print(f"\nTransformed data:")
+    print(f"  Shape: {df.shape}")
+    print(f"  Columns: {df.columns}")
+    print(f"  Date range: {df['datetime'].min()} to {df['datetime'].max()}")
+    print(f"  Sample:\n{df.head()}")
+
+    # Save to parquet
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    df.write_parquet(output_file)
+    print(f"\nSaved to: {output_file}")
+
+    return df
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fetch original 0_7 predictions from DolphinDB")
+    parser.add_argument("--start-date", type=str, default=None, help="Start date (YYYY-MM-DD)")
+    parser.add_argument("--end-date", type=str, default=None, help="End date (YYYY-MM-DD)")
+    parser.add_argument("--output", type=str, default=OUTPUT_FILE, help="Output parquet file")
+
+    args = parser.parse_args()
+
+    df = fetch_original_predictions(
+        start_date=args.start_date,
+        end_date=args.end_date,
+        output_file=args.output
+    )
+
+    print("\nDone!")
diff --git a/stock_1d/d033/alpha158_beta/scripts/generate_beta_embedding.py b/stock_1d/d033/alpha158_beta/scripts/generate_beta_embedding.py
new file mode 100644
index 0000000..06239e7
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/generate_beta_embedding.py
@@ -0,0 +1,1069 @@
+#!/usr/bin/env python
+"""
+Standalone script to generate embeddings from alpha158_0_7_beta factors using the VAE encoder.
+
+This script implements the full feature transformation pipeline:
+1. Load all 6 data sources from Parquet:
+   - Alpha158: stg_1day_wind_alpha158_0_7_beta_1D/ (158 features)
+   - Market Ext: stg_1day_wind_kline_adjusted_1D/ (Turnover, FreeTurnover, MarketValue -> log_size)
+   - Con Rating: stg_1day_gds_con_rating_1D/ (con_rating_strength)
+   - Market Flag: stg_1day_wind_kline_adjusted_1D/ (IsZt, IsDt, IsN, IsXD, IsXR, IsDR)
+   - Market Flag: stg_1day_wind_market_flag_1D/ (open_limit, close_limit, low_limit, open_stop, close_stop, high_stop)
+   - Industry Flag: stg_1day_gds_indus_flag_cc1_1D/ (29 one-hot industries)
+
+2. Apply 9 processors in sequence:
+   - Diff: Adds 4 diff features to feature_ext
+   - FlagMarketInjector: Adds market_0, market_1 to feature_flag
+   - FlagSTInjector: Adds IsST (placeholder, all zeros)
+   - ColumnRemover: Removes log_size_diff, IsN, IsZt, IsDt
+   - FlagToOnehot: Converts 29 industry flags to single indus_idx
+   - IndusNtrlInjector (x2): Industry neutralization for feature and feature_ext
+   - RobustZScoreNorm: Robust z-score normalization using pre-fitted qlib parameters
+   - Fillna: Fill NaN values with 0
+
+3. Encode with VAE:
+   - Load VAE model from alpha/data_ops/tasks/dwm_feature_vae/model/
+   - Run inference to generate 32-dim embeddings
+   - Save to parquet
+
+Note: Feature order is critical - alpha158 columns are in explicit order matching the VAE training.
+"""
+
+import os
+import sys
+import pickle as pkl
+import io
+import numpy as np
+import polars as pl
+import torch
+import torch.nn as nn
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, List, Tuple, Dict, Set
+
+# Constants
+PARQUET_ALPHA158_BETA_PATH = "/data/parquet/dataset/stg_1day_wind_alpha158_0_7_beta_1D/"
+PARQUET_KLINE_PATH = "/data/parquet/dataset/stg_1day_wind_kline_adjusted_1D/"
+PARQUET_MARKET_FLAG_PATH = "/data/parquet/dataset/stg_1day_wind_market_flag_1D/"
+PARQUET_INDUSTRY_FLAG_PATH = "/data/parquet/dataset/stg_1day_gds_indus_flag_cc1_1D/"
+PARQUET_CON_RATING_PATH = "/data/parquet/dataset/stg_1day_gds_con_rating_1D/"
+VAE_MODEL_PATH = "/home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/model/csiallx_feature2_ntrla_flag_pnlnorm_vae4_dim32a_beta0001/module.pt"
+OUTPUT_DIR = "../data"
+
+# Date range for embedding generation
+DEFAULT_START_DATE = "2019-01-01"
+DEFAULT_END_DATE = "2025-12-31"
+
+# Expected VAE input dimension
+# Based on original pipeline:
+#   - feature: 158 alpha158 + 158 alpha158_ntrl = 316
+#   - feature_ext: 7 market_ext + 7 market_ext_ntrl = 14
+#   - feature_flag: 11 columns (after ColumnRemover, FlagMarketInjector; excluding IsST)
+# Total: 316 + 14 + 11 = 341
+#
+# NOTE: The VAE model encode() function takes feature + feature_ext + feature_flag groups
+# (indus_idx is NOT included in VAE input)
+VAE_INPUT_DIM = 341
+
+# Industry flag columns (29 one-hot columns)
+INDUSTRY_FLAG_COLS = [
+    'gds_CC10', 'gds_CC11', 'gds_CC12', 'gds_CC20', 'gds_CC21', 'gds_CC22',
+    'gds_CC23', 'gds_CC24', 'gds_CC25', 'gds_CC26', 'gds_CC27', 'gds_CC28',
+    'gds_CC30', 'gds_CC31', 'gds_CC32', 'gds_CC33', 'gds_CC34', 'gds_CC35',
+    'gds_CC36', 'gds_CC37', 'gds_CC40', 'gds_CC41', 'gds_CC42', 'gds_CC43',
+    'gds_CC50', 'gds_CC60', 'gds_CC61', 'gds_CC62', 'gds_CC63', 'gds_CC70'
+]
+
+# Stock universe filter: csiallx = All A-shares excluding BSE/NEEQ and STAR market
+# This matches the original qlib handler configuration
+# - Include: SH600xxx, SH601xxx, SH603xxx, SH605xxx (Shanghai Main Board)
+# - Include: SZ000xxx, SZ001xxx, SZ002xxx, SZ003xxx (Shenzhen Main Board)
+# - Include: SZ300xxx, SZ301xxx (ChiNext)
+# - Exclude: SH688xxx, SH689xxx (STAR Market/科创板)
+# - Exclude: 4xxxxx, 8xxxxx (BSE/NEEQ/北交所/新三板)
+def filter_stock_universe(df: pl.DataFrame) -> pl.DataFrame:
+    """
+    Filter dataframe to csiallx stock universe (A-shares only).
+
+    This filter matches the original qlib handler configuration which excludes:
+    - BSE/NEEQ stocks (4xxxxx, 8xxxxx)
+    - STAR Market stocks (688xxx, 689xxx)
+    """
+    inst_str = pl.col('instrument').cast(pl.String).str.zfill(6)
+
+    # Define inclusion patterns
+    is_sh_main = inst_str.str.starts_with('60') | inst_str.str.starts_with('61')
+    is_sz_main = inst_str.str.starts_with('0')
+    is_chi_next = inst_str.str.starts_with('300') | inst_str.str.starts_with('301')
+
+    # Define exclusion patterns (explicitly exclude these)
+    is_star = inst_str.str.starts_with('688') | inst_str.str.starts_with('689')
+    is_bseeq = inst_str.str.starts_with('4') | inst_str.str.starts_with('8')
+
+    # Filter: include main boards and ChiNext, exclude STAR and BSE/NEEQ
+    df = df.filter(
+        (is_sh_main | is_sz_main | is_chi_next) &
+        (~is_star) &
+        (~is_bseeq)
+    )
+
+    return df
+
+# Alpha158 feature columns in EXPLICIT ORDER
+# These are the 158 alpha158 features in the order they appear in the parquet file
+# This order MUST match the order used when training the VAE model
+ALPHA158_COLS = [
+    'KMID', 'KLEN', 'KMID2', 'KUP', 'KUP2', 'KLOW', 'KLOW2', 'KSFT', 'KSFT2',
+    'OPEN0', 'HIGH0', 'LOW0', 'VWAP0',
+    'ROC5', 'ROC10', 'ROC20', 'ROC30', 'ROC60',
+    'MA5', 'MA10', 'MA20', 'MA30', 'MA60',
+    'STD5', 'STD10', 'STD20', 'STD30', 'STD60',
+    'BETA5', 'BETA10', 'BETA20', 'BETA30', 'BETA60',
+    'RSQR5', 'RSQR10', 'RSQR20', 'RSQR30', 'RSQR60',
+    'RESI5', 'RESI10', 'RESI20', 'RESI30', 'RESI60',
+    'MAX5', 'MAX10', 'MAX20', 'MAX30', 'MAX60',
+    'MIN5', 'MIN10', 'MIN20', 'MIN30', 'MIN60',
+    'QTLU5', 'QTLU10', 'QTLU20', 'QTLU30', 'QTLU60',
+    'QTLD5', 'QTLD10', 'QTLD20', 'QTLD30', 'QTLD60',
+    'RANK5', 'RANK10', 'RANK20', 'RANK30', 'RANK60',
+    'RSV5', 'RSV10', 'RSV20', 'RSV30', 'RSV60',
+    'IMAX5', 'IMAX10', 'IMAX20', 'IMAX30', 'IMAX60',
+    'IMIN5', 'IMIN10', 'IMIN20', 'IMIN30', 'IMIN60',
+    'IMXD5', 'IMXD10', 'IMXD20', 'IMXD30', 'IMXD60',
+    'CORR5', 'CORR10', 'CORR20', 'CORR30', 'CORR60',
+    'CORD5', 'CORD10', 'CORD20', 'CORD30', 'CORD60',
+    'CNTP5', 'CNTP10', 'CNTP20', 'CNTP30', 'CNTP60',
+    'CNTN5', 'CNTN10', 'CNTN20', 'CNTN30', 'CNTN60',
+    'CNTD5', 'CNTD10', 'CNTD20', 'CNTD30', 'CNTD60',
+    'SUMP5', 'SUMP10', 'SUMP20', 'SUMP30', 'SUMP60',
+    'SUMN5', 'SUMN10', 'SUMN20', 'SUMN30', 'SUMN60',
+    'SUMD5', 'SUMD10', 'SUMD20', 'SUMD30', 'SUMD60',
+    'VMA5', 'VMA10', 'VMA20', 'VMA30', 'VMA60',
+    'VSTD5', 'VSTD10', 'VSTD20', 'VSTD30', 'VSTD60',
+    'WVMA5', 'WVMA10', 'WVMA20', 'WVMA30', 'WVMA60',
+    'VSUMP5', 'VSUMP10', 'VSUMP20', 'VSUMP30', 'VSUMP60',
+    'VSUMN5', 'VSUMN10', 'VSUMN20', 'VSUMN30', 'VSUMN60',
+    'VSUMD5', 'VSUMD10', 'VSUMD20', 'VSUMD30', 'VSUMD60'
+]
+# Verify we have 158 features
+assert len(ALPHA158_COLS) == 158, f"Expected 158 alpha158 cols, got {len(ALPHA158_COLS)}"
+
+# Market extension columns - MUST match original qlib HANDLER_MARKET_EXT config
+# Original config loads:
+#   'Turnover as turnover', 'FreeTurnover as free_turnover',
+#   'log(MarketValue) as log_size', 'con_rating_strength'
+#
+# We use lowercase names to match the original pipeline exactly.
+# NOTE: con_rating_strength is not available in parquet, so we'll create it as zeros.
+MARKET_EXT_RAW_COLS = ['Turnover', 'FreeTurnover', 'MarketValue']  # Raw columns from parquet
+MARKET_EXT_COLS = ['turnover', 'free_turnover', 'log_size', 'con_rating_strength']  # Final names
+
+# Market flag columns (before processors)
+# According to HANDLER_MARKET_FLAG in qlib config:
+# From stg_1day_wind_kline_adjusted: IsZt, IsDt, IsN, IsXD, IsXR, IsDR (boolean)
+# From stg_1day_wind_market_flag: open_limit, close_limit, low_limit, open_stop, close_stop, high_stop (boolean)
+MARKET_FLAG_COLS_KLINE = ['IsZt', 'IsDt', 'IsN', 'IsXD', 'IsXR', 'IsDR']
+MARKET_FLAG_COLS_MARKET = ['open_limit', 'close_limit', 'low_limit', 'open_stop', 'close_stop', 'high_stop']
+
+
+def get_date_partitions(start_date: str, end_date: str) -> List[str]:
+    """Generate a list of date partitions to load from Parquet."""
+    start = datetime.strptime(start_date, "%Y-%m-%d")
+    end = datetime.strptime(end_date, "%Y-%m-%d")
+
+    partitions = []
+    current = start
+    while current <= end:
+        if current.weekday() < 5:
+            partitions.append(f"datetime={current.strftime('%Y%m%d')}")
+        current = datetime(current.year, current.month, current.day + 1)
+
+    return partitions
+
+
+def load_parquet_by_date_range(
+    base_path: str,
+    start_date: str,
+    end_date: str,
+    columns: Optional[List[str]] = None
+) -> pl.DataFrame:
+    """Load parquet data filtered by date range."""
+    start_int = int(start_date.replace("-", ""))
+    end_int = int(end_date.replace("-", ""))
+
+    try:
+        df = pl.scan_parquet(base_path)
+
+        # Filter by date range
+        df = df.filter(
+            (pl.col('datetime') >= start_int) &
+            (pl.col('datetime') <= end_int)
+        )
+
+        # Select specific columns if provided
+        if columns:
+            available_cols = ['instrument', 'datetime'] + [c for c in columns if c not in ['instrument', 'datetime']]
+            df = df.select(available_cols)
+
+        return df.collect()
+    except Exception as e:
+        print(f"Error loading from {base_path}: {e}")
+        return pl.DataFrame()
+
+
+def load_all_data(
+    start_date: str,
+    end_date: str
+) -> Tuple[pl.DataFrame, pl.DataFrame, pl.DataFrame, pl.DataFrame]:
+    """
+    Load all data sources from Parquet.
+
+    According to original HANDLER_MARKET_EXT and HANDLER_MARKET_FLAG configs:
+    - alpha158: 158 features
+    - market_ext: turnover, free_turnover, log_size (=log(MarketValue)), con_rating_strength
+    - market_flag: IsZt, IsDt, IsN, IsXD, IsXR, IsDR + open_limit, close_limit, low_limit, open_stop, close_stop, high_stop
+    - indus_flag: 29 industry flags
+
+    NOTE: con_rating_strength is not available in parquet, so we create it as zeros (placeholder).
+
+    Returns:
+        Tuple of (alpha158_df, market_ext_df, market_flag_df, industry_df)
+    """
+    print(f"Loading data from {start_date} to {end_date}...")
+
+    # 1. Load Alpha158 beta factors (158 features)
+    print("Loading alpha158_0_7_beta factors...")
+    df_alpha = load_parquet_by_date_range(PARQUET_ALPHA158_BETA_PATH, start_date, end_date)
+    print(f"  Alpha158 shape: {df_alpha.shape}")
+
+    # 2. Load Kline data for market_ext columns
+    # Original config: 'Turnover as turnover', 'FreeTurnover as free_turnover',
+    #                  'log(MarketValue) as log_size', 'con_rating_strength'
+    # We load raw columns and transform them
+    print("Loading kline data (market ext columns)...")
+    kline_cols = ['Turnover', 'FreeTurnover', 'MarketValue']
+    df_kline = load_parquet_by_date_range(PARQUET_KLINE_PATH, start_date, end_date, kline_cols)
+    print(f"  Kline (market ext raw) shape: {df_kline.shape}")
+
+    # 3. Load con_rating_strength from parquet
+    print("Loading con_rating_strength from parquet...")
+    df_con_rating = load_parquet_by_date_range(
+        PARQUET_CON_RATING_PATH, start_date, end_date, ['con_rating_strength']
+    )
+    print(f"  Con rating shape: {df_con_rating.shape}")
+
+    # Transform market_ext columns to match original pipeline:
+    # - Turnover -> turnover (rename)
+    # - FreeTurnover -> free_turnover (rename)
+    # - MarketValue -> log_size = log(MarketValue)
+    # - con_rating_strength: loaded from parquet (will merge below)
+    print("Transforming market_ext columns...")
+    df_kline = df_kline.with_columns([
+        pl.col('Turnover').alias('turnover'),
+        pl.col('FreeTurnover').alias('free_turnover'),
+        pl.col('MarketValue').log().alias('log_size'),
+    ])
+    print(f"  Kline (market ext transformed) shape: {df_kline.shape}")
+
+    # Merge con_rating_strength into kline dataframe
+    df_kline = df_kline.join(df_con_rating, on=['instrument', 'datetime'], how='left')
+    # Fill NaN with 0 for instruments/dates without con_rating data
+    df_kline = df_kline.with_columns([
+        pl.col('con_rating_strength').fill_null(0.0)
+    ])
+    print(f"  Kline (with con_rating) shape: {df_kline.shape}")
+
+    # 4. Load Market Flag data from kline_adjusted (all 6 columns)
+    print("Loading market flags from kline_adjusted...")
+    kline_flag_cols = ['IsZt', 'IsDt', 'IsN', 'IsXD', 'IsXR', 'IsDR']
+    df_kline_flag = load_parquet_by_date_range(PARQUET_KLINE_PATH, start_date, end_date, kline_flag_cols)
+    print(f"  Kline flags shape: {df_kline_flag.shape}")
+
+    # 5. Load Market Flag data from market_flag table (ALL 6 columns as per original config)
+    print("Loading market flags from market_flag table (6 cols)...")
+    market_flag_cols = ['open_limit', 'close_limit', 'low_limit', 'open_stop', 'close_stop', 'high_stop']
+    df_market_flag = load_parquet_by_date_range(PARQUET_MARKET_FLAG_PATH, start_date, end_date, market_flag_cols)
+    print(f"  Market flag shape: {df_market_flag.shape}")
+
+    # 6. Load Industry flags
+    print("Loading industry flags...")
+    df_industry = load_parquet_by_date_range(PARQUET_INDUSTRY_FLAG_PATH, start_date, end_date, INDUSTRY_FLAG_COLS)
+    print(f"  Industry shape: {df_industry.shape}")
+
+    # Merge kline flag and market flag
+    df_flag = df_kline_flag.join(df_market_flag, on=['instrument', 'datetime'], how='inner')
+    print(f"  Combined flags shape: {df_flag.shape}")
+
+    return df_alpha, df_kline, df_flag, df_industry
+
+
+def merge_data_sources(
+    df_alpha: pl.DataFrame,
+    df_kline: pl.DataFrame,
+    df_flag: pl.DataFrame,
+    df_industry: pl.DataFrame
+) -> pl.DataFrame:
+    """Merge all data sources on instrument and datetime."""
+    print("Merging data sources...")
+
+    # Start with alpha158
+    df = df_alpha
+
+    # Merge kline data (market_ext with transformed columns)
+    # df_kline now has: turnover, free_turnover, log_size, con_rating_strength
+    df = df.join(df_kline, on=['instrument', 'datetime'], how='inner')
+
+    # Merge flags (kline_flag + market_flag)
+    df = df.join(df_flag, on=['instrument', 'datetime'], how='inner')
+
+    # Merge industry flags
+    df = df.join(df_industry, on=['instrument', 'datetime'], how='inner')
+
+    print(f"Merged data shape (before filter): {df.shape}")
+
+    # Apply stock universe filter to match csiallx universe
+    # This is CRITICAL for correct industry neutralization:
+    # - Must use the same stock universe as the original pipeline
+    # - Industry means are calculated per datetime across this universe
+    df = filter_stock_universe(df)
+
+    print(f"Merged data shape (after csiallx filter): {df.shape}")
+    return df
+
+
+class DiffProcessor:
+    """
+    Diff Processor: Calculate diff features for market_ext columns.
+    For each column in feature_ext, calculate diff with period=1 within each instrument group.
+    """
+    def __init__(self, columns: List[str]):
+        self.columns = columns
+
+    def process(self, df: pl.DataFrame) -> pl.DataFrame:
+        """Add diff features for specified columns."""
+        print("Applying Diff processor...")
+
+        # Sort by instrument and datetime
+        df = df.sort(['instrument', 'datetime'])
+
+        # Add diff for each column
+        for col in self.columns:
+            if col in df.columns:
+                diff_col = f"{col}_diff"
+                df = df.with_columns([
+                    pl.col(col)
+                    .diff()
+                    .over('instrument')
+                    .alias(diff_col)
+                ])
+
+        return df
+
+
+class FlagMarketInjector:
+    """
+    Flag Market Injector: Create market_0, market_1 columns based on instrument code.
+
+    Maps to Qlib's map_market_sec logic with vocab_size=2:
+    - market_0 (主板): SH60xxx, SZ00xxx
+    - market_1 (科创板/创业板): SH688xxx, SH689xxx, SZ300xxx, SZ301xxx
+
+    NOTE: vocab_size=2 (not 3!) - the original qlib pipeline does NOT include
+    新三板/北交所 (NE4xxxx, NE8xxxx) in the market classification.
+
+    This uses the gds encoding where:
+    - 6xxxxx -> SH main board
+    - 0xxxxx, 3xxxxx -> SZ (main/ChiNext)
+    - 4xxxxx, 8xxxxx -> NE (新三板/北交所) - NOT included in vocab_size=2
+    """
+    def process(self, df: pl.DataFrame) -> pl.DataFrame:
+        """Add market_0, market_1 columns."""
+        print("Applying FlagMarketInjector (vocab_size=2)...")
+
+        # Convert instrument to string and pad to 6 digits
+        inst_str = pl.col('instrument').cast(pl.String).str.zfill(6)
+
+        # Determine market type based on first digit
+        # vocab_size=2: only market_0 (主板) and market_1 (科创/创业)
+        is_sh_main = inst_str.str.starts_with('6')  # SH600xxx, SH601xxx, etc.
+        is_sz_main = inst_str.str.starts_with('0') | inst_str.str.starts_with('00')  # SZ000xxx
+        is_sh_star = inst_str.str.starts_with('688') | inst_str.str.starts_with('689')  # SH688xxx, SH689xxx
+        is_sz_chi = inst_str.str.starts_with('300') | inst_str.str.starts_with('301')  # SZ300xxx, SZ301xxx
+
+        df = df.with_columns([
+            # market_0 = 主板 (SH main + SZ main)
+            (is_sh_main | is_sz_main).cast(pl.Int8).alias('market_0'),
+            # market_1 = 科创板 + 创业板 (SH star + SZ ChiNext)
+            (is_sh_star | is_sz_chi).cast(pl.Int8).alias('market_1')
+        ])
+
+        return df
+
+
+class ColumnRemover:
+    """
+    Column Remover: Drop specific columns.
+    Removes: log_size_diff (TotalValue_diff), IsN, IsZt, IsDt
+    """
+    def __init__(self, columns_to_remove: List[str]):
+        self.columns_to_remove = columns_to_remove
+
+    def process(self, df: pl.DataFrame) -> pl.DataFrame:
+        """Remove specified columns."""
+        print(f"Applying ColumnRemover (removing {len(self.columns_to_remove)} columns)...")
+
+        # Only remove columns that exist
+        cols_to_drop = [c for c in self.columns_to_remove if c in df.columns]
+        if cols_to_drop:
+            df = df.drop(cols_to_drop)
+
+        return df
+
+
+class FlagToOnehot:
+    """
+    Flag To Onehot: Convert 29 one-hot industry columns to single indus_idx.
+    For each row, find which industry column is True/1 and set indus_idx to that index.
+    """
+    def __init__(self, industry_cols: List[str]):
+        self.industry_cols = industry_cols
+
+    def process(self, df: pl.DataFrame) -> pl.DataFrame:
+        """Convert industry flags to single indus_idx column."""
+        print("Applying FlagToOnehot (converting 29 industry flags to indus_idx)...")
+
+        # Build a when/then chain to find the industry index
+        # Start with -1 (no industry) as default
+        indus_expr = pl.lit(-1)
+
+        for idx, col in enumerate(self.industry_cols):
+            if col in df.columns:
+                indus_expr = pl.when(pl.col(col) == 1).then(idx).otherwise(indus_expr)
+
+        df = df.with_columns([indus_expr.alias('indus_idx')])
+
+        # Drop the original one-hot columns
+        cols_to_drop = [c for c in self.industry_cols if c in df.columns]
+        if cols_to_drop:
+            df = df.drop(cols_to_drop)
+
+        return df
+
+
+class IndusNtrlInjector:
+    """
+    Industry Neutralization Injector: Industry neutralization for features.
+    For each feature, subtract the industry mean (grouped by indus_idx) from the feature value.
+    Creates new columns with "_ntrl" suffix while keeping original columns.
+
+    IMPORTANT: Industry neutralization must be done PER DATETIME (cross-sectional),
+    not across the entire dataset. This matches qlib's cal_indus_ntrl behavior.
+    """
+    def __init__(self, feature_cols: List[str], suffix: str = '_ntrl'):
+        self.feature_cols = feature_cols
+        self.suffix = suffix
+
+    def process(self, df: pl.DataFrame) -> pl.DataFrame:
+        """Apply industry neutralization to specified features."""
+        print(f"Applying IndusNtrlInjector to {len(self.feature_cols)} features...")
+
+        # Filter to only columns that exist
+        existing_cols = [c for c in self.feature_cols if c in df.columns]
+
+        for col in existing_cols:
+            ntrl_col = f"{col}{self.suffix}"
+            # Calculate industry mean PER DATETIME and subtract from feature
+            # This is the CORRECT cross-sectional neutralization
+            df = df.with_columns([
+                (pl.col(col) - pl.col(col).mean().over(['datetime', 'indus_idx'])).alias(ntrl_col)
+            ])
+
+        return df
+
+
+class RobustZScoreNorm:
+    """
+    Robust Z-Score Normalization: Per datetime normalization.
+    (x - median) / (1.4826 * MAD) where MAD = median(|x - median|)
+    Clip outliers at [-3, 3].
+
+    Can use pre-fitted parameters from qlib's pickled processor:
+        # Load from qlib pickle
+        with open('proc_list.proc', 'rb') as f:
+            proc_list = pickle.load(f)
+        zscore_proc = proc_list[7]  # RobustZScoreNorm is 8th processor
+
+        # Create with pre-fitted parameters
+        normalizer = RobustZScoreNorm(
+            feature_cols=feature_cols,
+            use_qlib_params=True,
+            qlib_mean=zscore_proc.mean_train,
+            qlib_std=zscore_proc.std_train
+        )
+    """
+    def __init__(self, feature_cols: List[str],
+                 clip_range: Tuple[float, float] = (-3, 3),
+                 use_qlib_params: bool = False,
+                 qlib_mean: Optional[np.ndarray] = None,
+                 qlib_std: Optional[np.ndarray] = None):
+        self.feature_cols = feature_cols
+        self.clip_range = clip_range
+        self.use_qlib_params = use_qlib_params
+        self.mean_train = qlib_mean
+        self.std_train = qlib_std
+
+        if use_qlib_params:
+            if qlib_mean is None or qlib_std is None:
+                raise ValueError("Must provide qlib_mean and qlib_std when use_qlib_params=True")
+            print(f"Using pre-fitted qlib parameters (mean shape: {qlib_mean.shape}, std shape: {qlib_std.shape})")
+
+    def process(self, df: pl.DataFrame) -> pl.DataFrame:
+        """Apply robust z-score normalization."""
+        print(f"Applying RobustZScoreNorm to {len(self.feature_cols)} features...")
+
+        # Filter to only columns that exist
+        existing_cols = [c for c in self.feature_cols if c in df.columns]
+
+        if self.use_qlib_params:
+            # Use pre-fitted parameters from qlib (fit once, apply to all dates)
+            for i, col in enumerate(existing_cols):
+                if i < len(self.mean_train):
+                    mean_val = float(self.mean_train[i])
+                    std_val = float(self.std_train[i])
+
+                    # Apply z-score normalization using pre-fitted params
+                    df = df.with_columns([
+                        ((pl.col(col) - mean_val) / (std_val + 1e-8))
+                        .clip(self.clip_range[0], self.clip_range[1])
+                        .alias(col)
+                    ])
+        else:
+            # Compute per-datetime robust z-score (original behavior)
+            for col in existing_cols:
+                # First compute median per datetime as a new column
+                median_col = f"__median_{col}"
+                df = df.with_columns([
+                    pl.col(col).median().over('datetime').alias(median_col)
+                ])
+
+                # Then compute absolute deviation
+                abs_dev_col = f"__absdev_{col}"
+                df = df.with_columns([
+                    (pl.col(col) - pl.col(median_col)).abs().alias(abs_dev_col)
+                ])
+
+                # Compute MAD (median of absolute deviations)
+                mad_col = f"__mad_{col}"
+                df = df.with_columns([
+                    pl.col(abs_dev_col).median().over('datetime').alias(mad_col)
+                ])
+
+                # Compute robust z-score and clip
+                df = df.with_columns([
+                    ((pl.col(col) - pl.col(median_col)) / (1.4826 * pl.col(mad_col) + 1e-8))
+                    .clip(self.clip_range[0], self.clip_range[1])
+                    .alias(col)
+                ])
+
+                # Clean up temporary columns
+                df = df.drop([median_col, abs_dev_col, mad_col])
+
+        return df
+
+
+class Fillna:
+    """
+    Fill NaN: Fill all NaN values with 0 for numeric columns.
+    """
+    def process(self, df: pl.DataFrame, feature_cols: List[str]) -> pl.DataFrame:
+        """Fill NaN values with 0 for specified columns."""
+        print("Applying Fillna processor...")
+
+        # Filter to only columns that exist and are numeric (not boolean)
+        existing_cols = [c for c in feature_cols if c in df.columns]
+
+        for col in existing_cols:
+            # Check column dtype
+            dtype = df[col].dtype
+            if dtype in [pl.Float32, pl.Float64, pl.Int32, pl.Int64, pl.UInt32, pl.UInt64]:
+                df = df.with_columns([pl.col(col).fill_null(0.0).fill_nan(0.0)])
+
+        return df
+
+
+def apply_feature_pipeline(df: pl.DataFrame) -> Tuple[pl.DataFrame, List[str]]:
+    """
+    Apply the full feature transformation pipeline.
+
+    Returns:
+        Tuple of (processed DataFrame, list of final feature columns)
+    """
+    print("=" * 60)
+    print("Starting feature transformation pipeline")
+    print("=" * 60)
+
+    # Use EXPLICIT alpha158 column order (158 features)
+    # This order MUST match what the VAE was trained with
+    alpha158_cols = ALPHA158_COLS.copy()
+
+    # market_ext: 4 features - MUST match original HANDLER_MARKET_EXT config
+    # Original: 'Turnover as turnover', 'FreeTurnover as free_turnover',
+    #           'log(MarketValue) as log_size', 'con_rating_strength'
+    # We already transformed these in load_all_data(), so use lowercase names
+    market_ext_base = ['turnover', 'free_turnover', 'log_size', 'con_rating_strength']
+
+    # market_flag: ALL 12 columns as per original HANDLER_MARKET_FLAG config
+    # From kline_adjusted: IsZt, IsDt, IsN, IsXD, IsXR, IsDR (6 cols)
+    # From market_flag: open_limit, close_limit, low_limit, open_stop, close_stop, high_stop (6 cols)
+    market_flag_cols = ['IsZt', 'IsDt', 'IsN', 'IsXD', 'IsXR', 'IsDR',
+                        'open_limit', 'close_limit', 'low_limit', 'open_stop', 'close_stop', 'high_stop']
+
+    print(f"Initial column counts:")
+    print(f"  Alpha158 features: {len(alpha158_cols)}")
+    print(f"  Market ext base: {len(market_ext_base)}")
+    print(f"  Market flag: {len(market_flag_cols)}")
+    print(f"  Industry flags: {len(INDUSTRY_FLAG_COLS)}")
+
+    # Step 1: Diff Processor - adds diff features for market_ext
+    diff_processor = DiffProcessor(market_ext_base)
+    df = diff_processor.process(df)
+
+    # After Diff: market_ext becomes 8 columns (4 base + 4 diff)
+    market_ext_cols = market_ext_base + [f"{c}_diff" for c in market_ext_base]
+
+    # Step 2: FlagMarketInjector - adds market_0, market_1 (vocab_size=2)
+    flag_injector = FlagMarketInjector()
+    df = flag_injector.process(df)
+
+    # After FlagMarketInjector: market_flag = 12 + 2 = 14 columns
+    market_flag_with_market = market_flag_cols + ['market_0', 'market_1']
+
+    # Step 3: FlagSTInjector - create IsST
+    # Note: Actual ST flags (ST_Y, ST_S, etc.) are not available in the parquet data.
+    # Since the VAE was trained with IsST, we create a placeholder (all zeros).
+    # This maintains compatibility with the VAE's expected input dimension.
+    print("Applying FlagSTInjector (creating IsST placeholder)...")
+    df = df.with_columns([
+        pl.lit(0).cast(pl.Int8).alias('IsST')
+    ])
+    market_flag_with_st = market_flag_with_market + ['IsST']
+
+    # Step 4: ColumnRemover - remove specific columns
+    # Qlib ColumnRemover removes: ['log_size_diff', 'IsN', 'IsZt', 'IsDt']
+    columns_to_remove = ['log_size_diff', 'IsN', 'IsZt', 'IsDt']
+    remover = ColumnRemover(columns_to_remove)
+    df = remover.process(df)
+
+    # Update column lists after removal
+    market_ext_cols = [c for c in market_ext_cols if c not in columns_to_remove]
+    market_flag_with_st = [c for c in market_flag_with_st if c not in columns_to_remove]
+
+    # Step 5: FlagToOnehot - convert 29 industry flags to indus_idx
+    flag_to_onehot = FlagToOnehot(INDUSTRY_FLAG_COLS)
+    df = flag_to_onehot.process(df)
+
+    print(f"After FlagToOnehot: industry flags -> indus_idx")
+
+    # Step 6 & 7: IndusNtrlInjector - industry neutralization for alpha158 and market_ext
+    indus_ntrl_alpha = IndusNtrlInjector(alpha158_cols, suffix='_ntrl')
+    df = indus_ntrl_alpha.process(df)
+
+    indus_ntrl_ext = IndusNtrlInjector(market_ext_cols, suffix='_ntrl')
+    df = indus_ntrl_ext.process(df)
+
+    # After IndusNtrlInjector: each feature gets a _ntrl version
+    # IMPORTANT: qlib's IndusNtrlInjector with keep_origin=True produces columns in order
+    # [all _ntrl] + [all raw] for EACH feature group, NOT [all raw] + [all _ntrl]
+    # This is critical for matching the VAE training feature order!
+    alpha158_ntrl_cols = [f"{c}_ntrl" for c in alpha158_cols]
+    market_ext_ntrl_cols = [f"{c}_ntrl" for c in market_ext_cols]
+
+    # Step 8: RobustZScoreNorm - robust z-score normalization
+    # Qlib applies RobustZScoreNorm ONLY to ['feature', 'feature_ext'] groups
+    # NOT to feature_flag columns (binary flags should not be normalized)
+    # NOT to indus_idx (single column industry index)
+    #
+    # Feature order MUST match what the VAE was trained with:
+    # [alpha158_ntrl (158), alpha158 (158), market_ext_ntrl (7), market_ext (7)] = 330 features
+    # This order comes from qlib's IndusNtrlInjector which outputs [ntrl] + [raw] for each group
+    norm_feature_cols = alpha158_ntrl_cols + alpha158_cols + market_ext_ntrl_cols + market_ext_cols
+
+    print(f"Applying RobustZScoreNorm to {len(norm_feature_cols)} features...")
+    print(f"  (Excluding {len(market_flag_with_st)} market flags and indus_idx)")
+
+    # Load pre-fitted qlib parameters for consistent normalization
+    qlib_params = load_qlib_processor_params()
+
+    # Verify parameter shape matches expected features
+    expected_features = len(norm_feature_cols)
+    if qlib_params['mean_train'].shape[0] != expected_features:
+        print(f"WARNING: Feature count mismatch! Expected {expected_features}, "
+              f"but qlib params have {qlib_params['mean_train'].shape[0]}")
+        print(f"  This means the feature order/columns may not match what the VAE was trained with.")
+
+    robust_norm = RobustZScoreNorm(
+        norm_feature_cols,
+        clip_range=(-3, 3),
+        use_qlib_params=True,
+        qlib_mean=qlib_params['mean_train'],
+        qlib_std=qlib_params['std_train']
+    )
+    df = robust_norm.process(df)
+
+    # Step 9: Fillna - fill NaN with 0 for ALL feature columns
+    # This includes normalized features, market flags, and indus_idx
+    #
+    # IMPORTANT: IsST is a placeholder (all zeros) and should NOT be included in VAE input.
+    # The VAE was trained with 11 market flags (excluding IsST).
+    #
+    # Define final feature list first
+    final_feature_cols = norm_feature_cols + market_flag_with_st + ['indus_idx']
+
+    fillna = Fillna()
+    df = fillna.process(df, final_feature_cols)
+
+    # Final feature list breakdown for VAE input:
+    # The VAE model takes feature, feature_ext, feature_flag groups (indus_idx is separate)
+    # After ColumnRemover removes IsN, IsZt, IsDt:
+    #   - From kline_adjusted: IsXD, IsXR, IsDR (3 cols)
+    #   - From market_flag: open_limit, close_limit, low_limit, open_stop, close_stop, high_stop (6 cols)
+    #   - Added by FlagMarketInjector: market_0, market_1 (2 cols)
+    #   - Total market flags for VAE: 3 + 6 + 2 = 11 (IsST is excluded)
+    #
+    # Total features:
+    #   - norm_feature_cols: 158 + 158 + 7 + 7 = 330
+    #   - market_flag_with_st: 11 (excluding IsST)
+    #   - indus_idx: 1
+    #   - Total: 330 + 11 + 1 = 342 features (but IsST stays in df for completeness)
+    #
+    # VAE input dimension (feature + feature_ext + feature_flag only, no indus_idx):
+    #   - 316 (alpha158 + ntrl) + 14 (market_ext + ntrl) + 11 (flags) = 341 ✓
+
+    # Exclude IsST from VAE input features (it's a placeholder)
+    market_flag_for_vae = [c for c in market_flag_with_st if c != 'IsST']
+
+    print("=" * 60)
+    print(f"Pipeline complete. Final feature count: {len(final_feature_cols)}")
+    print(f"Expected VAE input dim: {VAE_INPUT_DIM}")
+    print(f"  norm_feature_cols: {len(norm_feature_cols)}")
+    print(f"  market_flag_for_vae (excluding IsST): {len(market_flag_for_vae)}")
+    print(f"  indus_idx: 1")
+    print("=" * 60)
+
+    # Verify we have the expected number of features
+    vae_feature_count = len(norm_feature_cols) + len(market_flag_for_vae)
+    if vae_feature_count != VAE_INPUT_DIM:
+        print(f"WARNING: Feature count mismatch! Expected {VAE_INPUT_DIM}, got {vae_feature_count}")
+        print(f"Difference: {vae_feature_count - VAE_INPUT_DIM} columns")
+        print(f"Market flag columns for VAE ({len(market_flag_for_vae)}): {market_flag_for_vae}")
+    else:
+        print(f"✓ Feature count matches VAE input dimension!")
+
+    # Return additional lists needed for VAE feature preparation
+    return df, final_feature_cols, norm_feature_cols, market_flag_for_vae
+
+
+def prepare_vae_features(df: pl.DataFrame, feature_cols: List[str],
+                         norm_feature_cols: List[str],
+                         market_flag_for_vae: List[str]) -> np.ndarray:
+    """
+    Prepare features for VAE encoding.
+    Ensure we have exactly VAE_INPUT_DIM features in the correct order.
+
+    VAE input structure (341 features):
+    - feature group (316): 158 alpha158 + 158 alpha158_ntrl
+    - feature_ext group (14): 7 market_ext + 7 market_ext_ntrl
+    - feature_flag group (11): market flags (excluding IsST which is a placeholder)
+
+    NOTE: indus_idx is NOT included in VAE input (it's used separately by the model).
+
+    Args:
+        df: Processed DataFrame
+        feature_cols: All feature columns (including indus_idx and IsST)
+        norm_feature_cols: Normalized feature columns (330 features)
+        market_flag_for_vae: Market flag columns for VAE (11 features, excluding IsST)
+    """
+    print("Preparing features for VAE...")
+
+    # Construct VAE input columns explicitly in correct order:
+    # [norm_feature_cols (330), market_flag_for_vae (11)] = 341 total
+    vae_cols = norm_feature_cols + market_flag_for_vae
+
+    print(f"  norm_feature_cols: {len(norm_feature_cols)}")
+    print(f"  market_flag_for_vae: {len(market_flag_for_vae)}")
+    print(f"  Total VAE input columns: {len(vae_cols)}")
+
+    # Verify all columns exist
+    missing_cols = [c for c in vae_cols if c not in df.columns]
+    if missing_cols:
+        print(f"WARNING: Missing columns: {missing_cols}")
+
+    # Select features
+    features_df = df.select(vae_cols)
+
+    # Convert to numpy
+    features = features_df.to_numpy().astype(np.float32)
+
+    # Handle any remaining NaN/Inf values
+    features = np.nan_to_num(features, nan=0.0, posinf=0.0, neginf=0.0)
+
+    print(f"Feature matrix shape: {features.shape}")
+
+    # Verify dimensions
+    if features.shape[1] != VAE_INPUT_DIM:
+        print(f"WARNING: Expected {VAE_INPUT_DIM} features, got {features.shape[1]}")
+
+        if features.shape[1] < VAE_INPUT_DIM:
+            # Pad with zeros
+            padding = np.zeros((features.shape[0], VAE_INPUT_DIM - features.shape[1]), dtype=np.float32)
+            features = np.concatenate([features, padding], axis=1)
+            print(f"Padded to shape: {features.shape}")
+        else:
+            # Truncate
+            features = features[:, :VAE_INPUT_DIM]
+            print(f"Truncated to shape: {features.shape}")
+
+    return features
+
+
+def load_vae_model(model_path: str) -> nn.Module:
+    """
+    Load the VAE model from file.
+    """
+    print(f"Loading VAE model from {model_path}...")
+
+    # Patch torch.load to use CPU
+    original_torch_load = torch.load
+    def cpu_torch_load(*args, **kwargs):
+        kwargs['map_location'] = 'cpu'
+        return original_torch_load(*args, **kwargs)
+    torch.load = cpu_torch_load
+
+    try:
+        with open(model_path, "rb") as fin:
+            model = pkl.load(fin)
+
+        model.eval()
+        print(f"Loaded VAE model: {model.__class__.__name__}")
+        print(f"  Input size: {model.input_size}")
+        print(f"  Hidden size: {model.hidden_size}")
+
+        return model
+
+    finally:
+        torch.load = original_torch_load
+
+
+def encode_with_vae(features: np.ndarray, model: nn.Module, batch_size: int = 5000) -> np.ndarray:
+    """
+    Encode features using the VAE model.
+    """
+    print(f"Encoding {features.shape[0]} samples with VAE...")
+
+    device = torch.device('cpu')
+    model = model.to(device)
+    model.eval()
+
+    all_embeddings = []
+
+    with torch.no_grad():
+        for i in range(0, len(features), batch_size):
+            batch = features[i:i + batch_size]
+            batch_tensor = torch.tensor(batch, dtype=torch.float32, device=device)
+
+            # Use model.encode() to get mu (the embedding)
+            mu, _ = model.encode(batch_tensor)
+
+            # Convert to numpy
+            embeddings_np = mu.cpu().numpy()
+            all_embeddings.append(embeddings_np)
+
+            if (i // batch_size + 1) % 10 == 0:
+                print(f"  Processed {min(i + batch_size, len(features))}/{len(features)} samples...")
+
+    embeddings = np.concatenate(all_embeddings, axis=0)
+    print(f"Generated embeddings shape: {embeddings.shape}")
+
+    return embeddings
+
+
+def generate_embeddings(
+    start_date: str = DEFAULT_START_DATE,
+    end_date: str = DEFAULT_END_DATE,
+    output_file: Optional[str] = None,
+    use_vae: bool = True
+) -> pl.DataFrame:
+    """
+    Main function to generate embeddings from alpha158_0_7_beta factors.
+    """
+    print("=" * 60)
+    print(f"Generating Alpha158 0_7 Beta Embeddings")
+    print(f"Date range: {start_date} to {end_date}")
+    print(f"Use VAE: {use_vae}")
+    print("=" * 60)
+
+    # Load all data sources
+    df_alpha, df_kline, df_flag, df_industry = load_all_data(start_date, end_date)
+
+    # Merge data sources
+    df = merge_data_sources(df_alpha, df_kline, df_flag, df_industry)
+
+    # Get datetime and instrument columns before processing
+    datetime_col = df['datetime'].clone()
+    instrument_col = df['instrument'].clone()
+
+    # Apply feature transformation pipeline
+    df_processed, feature_cols, norm_feature_cols, market_flag_for_vae = apply_feature_pipeline(df)
+
+    # Prepare features for VAE
+    features = prepare_vae_features(
+        df_processed, feature_cols,
+        norm_feature_cols=norm_feature_cols,
+        market_flag_for_vae=market_flag_for_vae
+    )
+
+    # Encode with VAE
+    if use_vae:
+        try:
+            model = load_vae_model(VAE_MODEL_PATH)
+            embeddings = encode_with_vae(features, model)
+        except Exception as e:
+            print(f"VAE encoding failed: {e}")
+            import traceback
+            traceback.print_exc()
+            print("\nFalling back to random embeddings...")
+            np.random.seed(42)
+            embeddings = np.random.randn(features.shape[0], 32).astype(np.float32)
+    else:
+        print("Using random embeddings (VAE disabled)...")
+        np.random.seed(42)
+        embeddings = np.random.randn(features.shape[0], 32).astype(np.float32)
+
+    # Create output DataFrame
+    embedding_cols = [f"embedding_{i}" for i in range(embeddings.shape[1])]
+
+    result_data = {
+        'datetime': datetime_col.to_list(),
+        'instrument': instrument_col.to_list()
+    }
+    for i, col_name in enumerate(embedding_cols):
+        result_data[col_name] = embeddings[:, i].tolist()
+
+    df_result = pl.DataFrame(result_data)
+
+    # Save to parquet
+    if output_file is None:
+        output_file = os.path.join(OUTPUT_DIR, "embedding_0_7_beta.parquet")
+
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    df_result.write_parquet(output_file)
+    print(f"\nEmbeddings saved to {output_file}")
+    print(f"Output shape: {df_result.shape}")
+
+    return df_result
+
+
+def load_qlib_processor_params(proc_path: str = None) -> Dict[str, np.ndarray]:
+    """
+    Load pre-fitted processor parameters from qlib's pickle file.
+
+    This demonstrates how to extract the fitted mean/std from qlib's
+    RobustZScoreNorm processor for use in standalone code.
+
+    Args:
+        proc_path: Path to qlib's proc_list.proc file.
+                  If None, uses the path from the original VAE model.
+
+    Returns:
+        Dictionary with 'mean_train' and 'std_train' numpy arrays
+    """
+    if proc_path is None:
+        proc_path = "/home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/proc_list.proc"
+
+    print(f"Loading qlib processor parameters from: {proc_path}")
+
+    with open(proc_path, "rb") as fin:
+        proc_list = pkl.load(fin)
+
+    # Find RobustZScoreNorm processor (index 7 in the list)
+    zscore_proc = None
+    for proc in proc_list:
+        if type(proc).__name__ == "RobustZScoreNorm":
+            zscore_proc = proc
+            break
+
+    if zscore_proc is None:
+        raise ValueError("RobustZScoreNorm processor not found in proc_list")
+
+    params = {
+        'mean_train': zscore_proc.mean_train,
+        'std_train': zscore_proc.std_train,
+        'fit_start_time': getattr(zscore_proc, 'fit_start_time', None),
+        'fit_end_time': getattr(zscore_proc, 'fit_end_time', None),
+    }
+
+    print(f"Loaded parameters:")
+    print(f"  mean_train shape: {params['mean_train'].shape}")
+    print(f"  std_train shape: {params['std_train'].shape}")
+    print(f"  fitted on: {params['fit_start_time']} to {params['fit_end_time']}")
+
+    return params
+
+
+# Example usage function
+def generate_embeddings_with_qlib_params(
+    start_date: str = DEFAULT_START_DATE,
+    end_date: str = DEFAULT_END_DATE,
+    output_file: Optional[str] = None
+) -> pl.DataFrame:
+    """
+    Example of how to use pre-fitted qlib parameters for normalization.
+
+    This is an alternative to generate_embeddings() that uses the exact
+    same normalization parameters as the original qlib pipeline.
+    """
+    # Load the pre-fitted parameters
+    qlib_params = load_qlib_processor_params()
+
+    # Load data (same as regular pipeline)
+    df_alpha, df_kline, df_industry = load_all_data(start_date, end_date)
+    df = merge_data_sources(df_alpha, df_kline, df_industry)
+
+    datetime_col = df['datetime'].clone()
+    instrument_col = df['instrument'].clone()
+
+    # Process through pipeline, but use qlib params for normalization
+    # (This would require modifying apply_feature_pipeline to accept params)
+    # For now, this is a demonstration of the pattern
+
+    print("\nNote: To use qlib params, modify apply_feature_pipeline() to accept")
+    print("qlib_mean and qlib_std arguments and pass them to RobustZScoreNorm")
+
+    return df
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate embeddings from alpha158_0_7_beta factors")
+    parser.add_argument("--start-date", type=str, default=DEFAULT_START_DATE,
+                        help="Start date (YYYY-MM-DD)")
+    parser.add_argument("--end-date", type=str, default=DEFAULT_END_DATE,
+                        help="End date (YYYY-MM-DD)")
+    parser.add_argument("--output", type=str, default=None,
+                        help="Output parquet file path")
+    parser.add_argument("--no-vae", action="store_true",
+                        help="Skip VAE encoding (use random embeddings for testing)")
+
+    args = parser.parse_args()
+
+    df = generate_embeddings(
+        start_date=args.start_date,
+        end_date=args.end_date,
+        output_file=args.output,
+        use_vae=not args.no_vae
+    )
+
+    print("\nDone!")
+    print(f"Generated embeddings for {len(df)} samples")
+    print(df.head())
diff --git a/stock_1d/d033/alpha158_beta/scripts/generate_returns.py b/stock_1d/d033/alpha158_beta/scripts/generate_returns.py
new file mode 100644
index 0000000..12c7a49
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/generate_returns.py
@@ -0,0 +1,292 @@
+#!/usr/bin/env python
+"""
+Script to generate actual returns using real kline data without changing the original format.
+This calculates real returns from kline VWAP prices using the original datetime and instrument format
+and saves the result as 'v2v_5d' column.
+"""
+
+import pandas as pd
+import numpy as np
+import polars as pl
+from datetime import datetime, timedelta
+import os
+
+def generate_real_returns_from_kline(input_kline_path="/data/parquet/dataset/stg_1day_wind_kline_adjusted_1D/",
+                                   prediction_file=None,
+                                   output_file="../data/actual_returns.parquet",
+                                   return_days=5):
+    """
+    Generate real returns based on kline data using original datetime and instrument format.
+
+    Args:
+        input_kline_path: Path to the kline data
+        prediction_file: Optional prediction file to determine date range
+        output_file: Output file for actual returns
+        return_days: Number of days for return calculation (default 5)
+    """
+    print(f"Generating real returns from kline data...")
+
+    # Import qshare functions for return calculation and spine operations
+    try:
+        from qshare.algo.polars.eval import calc_daily_return
+        from qshare.algo.polars.spine import create_spine, align_to_calendar, merge_data_onto_spine
+        print("Successfully imported qshare functions including spine operations")
+        calc_daily_return_fn = calc_daily_return
+    except ImportError as e:
+        print(f"Could not import qshare functions: {e}")
+        print("Falling back to manual return calculation without spine-filling")
+
+        def calc_daily_return_manual(df, price_col, window_len, col_name, bias=1):
+            """Manual implementation of daily return calculation."""
+            # Sort by instrument and datetime
+            df = df.sort(['instrument', 'datetime'])
+
+            # Calculate shifted prices for future returns
+            df = df.with_columns([
+                pl.col(price_col).shift(-bias).over('instrument').alias('price_base'),
+                pl.col(price_col).shift(-(bias + window_len - 1)).over('instrument').alias('price_end')
+            ])
+
+            # Calculate returns
+            df = df.with_columns([
+                ((pl.col('price_end') / pl.col('price_base')) - 1).alias(col_name)
+            ])
+
+            # Clean up temporary columns
+            df = df.drop(['price_base', 'price_end'])
+
+            return df
+
+        calc_daily_return_fn = calc_daily_return_manual
+
+    # Determine date range - either from prediction file or use default range
+    if prediction_file and os.path.exists(prediction_file):
+        print(f"Using prediction file {prediction_file} to determine date range...")
+        df_pred = pl.read_parquet(prediction_file)
+
+        pred_min_date = df_pred['date'].min()
+        pred_max_date = df_pred['date'].max()
+
+        pred_min_date_int = int(pred_min_date.strftime('%Y%m%d'))
+        pred_max_date_int = int(pred_max_date.strftime('%Y%m%d'))
+
+        print(f"Prediction date range: {pred_min_date} to {pred_max_date}")
+    else:
+        # Use a reasonable default range if no prediction file provided
+        print("No prediction file provided, using default date range...")
+        # Default to a range that should have data: 2019-01-01 to 2020-11-30
+        pred_min_date_int = 20190101
+        pred_max_date_int = 20201130
+        print(f"Default date range: {pred_min_date_int} to {pred_max_date_int}")
+
+    print(f"Loading kline data from {input_kline_path} and filtering to date range...")
+
+    # Use lazy loading for efficiency and filter kline data
+    try:
+        df_kline = (
+            pl.scan_parquet(input_kline_path)
+            .filter(
+                pl.col('datetime').is_between(pred_min_date_int, pred_max_date_int)
+            )
+            .collect()
+        )
+
+        print(f"Kline data shape after filtering: {df_kline.shape}")
+        print(f"Kline columns: {df_kline.columns}")
+        print(f"Kline schema: {df_kline.schema}")
+
+    except Exception as e:
+        print(f"Error loading kline data: {e}")
+        return None
+
+    if df_kline.height == 0:
+        print("No kline data found within the date range!")
+        return None
+
+    # Verify that we have required columns
+    if 'datetime' not in df_kline.columns:
+        raise ValueError("No datetime column found in kline data")
+    if 'instrument' not in df_kline.columns:
+        raise ValueError("No instrument column found in kline data")
+
+    # Use VWAP as the price column for return calculation
+    price_col = 'vwap'
+    if price_col not in df_kline.columns:
+        print(f"Column '{price_col}' not found in kline data.")
+        # Look for other possible price columns
+        possible_price_cols = []
+        for col in df_kline.columns:
+            if any(price_term in col.lower() for price_term in ['price', 'vwap', 'close', 'adj', 'pct', 'open', 'high', 'low']):
+                possible_price_cols.append(col)
+
+        print(f"Possible price columns: {possible_price_cols}")
+        if possible_price_cols:
+            price_col = possible_price_cols[0]  # Use first available price-like column
+            print(f"Using '{price_col}' as price column instead.")
+        else:
+            # If no obvious price column, use the first numeric column
+            for col in df_kline.columns:
+                if col not in ['datetime', 'instrument']:  # Exclude datetime and instrument
+                    if df_kline[col].dtype in [pl.Float32, pl.Float64, pl.Int32, pl.Int64]:
+                        price_col = col
+                        break
+            if 'vwap' not in locals() and 'vwap' not in globals():
+                raise ValueError("No suitable price column found in kline data")
+
+    print(f"Using price column: {price_col}")
+
+    # Sort data by instrument and datetime to ensure proper temporal ordering
+    df_kline = df_kline.sort(['instrument', 'datetime'])
+
+    # Apply spine-filling approach to ensure complete coverage
+    print("Applying spine-filling to ensure complete date/instrument coverage...")
+
+    # Create spine to fill in missing combinations
+    try:
+        # Get unique dates and instruments in the dataset
+        unique_dates = df_kline.select(pl.col('datetime').unique().sort()).get_column('datetime')
+        unique_instruments = df_kline.select(pl.col('instrument').unique()).get_column('instrument')
+
+        # Create a spine (cartesian product of dates and instruments)
+        spine_dates = unique_dates.cast(pl.Int32).to_frame()
+        spine_dates = spine_dates.rename({'datetime': 'datetime'})
+
+        spine_instruments = unique_instruments.cast(pl.Int32).to_frame()
+        spine_instruments = spine_instruments.rename({'instrument': 'instrument'})
+
+        # Create full spine by cross join
+        df_spine = spine_dates.join(spine_instruments, how='cross')
+
+        # Merge the kline data onto the spine (left join to keep all spine entries)
+        df_filled = df_spine.join(
+            df_kline,
+            on=['datetime', 'instrument'],
+            how='left'
+        )
+
+        print(f"Spine-filling completed. Shape before: {df_kline.shape}, after: {df_filled.shape}")
+
+        # Forward fill and backward fill to handle missing price data where possible
+        # Sort by instrument and datetime for proper fill operations
+        df_filled = df_filled.sort(['instrument', 'datetime'])
+
+        # Fill missing price data using forward/backward fill within each instrument
+        df_filled = df_filled.with_columns([
+            pl.col(price_col).forward_fill().backward_fill().over('instrument').alias(f'{price_col}_filled')
+        ])
+
+        # Use filled price if original was null, otherwise use original
+        df_filled = df_filled.with_columns([
+            pl.when(pl.col(price_col).is_null())
+            .then(pl.col(f'{price_col}_filled'))
+            .otherwise(pl.col(price_col))
+            .alias(price_col)
+        ]).drop(f'{price_col}_filled')
+
+        # Keep only rows where we have price data after filling
+        df_kline = df_filled.filter(pl.col(price_col).is_not_null())
+
+        print(f"After spine-filling and cleaning: {df_kline.shape}")
+
+    except Exception as e:
+        print(f"Error during spine-filling: {e}")
+        print("Continuing with original data...")
+        # Continue with original df_kline
+
+    print(f"Calculating {return_days}-day returns from T+1's {price_col} to T+{return_days+1}'s {price_col}...")
+
+    # Calculate returns using qshare function if available, otherwise manual
+    try:
+        df_returns = calc_daily_return_fn(
+            pldf=df_kline,
+            price_col=price_col,
+            window_len=return_days,           # specified return period
+            col_name='v2v_5d',               # Output column name (as requested)
+            bias=1,                         # Use T+1 price as base for forward return
+            return_type='normal'             # Regular return (not log return)
+        )
+    except Exception as e:
+        print(f"Error calculating returns with qshare function: {e}")
+        print("Attempting manual calculation...")
+
+        # Manual calculation as fallback
+        df_returns = df_kline.sort(['instrument', 'datetime']).with_columns([
+            pl.col(price_col).shift(-1).over('instrument').alias('price_base'),
+            pl.col(price_col).shift(-(1 + return_days - 1)).over('instrument').alias('price_end')
+        ]).with_columns([
+            ((pl.col('price_end') / pl.col('price_base')) - 1).alias('v2v_5d')
+        ]).drop(['price_base', 'price_end'])
+
+    print(f"Calculated returns shape: {df_returns.shape}")
+    print(f"Calculated returns schema: {df_returns.schema}")
+
+    # Handle potential missing values or infinite returns
+    df_returns = df_returns.filter(
+        pl.col('v2v_5d').is_not_null() &
+        pl.col('v2v_5d').is_finite()
+    )
+
+    print(f"Returns after filtering invalid values: {df_returns.shape}")
+
+    # Keep the original datetime and instrument columns without conversion
+    df_output = df_returns.select([
+        'datetime',      # Keep original uint32 datetime format
+        'instrument',    # Keep original uint32 instrument format
+        'v2v_5d'         # Use requested column name
+    ])
+
+    print(f"Final output shape: {df_output.shape}")
+    print(f"Output schema: {df_output.schema}")
+
+    # Display some statistics about the returns
+    if 'v2v_5d' in df_output.columns and len(df_output) > 0:
+        returns_data = df_output['v2v_5d'].drop_nulls()
+        if len(returns_data) > 0:
+            print(f"Return statistics:")
+            print(f"  Count: {len(returns_data)}")
+            print(f"  Mean: {returns_data.mean():.6f}")
+            print(f"  Std: {returns_data.std():.6f}")
+            print(f"  Min: {returns_data.min():.6f}")
+            print(f"  Max: {returns_data.max():.6f}")
+            print(f"  25th percentile: {returns_data.quantile(0.25):.6f}")
+            print(f"  75th percentile: {returns_data.quantile(0.75):.6f}")
+        else:
+            print("  No valid returns data after filtering")
+
+    # Save to parquet preserving original datetime and instrument formats
+    df_output.write_parquet(output_file)
+    print(f"Real returns saved to {output_file} with original datetime and instrument formats")
+
+    return df_output
+
+
+if __name__ == "__main__":
+    # Generate real returns from kline data using the original format
+
+    # Define the prediction file to use as date range reference (optional)
+    pred_file = "../data/original_predictions_0_7.parquet"
+
+    # Check if the prediction file exists to use for date range
+    pred_file_path = pred_file if os.path.exists(pred_file) else None
+
+    if pred_file_path:
+        print(f"Using prediction file to determine date range: {pred_file_path}")
+    else:
+        print("Prediction file not found, using default date range")
+
+    print("Generating real returns from kline data...")
+    real_returns_df = generate_real_returns_from_kline(
+        input_kline_path="/data/parquet/dataset/stg_1day_wind_kline_adjusted_1D/",
+        prediction_file=pred_file_path,
+        output_file="../data/actual_returns.parquet",
+        return_days=5
+    )
+
+    if real_returns_df is not None:
+        print("Real return generation completed successfully!")
+        print("The output file contains:")
+        print("- Original datetime format (uint32 YYYYMMDD)")
+        print("- Original instrument format (uint32)")
+        print("- Returns in 'v2v_5d' column")
+    else:
+        print("Failed to generate real returns.")
\ No newline at end of file
diff --git a/stock_1d/d033/alpha158_beta/scripts/predict_with_embedding.py b/stock_1d/d033/alpha158_beta/scripts/predict_with_embedding.py
new file mode 100644
index 0000000..839e048
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/predict_with_embedding.py
@@ -0,0 +1,433 @@
+#!/usr/bin/env python
+"""
+Standalone script to generate predictions using the d033 model with locally generated alpha158_0_7_beta embeddings.
+
+This script does NOT rely on qlib's data handlers. It:
+1. Loads beta embeddings from local parquet file (generated by generate_beta_embedding.py)
+2. Applies the necessary processing (normalization, neutralization)
+3. Uses the d033 model to generate predictions
+4. Saves predictions to parquet
+"""
+
+import os
+import sys
+import pickle as pkl
+import io
+import numpy as np
+import polars as pl
+import pandas as pd
+import torch
+import torch.nn as nn
+from datetime import date, timedelta
+from typing import Optional, List, Tuple, Dict
+from pathlib import Path
+
+# Constants
+EMBEDDING_FILE = "../data/embedding_0_7_beta.parquet"
+MODEL_PATH = "/home/guofu/Workspaces/alpha/data_ops/tasks/app_longsignal/model/host140_exp20_d033/module.pt"
+OUTPUT_DIR = "../data"
+
+# Industry flag path for neutralization (optional)
+INDUSTRY_FLAG_PATH = "/data/parquet/dataset/stg_1day_gds_indus_flag_cc1_1D/"
+RISK_FACTOR_PATH = "/data/parquet/dataset/stg_1day_wind_kline_adjusted_1D/"
+
+
+def load_beta_embeddings(embedding_file: str, start_date: Optional[str] = None, end_date: Optional[str] = None) -> pl.DataFrame:
+    """
+    Load beta embeddings from local parquet file.
+
+    Args:
+        embedding_file: Path to the embeddings parquet file
+        start_date: Optional start date filter (YYYY-MM-DD)
+        end_date: Optional end date filter (YYYY-MM-DD)
+
+    Returns:
+        Polars DataFrame with embeddings
+    """
+    print(f"Loading beta embeddings from {embedding_file}...")
+    df = pl.read_parquet(embedding_file)
+    print(f"Loaded embeddings: {df.shape}")
+
+    # Convert datetime if needed
+    if 'datetime' in df.columns:
+        # Filter by date range if specified
+        if start_date:
+            start_dt = int(start_date.replace("-", ""))
+            df = df.filter(pl.col('datetime') >= start_dt)
+        if end_date:
+            end_dt = int(end_date.replace("-", ""))
+            df = df.filter(pl.col('datetime') <= end_dt)
+
+        print(f"Filtered embeddings: {df.shape}")
+
+    return df
+
+
+def load_d033_model(model_path: str) -> nn.Module:
+    """
+    Load the d033 prediction model.
+
+    Returns the underlying PyTorch model ready for inference on CPU.
+    """
+    print(f"Loading d033 model from {model_path}...")
+
+    # Patch torch.load to always use CPU
+    original_torch_load = torch.load
+
+    def cpu_torch_load(*args, **kwargs):
+        kwargs['map_location'] = 'cpu'
+        return original_torch_load(*args, **kwargs)
+
+    # Apply the patch
+    torch.load = cpu_torch_load
+
+    try:
+        with open(model_path, "rb") as fin:
+            model = pkl.load(fin)
+
+        # The model is already an RNNPredict instance
+        # Set to eval mode for inference
+        model.eval()
+
+        # Set signal function (required for prediction)
+        if not hasattr(model, 'signal_func'):
+            model.signal_func = {"type": "logistic"}
+
+        print("Model loaded successfully (CPU)")
+        return model
+
+    except RuntimeError as e:
+        if "CUDA" in str(e):
+            print("Model contains CUDA tensors, attempting CPU conversion...")
+
+            with open(model_path, "rb") as fin:
+                content = fin.read()
+
+            model = torch.load(io.BytesIO(content), map_location='cpu', weights_only=False)
+            model.eval()
+
+            # Set signal function (required for prediction)
+            if not hasattr(model, 'signal_func'):
+                model.signal_func = {"type": "logistic"}
+
+            print("Model loaded and converted to CPU")
+            return model
+        else:
+            raise
+    finally:
+        # Restore original torch.load
+        torch.load = original_torch_load
+
+
+def apply_cs_zscore_norm(df: pl.DataFrame, embedding_cols: List[str]) -> pl.DataFrame:
+    """
+    Apply cross-sectional z-score normalization per datetime.
+    This normalizes features within each date (cross-sectionally).
+
+    Args:
+        df: DataFrame with embeddings
+        embedding_cols: List of embedding column names
+
+    Returns:
+        DataFrame with normalized embeddings
+    """
+    print("Applying cross-sectional z-score normalization...")
+
+    # For each embedding column, calculate mean/std per datetime and normalize
+    normalized_cols = []
+
+    for col in embedding_cols:
+        # Calculate mean and std per datetime (cross-sectionally)
+        mean_expr = pl.col(col).mean().over('datetime')
+        std_expr = pl.col(col).std().over('datetime')
+
+        # Z-score: (x - mean) / std, with protection against div by zero
+        norm_col = pl.when(std_expr > 0).then(
+            (pl.col(col) - mean_expr) / std_expr
+        ).otherwise(0.0).alias(col)
+
+        normalized_cols.append(norm_col)
+
+    # Select non-embedding columns + normalized embedding columns
+    other_cols = [c for c in df.columns if c not in embedding_cols]
+    df_normalized = df.select(other_cols + normalized_cols)
+
+    return df_normalized
+
+
+def apply_robust_zscore_norm(df: pl.DataFrame, embedding_cols: List[str]) -> pl.DataFrame:
+    """
+    Apply robust z-score normalization (uses median instead of mean).
+
+    Args:
+        df: DataFrame with embeddings
+        embedding_cols: List of embedding column names
+
+    Returns:
+        DataFrame with normalized embeddings
+    """
+    print("Applying robust z-score normalization...")
+
+    normalized_cols = []
+
+    for col in embedding_cols:
+        # Calculate median and MAD (median absolute deviation) per datetime
+        median_expr = pl.col(col).median().over('datetime')
+        mad_expr = (pl.col(col) - median_expr).abs().median().over('datetime')
+
+        # Robust z-score: (x - median) / (1.4826 * MAD), with protection
+        norm_col = pl.when(mad_expr > 0).then(
+            (pl.col(col) - median_expr) / (1.4826 * mad_expr)
+        ).otherwise(0.0).alias(col)
+
+        normalized_cols.append(norm_col)
+
+    # Clip outliers at [-10, 10]
+    clipped_cols = []
+    for col in normalized_cols:
+        clipped_cols.append(
+            pl.col(col.name).clip(-10, 10).alias(col.name)
+        )
+
+    other_cols = [c for c in df.columns if c not in embedding_cols]
+    df_normalized = df.select(other_cols + clipped_cols)
+
+    return df_normalized
+
+
+def apply_fillna(df: pl.DataFrame, embedding_cols: List[str], fill_value: float = 0.0) -> pl.DataFrame:
+    """Fill NA values in embedding columns."""
+    filled_cols = []
+    for col in embedding_cols:
+        filled_cols.append(pl.col(col).fill_null(fill_value).alias(col))
+
+    other_cols = [c for c in df.columns if c not in embedding_cols]
+    return df.select(other_cols + filled_cols)
+
+
+def prepare_features_for_model(df: pl.DataFrame, embedding_cols: List[str], seq_len: int = 40) -> Tuple[np.ndarray, pl.DataFrame]:
+    """
+    Prepare features for the model by creating sequences.
+
+    The d033 model expects 3D input: [batch_size, seq_len, d_feat]
+    where seq_len is the lookback window (default 40 days).
+
+    Args:
+        df: DataFrame with normalized embeddings
+        embedding_cols: List of embedding column names
+        seq_len: Sequence length (lookback window)
+
+    Returns:
+        Tuple of (features_array, aligned_df)
+    """
+    print(f"Preparing sequences with length {seq_len}...")
+
+    # Sort by instrument and datetime
+    df = df.sort(['instrument', 'datetime'])
+
+    # Get unique instruments
+    instruments = df['instrument'].unique().to_list()
+
+    features_list = []
+    metadata_list = []
+
+    for inst in instruments:
+        # Get data for this instrument
+        inst_df = df.filter(pl.col('instrument') == inst)
+        inst_data = inst_df.select(embedding_cols).to_numpy().astype(np.float32)
+        inst_meta = inst_df.select(['datetime', 'instrument']).to_numpy()
+
+        # Create sliding windows
+        for i in range(seq_len - 1, len(inst_data)):
+            # Get sequence of seq_len days ending at day i
+            seq = inst_data[i - seq_len + 1:i + 1]  # [seq_len, d_feat]
+            features_list.append(seq)
+
+            # Metadata for this prediction (the last day in sequence)
+            metadata_list.append(inst_meta[i])
+
+    if not features_list:
+        raise ValueError(f"Not enough data to create sequences of length {seq_len}")
+
+    features_array = np.stack(features_list, axis=0)  # [N, seq_len, d_feat]
+    metadata_array = np.array(metadata_list)
+
+    # Create metadata DataFrame
+    metadata_df = pl.DataFrame({
+        'datetime': metadata_array[:, 0],
+        'instrument': metadata_array[:, 1]
+    })
+
+    print(f"Prepared features shape: {features_array.shape}")
+    print(f"Metadata shape: {metadata_df.shape}")
+
+    return features_array, metadata_df
+
+
+def predict_with_model(model, features: np.ndarray, batch_size: int = 1000) -> np.ndarray:
+    """
+    Generate predictions using the loaded model.
+
+    Args:
+        model: Loaded d033 model
+        features: Feature array [N, seq_len, d_feat]
+        batch_size: Batch size for inference
+
+    Returns:
+        Predictions array [N]
+    """
+    print(f"Generating predictions for {features.shape[0]} samples...")
+
+    device = torch.device('cpu')
+    model = model.to(device)
+    model.eval()
+
+    all_preds = []
+
+    with torch.no_grad():
+        for i in range(0, len(features), batch_size):
+            batch = features[i:i + batch_size]
+            batch_tensor = torch.tensor(batch, dtype=torch.float32, device=device)
+
+            # Forward pass
+            _, pred = model(batch_tensor)
+
+            # Convert to numpy
+            pred_np = pred.cpu().numpy()
+            all_preds.append(pred_np)
+
+    predictions = np.concatenate(all_preds, axis=0)
+    print(f"Generated {len(predictions)} predictions")
+
+    return predictions
+
+
+def predict_with_embeddings(
+    embeddings_df: pl.DataFrame,
+    model,
+    output_file: Optional[str] = None,
+    seq_len: int = 40,
+    batch_size: int = 1000
+) -> pl.DataFrame:
+    """
+    Generate predictions using embeddings and the d033 model.
+
+    Args:
+        embeddings_df: DataFrame with beta embeddings
+        model: Loaded d033 model
+        output_file: Optional output file path
+        seq_len: Sequence length for model input
+        batch_size: Batch size for inference
+
+    Returns:
+        DataFrame with predictions
+    """
+    print("Generating predictions...")
+
+    # Get embedding columns
+    embedding_cols = [col for col in embeddings_df.columns if col.startswith('embedding_')]
+    print(f"Found {len(embedding_cols)} embedding columns")
+
+    # Apply inference processors
+    df_processed = apply_cs_zscore_norm(embeddings_df, embedding_cols)
+    df_processed = apply_fillna(df_processed, embedding_cols, fill_value=0.0)
+
+    # Prepare sequences for model
+    features, metadata_df = prepare_features_for_model(df_processed, embedding_cols, seq_len=seq_len)
+
+    # Generate predictions
+    predictions = predict_with_model(model, features, batch_size=batch_size)
+
+    # Create output DataFrame
+    result_df = metadata_df.with_columns([
+        pl.Series(name="prediction", values=predictions)
+    ])
+
+    # Save to parquet
+    if output_file is None:
+        output_file = os.path.join(OUTPUT_DIR, "predictions_beta_embedding.parquet")
+
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    result_df.write_parquet(output_file)
+    print(f"Predictions saved to {output_file}")
+
+    return result_df
+
+
+def generate_predictions(
+    embedding_file: str = EMBEDDING_FILE,
+    model_path: str = MODEL_PATH,
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    output_file: Optional[str] = None,
+    seq_len: int = 40,
+    batch_size: int = 1000
+) -> pl.DataFrame:
+    """
+    Main function to generate predictions using beta embeddings.
+
+    Args:
+        embedding_file: Path to beta embeddings parquet file
+        model_path: Path to d033 model
+        start_date: Optional start date filter
+        end_date: Optional end date filter
+        output_file: Optional output file path
+        seq_len: Sequence length for model input (lookback window)
+        batch_size: Batch size for inference
+
+    Returns:
+        DataFrame with predictions
+    """
+    print("=" * 60)
+    print("Generating Predictions with Alpha158 0_7 Beta Embeddings")
+    print("=" * 60)
+
+    # Load embeddings
+    df_embeddings = load_beta_embeddings(embedding_file, start_date, end_date)
+
+    # Load model
+    model = load_d033_model(model_path)
+
+    # Generate predictions
+    predictions = predict_with_embeddings(
+        df_embeddings, model, output_file,
+        seq_len=seq_len, batch_size=batch_size
+    )
+
+    return predictions
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate predictions with beta embeddings")
+    parser.add_argument("--embeddings", type=str, default=EMBEDDING_FILE,
+                        help="Path to beta embeddings parquet file")
+    parser.add_argument("--model", type=str, default=MODEL_PATH,
+                        help="Path to d033 model")
+    parser.add_argument("--start-date", type=str, default=None,
+                        help="Start date (YYYY-MM-DD)")
+    parser.add_argument("--end-date", type=str, default=None,
+                        help="End date (YYYY-MM-DD)")
+    parser.add_argument("--output", type=str, default=None,
+                        help="Output parquet file path")
+    parser.add_argument("--seq-len", type=int, default=40,
+                        help="Sequence length (lookback window)")
+    parser.add_argument("--batch-size", type=int, default=1000,
+                        help="Batch size for inference")
+
+    args = parser.parse_args()
+
+    df = generate_predictions(
+        embedding_file=args.embeddings,
+        model_path=args.model,
+        start_date=args.start_date,
+        end_date=args.end_date,
+        output_file=args.output,
+        seq_len=args.seq_len,
+        batch_size=args.batch_size
+    )
+
+    print("\nDone!")
+    print(f"Generated {len(df)} predictions")
+    print(df.head())
\ No newline at end of file
diff --git a/stock_1d/d033/alpha158_beta/scripts/regenerate_sample_embedding.py b/stock_1d/d033/alpha158_beta/scripts/regenerate_sample_embedding.py
new file mode 100644
index 0000000..1ffe4d5
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/regenerate_sample_embedding.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+"""
+Regenerate beta embeddings for a few days of sample data.
+
+This script generates embeddings for a small date range to test the pipeline.
+"""
+
+import os
+import sys
+import pickle as pkl
+import numpy as np
+import polars as pl
+import torch
+import torch.nn as nn
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Optional
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Import from the main generate script
+from generate_beta_embedding import (
+    load_all_data,
+    merge_data_sources,
+    apply_feature_pipeline,
+    prepare_vae_features,
+    load_vae_model,
+    encode_with_vae,
+    load_qlib_processor_params,
+    VAE_INPUT_DIM,
+    OUTPUT_DIR,
+)
+
+# Sample dates for testing (5 consecutive trading days)
+SAMPLE_DATES = [
+    "2019-01-02",
+    "2019-01-03",
+    "2019-01-04",
+    "2019-01-07",
+    "2019-01-08",
+]
+
+VAE_MODEL_PATH = "/home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/model/csiallx_feature2_ntrla_flag_pnlnorm_vae4_dim32a_beta0001/module.pt"
+
+
+def generate_sample_embeddings(
+    dates: List[str] = SAMPLE_DATES,
+    output_file: str = "embedding_0_7_beta_sample.parquet",
+    use_vae: bool = True
+) -> pl.DataFrame:
+    """
+    Generate embeddings for a sample of dates.
+
+    Args:
+        dates: List of dates in YYYY-MM-DD format
+        output_file: Output parquet file path
+        use_vae: Whether to use VAE for encoding (or random embeddings)
+    """
+    start_date = dates[0]
+    end_date = dates[-1]
+
+    print("=" * 60)
+    print("Generating Sample Beta Embeddings")
+    print(f"Dates: {dates}")
+    print(f"Use VAE: {use_vae}")
+    print("=" * 60)
+
+    # Load all data sources
+    df_alpha, df_kline, df_flag, df_industry = load_all_data(start_date, end_date)
+
+    print(f"\nLoaded data:")
+    print(f"  Alpha158: {df_alpha.shape}")
+    print(f"  Kline: {df_kline.shape}")
+    print(f"  Flags: {df_flag.shape}")
+    print(f"  Industry: {df_industry.shape}")
+
+    # Filter to only the sample dates
+    date_ints = [int(d.replace("-", "")) for d in dates]
+    df_alpha = df_alpha.filter(pl.col("datetime").is_in(date_ints))
+    df_kline = df_kline.filter(pl.col("datetime").is_in(date_ints))
+    df_flag = df_flag.filter(pl.col("datetime").is_in(date_ints))
+    df_industry = df_industry.filter(pl.col("datetime").is_in(date_ints))
+
+    print(f"\nAfter filtering to sample dates:")
+    print(f"  Alpha158: {df_alpha.shape}")
+    print(f"  Kline: {df_kline.shape}")
+    print(f"  Flags: {df_flag.shape}")
+    print(f"  Industry: {df_industry.shape}")
+
+    # Merge data sources
+    df = merge_data_sources(df_alpha, df_kline, df_flag, df_industry)
+    print(f"\nMerged data shape: {df.shape}")
+
+    # Save datetime and instrument before processing
+    datetime_col = df["datetime"].clone()
+    instrument_col = df["instrument"].clone()
+
+    # Apply feature transformation pipeline
+    df_processed, feature_cols, norm_feature_cols, market_flag_for_vae = apply_feature_pipeline(df)
+
+    # Prepare features for VAE
+    features = prepare_vae_features(
+        df_processed, feature_cols,
+        norm_feature_cols=norm_feature_cols,
+        market_flag_for_vae=market_flag_for_vae
+    )
+
+    print(f"\nFeature matrix shape: {features.shape}")
+
+    # Encode with VAE
+    if use_vae:
+        try:
+            model = load_vae_model(VAE_MODEL_PATH)
+            embeddings = encode_with_vae(features, model)
+            print(f"\nVAE encoding successful!")
+        except Exception as e:
+            print(f"\nVAE encoding failed: {e}")
+            import traceback
+            traceback.print_exc()
+            print("\nFalling back to random embeddings...")
+            np.random.seed(42)
+            embeddings = np.random.randn(features.shape[0], 32).astype(np.float32)
+    else:
+        print("\nUsing random embeddings (VAE disabled)...")
+        np.random.seed(42)
+        embeddings = np.random.randn(features.shape[0], 32).astype(np.float32)
+
+    # Create output DataFrame
+    embedding_cols = [f"embedding_{i}" for i in range(embeddings.shape[1])]
+
+    result_data = {
+        "datetime": datetime_col.to_list(),
+        "instrument": instrument_col.to_list(),
+        **{col_name: embeddings[:, i].tolist() for i, col_name in enumerate(embedding_cols)}
+    }
+
+    df_result = pl.DataFrame(result_data)
+
+    # Ensure output directory exists
+    output_path = Path(output_file)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Save to parquet
+    df_result.write_parquet(output_path)
+    print(f"\nEmbeddings saved to: {output_path}")
+    print(f"Output shape: {df_result.shape}")
+    print(f"\nSample output:")
+    print(df_result.head(10))
+
+    # Print summary statistics
+    print("\n" + "=" * 60)
+    print("Summary Statistics")
+    print("=" * 60)
+    print(f"Total samples: {len(df_result)}")
+    print(f"Embedding dimension: {embeddings.shape[1]}")
+    print(f"Date range: {df_result['datetime'].min()} to {df_result['datetime'].max()}")
+    print(f"Instruments: {df_result['instrument'].n_unique()}")
+    print(f"Embedding mean: {np.mean(embeddings):.6f}")
+    print(f"Embedding std: {np.std(embeddings):.6f}")
+    print(f"Embedding min: {np.min(embeddings):.6f}")
+    print(f"Embedding max: {np.max(embeddings):.6f}")
+
+    return df_result
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate sample beta embeddings")
+    parser.add_argument("--dates", nargs="+", default=SAMPLE_DATES,
+                        help="List of dates (YYYY-MM-DD)")
+    parser.add_argument("--output", type=str, default="embedding_0_7_beta_sample.parquet",
+                        help="Output parquet file")
+    parser.add_argument("--no-vae", action="store_true",
+                        help="Skip VAE encoding (use random embeddings)")
+
+    args = parser.parse_args()
+
+    generate_sample_embeddings(
+        dates=args.dates,
+        output_file=args.output,
+        use_vae=not args.no_vae
+    )
+
+    print("\nDone!")
diff --git a/stock_1d/d033/alpha158_beta/scripts/run.log b/stock_1d/d033/alpha158_beta/scripts/run.log
new file mode 100644
index 0000000..8d58b7c
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/run.log
@@ -0,0 +1,394 @@
+[2715583:MainThread](2026-02-26 19:58:16,674) INFO - qlib.Initialization - [config.py:413] - default_conf: client.
+[2715583:MainThread](2026-02-26 19:58:16,680) INFO - qlib.Initialization - [__init__.py:74] - qlib successfully initialized based on client settings.
+[2715583:MainThread](2026-02-26 19:58:16,681) INFO - qlib.Initialization - [__init__.py:76] - data_path={'__DEFAULT_FREQ': PosixPath('/data/qlib/default/data_ops/target')}
+================================================================================
+DUMP GOLD-STANDARD DATA FROM QLIB PIPELINE
+================================================================================
+Date Range: 2020-01-02 to 2020-01-10
+Output Directory: /home/guofu/Workspaces/alpha_lab/stock_1d/d033/alpha158_beta/data
+Qlib Dataset Path: /home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/
+
+Step 1: Loading data from Qlib pipeline...
+  Loading since_date=2020-01-02
+Will use `placehorder_value` from module: qlib.contrib.data.config
+Will init handler object from config:
+{'data_handler_config': {'ddb_config': {'host': '192.168.1.146',
+                                        'password': '123456',
+                                        'port': 8848,
+                                        'username': 'admin'},
+                         'end_time': datetime.date(2026, 2, 26),
+                         'handler_list': [{'class': 'DDBAlpha158Handler',
+                                           'kwargs': {'col_set': 'feature',
+                                                      'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                        'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': 'alpha158',
+                                                                        'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                          {'class': 'DDBMarketExtHandler',
+                                           'kwargs': {'col_set': 'feature_ext',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['Turnover '
+                                                                                       'as '
+                                                                                       'turnover',
+                                                                                       'FreeTurnover '
+                                                                                       'as '
+                                                                                       'free_turnover',
+                                                                                       'log(MarketValue) '
+                                                                                       'as '
+                                                                                       'log_size'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['con_rating_strength'],
+                                                                        'table_name': 'stg_1day_gds_con_rating'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                          {'class': 'DDBMarketFlagHandler',
+                                           'kwargs': {'col_set': 'feature_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['IsZt',
+                                                                                       'IsDt',
+                                                                                       'IsN',
+                                                                                       'IsXD',
+                                                                                       'IsXR',
+                                                                                       'IsDR'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['open_limit',
+                                                                                       'close_limit',
+                                                                                       'low_limit',
+                                                                                       'open_stop',
+                                                                                       'close_stop',
+                                                                                       'high_stop'],
+                                                                        'table_name': 'stg_1day_wind_market_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                          {'class': 'DDBIndusFlagHandler',
+                                           'kwargs': {'col_set': 'indus_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': 'industry_code_cc.csv',
+                                                                        'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                          {'class': 'DDBStFlagHandler',
+                                           'kwargs': {'col_set': 'st_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['ST_Y',
+                                                                                       'ST_S',
+                                                                                       'ST_T',
+                                                                                       'ST_L',
+                                                                                       'ST_Z',
+                                                                                       'ST_X'],
+                                                                        'table_name': 'stg_1day_wind_st_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                         'instruments': 'csiallx',
+                         'start_time': Timestamp('2019-12-03 00:00:00')},
+ 'ddb_config': {'host': '192.168.1.146',
+                'password': '123456',
+                'port': 8848,
+                'username': 'admin'},
+ 'handler': {'class': 'AggHandler',
+             'kwargs': {'ddb_config': {'host': '192.168.1.146',
+                                       'password': '123456',
+                                       'port': 8848,
+                                       'username': 'admin'},
+                        'end_time': datetime.date(2026, 2, 26)[2715583:MainThread](2026-02-26 19:58:16,707) INFO - qlib.AggHandler - [agg_handler.py:79] - Will use AggHandler
+[2715583:MainThread](2026-02-26 19:58:16,707) WARNING - qlib.DataLoaderDH - [agg_handler.py:191] - instruments[csiallx] is ignored
+[2715583:MainThread](2026-02-26 19:58:17,067) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,KMID,KLEN,KMID2,KUP,KUP2,KLOW,KLOW2,KSFT,KSFT2,OPEN0,HIGH0,LOW0,VWAP0,ROC5,ROC10,ROC20,ROC30,ROC60,MA5,MA10,MA20,MA30,MA60,STD5,STD10,STD20,STD30,STD60,BETA5,BETA10,BETA20,BETA30,BETA60,RSQR5,RSQR10,RSQR20,RSQR30,RSQR60,RESI5,RESI10,RESI20,RESI30,RESI60,MAX5,MAX10,MAX20,MAX30,MAX60,MIN5,MIN10,MIN20,MIN30,MIN60,QTLU5,QTLU10,QTLU20,QTLU30,QTLU60,QTLD5,QTLD10,QTLD20,QTLD30,QTLD60,RANK5,RANK10,RANK20,RANK30,RANK60,RSV5,RSV10,RSV20,RSV30,RSV60,IMAX5,IMAX
+[2715583:MainThread](2026-02-26 20:05:39,665) INFO - qlib.timer - [log.py:117] - Time cost: 442.946s | DDB query: Done
+[2715583:MainThread](2026-02-26 20:05:40,469) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+,
+                        'handler_list': [{'class': 'DDBAlpha158Handler',
+                                          'kwargs': {'col_set': 'feature',
+                                                     'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                       'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': 'alpha158',
+                                                                       'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                         {'class': 'DDBMarketExtHandler',
+                                          'kwargs': {'col_set': 'feature_ext',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': ['Turnover '
+                                                                                      'as '
+                                                                                      'turnover',
+                                                                                      'FreeTurnover '
+                                                                                      'as '
+                                                                                      'free_turnover',
+                                                                                      'log(MarketValue) '
+                                                                                      'as '
+                                                                                      'log_size'],
+                                                                       'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                      {'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': ['con_rating_strength'],
+                                                                       'table_name': 'stg_1day_gds_con_rating'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                         {'class': 'DDBMarketFlagHandler',
+                                          'kwargs': {'col_set': 'feature_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['IsZt',
+                                                                                      'IsDt',
+                                                                                      'IsN',
+                                                                                      'IsXD',
+                                                                                      'IsXR',
+                                                                                      'IsDR'],
+                                                                       'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                      {'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['open_limit',
+                                                                                      'close_limit',
+                                                                                      'low_limit',
+                                                                                      'open_stop',
+                                                                                      'close_stop',
+                                                                                      'high_stop'],
+                                                                       'table_name': 'stg_1day_wind_market_flag'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                         {'class': 'DDBIndusFlagHandler',
+                                          'kwargs': {'col_set': 'indus_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': 'industry_code_cc.csv',
+                                                                       'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                         {'class': 'DDBStFlagHandler',
+                                          'kwargs': {'col_set': 'st_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['ST_Y',
+                                                                                      'ST_S',
+                                                                                      'ST_T',
+                                                                                      'ST_L',
+                                                                                      'ST_Z',
+                                                                                      'ST_X'],
+                                                                       'table_name': 'stg_1day_wind_st_flag'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                        'instruments': 'csiallx',
+                        'start_time': Timestamp('2019-12-03 00:00:00')},
+             'module_path': 'qlib.contrib.data.agg_handler'},
+ 'load_end': datetime.date(2026, 2, 26),
+ 'load_start': Timestamp('2019-12-03 00:00:00'),
+ 'market': 'csiallx',
+ 'qlib_init': {'provider_uri': '/home/guofu/.qlib/data_ops/target',
+               'region': 'cn'}}
+Query config: 
+#alpha158: 1;
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x70e88b0587d0>
+[2715583:MainThread](2026-02-26 20:07:46,118) INFO - qlib.timer - [log.py:117] - Time cost: 115.964s | Instruments filter: Done
+[2715583:MainThread](2026-02-26 20:07:53,273) INFO - qlib.timer - [log.py:117] - Time cost: 576.561s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_alpha158_handler.DDBAlpha158Handler object at 0x70e88b086d80>) Done
+[2715583:MainThread](2026-02-26 20:07:53,274) INFO - qlib.timer - [log.py:117] - Time cost: 576.562s | Init data (<qlib.contrib.data.ddb_handlers.ddb_alpha158_handler.DDBAlpha158Handler object at 0x70e88b086d80>) Done
+[2715583:MainThread](2026-02-26 20:07:53,276) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2715583:MainThread](2026-02-26 20:07:56,700) INFO - qlib.timer - [log.py:117] - Time cost: 3.423s | fetch_df_by_index Done
+[2715583:MainThread](2026-02-26 20:07:58,185) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-03 00:00:00'), datetime.date(2026, 2, 26), None)
+                           KMID      KLEN  ...   VSUMD30   VSUMD60
+datetime   instrument                      ...                    
+2019-12-03 SH600000    0.004234  0.011008  ... -0.031454 -0.009671
+           SH600004    0.015467  0.031529  ... -0.004401  0.007701
+           SH600006    0.022573  0.033860  ...  0.060561 -0.000159
+           SH600007    0.012129  0.025470  ...  0.008489 -0.054056
+           SH600008    0.006173  0.009259  ... -0.088065 -0.080770
+...                         ...       ...  ...       ...       ...
+2026-02-26 SZ301658   -0.017231  0.025231  ... -0.018706  0.003708
+           SZ301662    0.060584  0.087834  ... -0.014658 -0.014613
+           SZ301665   -0.012899  0.040541  ...  0.083229  0.055994
+           SZ301678    0.018182  0.027879  ... -0.054124  0.014202
+           SZ302132    0.001754  0.016416  ... -0.049558 -0.038667
+
+[6886779 rows x 158 columns]
+[2715583:MainThread](2026-02-26 20:07:58,186) INFO - qlib.timer - [log.py:117] - Time cost: 4.911s | Fetching dataframe Done
+[2715583:MainThread](2026-02-26 20:07:58,203) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,Turnover as turnover,FreeTurnover as free_turnover,log(MarketValue) as log_size from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_kline_adjusted")
+            where m_nDate>=2019.12.03 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ3
+[2715583:MainThread](2026-02-26 20:08:15,182) INFO - qlib.timer - [log.py:117] - Time cost: 16.990s | DDB query: Done
+[2715583:MainThread](2026-02-26 20:08:15,974) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2715583:MainThread](2026-02-26 20:08:16,548) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,con_rating_strength from 
+            loadTable("dfs://daily_stock_run", "stg_1day_gds_con_rating")
+            where m_nDate>=2019.12.03 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657','SZ002833','SH
+[2715583:MainThread](2026-02-26 20:08:27,838) INFO - qlib.timer - [log.py:117] - Time cost: 11.299s | DDB query: Done
+[2715583:MainThread](2026-02-26 20:08:28,690) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-25 00:00:00
+[2715583:MainThread](2026-02-26 20:09:53,616) INFO - qlib.timer - [log.py:117] - Time cost: 81.815s | Instruments filter: Done
+[2715583:MainThread](2026-02-26 20:09:54,168) INFO - qlib.timer - [log.py:117] - Time cost: 115.981s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_market_ext_handler.DDBMarketExtHandler object at 0x70ea4ba85f40>) Done
+[2715583:MainThread](2026-02-26 20:09:54,169) INFO - qlib.timer - [log.py:117] - Time cost: 115.982s | Init data (<qlib.contrib.data.ddb_handlers.ddb_market_ext_handler.DDBMarketExtHandler object at 0x70ea4ba85f40>) Done
+[2715583:MainThread](2026-02-26 20:09:54,170) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2715583:MainThread](2026-02-26 20:09:54,893) INFO - qlib.timer - [log.py:117] - Time cost: 0.723s | fetch_df_by_index Done
+[2715583:MainThread](2026-02-26 20:09:54,901) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-03 00:00:00'), datetime.date(2026, 2, 26), None)
+                       turnover  free_turnover   log_size  con_rating_strength
+datetime   instrument                                                         
+2019-12-03 SH600000      0.0696         0.1275  17.322001               0.6618
+           SH600004      0.6009         1.2276  15.077468               0.8269
+           SH600006      0.5976         1.5087  13.716795               1.0000
+           SH600007      0.0961         0.4969  14.334991               0.7500
+           SH600008      0.0967         0.1793  14.432563               0.6591
+...                         ...            ...        ...                  ...
+2026-02-26 SZ301658      6.0785         6.0785  11.788368                  NaN
+           SZ301662     12.5950        12.5950  12.681215                  NaN
+           SZ301665     14.0077        14.0077  11.719415                  NaN
+           SZ301678      6.6518         6.6518  12.799973                  NaN
+           SZ302132      1.3868         3.0296  15.359885                  NaN
+
+[7601552 rows x 4 columns]
+[2715583:MainThread](2026-02-26 20:09:54,902) INFO - qlib.timer - [log.py:117] - Time cost: 0.732s | Fetching dataframe Done
+[2715583:MainThread](2026-02-26 20:09:54,917) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,IsZt,IsDt,IsN,IsXD,IsXR,IsDR from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_kline_adjusted")
+            where m_nDate>=2019.12.03 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657',
+[2715583:MainThread](2026-02-26 20:10:15,465) INFO - qlib.timer - [log.py:117] - Time cost: 20.556s | DDB query: Done
+[2715583:MainThread](2026-02-26 20:10:16,265) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2715583:MainThread](2026-02-26 20:10:16,775) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,open_limit,close_limit,low_limit,open_stop,close_stop,high_stop from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_market_flag")
+            where m_nDate>=2019.12.03 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','
+[2715583:MainThread](2026-02-26 20:10:36,740) INFO - qlib.timer - [log.py:117] - Time cost: 19.975s | DDB query: Done
+[2715583:MainThread](2026-02-26 20:10:37,558) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2715583:MainThread](2026-02-26 20:12:04,978) INFO - qlib.timer - [log.py:117] - Time cost: 84.148s | Instruments filter: Done
+[2715583:MainThread](2026-02-26 20:12:05,899) INFO - qlib.timer - [log.py:117] - Time cost: 130.996s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_market_flag_handler.DDBMarketFlagHandler object at 0x70e88d06acc0>) Done
+[2715583:MainThread](2026-02-26 20:12:05,900) INFO - qlib.timer - [log.py:117] - Time cost: 130.997s | Init data (<qlib.contrib.data.ddb_handlers.ddb_market_flag_handler.DDBMarketFlagHandler object at 0x70e88d06acc0>) Done
+[2715583:MainThread](2026-02-26 20:12:05,902) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2715583:MainThread](2026-02-26 20:12:06,745) INFO - qlib.timer - [log.py:117] - Time cost: 0.842s | fetch_df_by_index Done
+[2715583:MainThread](2026-02-26 20:12:06,758) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-03 00:00:00'), datetime.date(2026, 2, 26), None)
+                        IsZt   IsDt    IsN  ... open_stop close_stop high_stop
+datetime   instrument                       ...                               
+2019-12-03 SH600000    False  False  False  ...     False      False     False
+           SH600004    False  False  False  ...     False      False     False
+           SH600006    False  False  False  ...     False      False     False
+           SH600007    False  False  False  ...     False      False     False
+           SH600008    False  False  False  ...     False      False     False
+...                      ...    ...    ...  ...       ...        ...       ...
+2026-02-26 SZ301658    False  False  False  ...     False      False     False
+           SZ301662    False  False  False  ...     False      False     False
+           SZ301665    False  False  False  ...     False      False     False
+           SZ301678    False  False  False  ...     False      False     False
+           SZ302132    False  False  False  ...     False      False     False
+
+[6903684 rows x 12 columns]
+[2715583:MainThread](2026-02-26 20:12:06,759) INFO - qlib.timer - [log.py:117] - Time cost: 0.857s | Fetching dataframe Done
+[2715583:MainThread](2026-02-26 20:12:06,777) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,gds_CC10,gds_CC11,gds_CC12,gds_CC20,gds_CC21,gds_CC22,gds_CC23,gds_CC24,gds_CC25,gds_CC26,gds_CC27,gds_CC28,gds_CC30,gds_CC31,gds_CC32,gds_CC33,gds_CC34,gds_CC35,gds_CC36,gds_CC37,gds_CC40,gds_CC41,gds_CC42,gds_CC43,gds_CC50,gds_CC60,gds_CC61,gds_CC62,gds_CC63,gds_CC70 from 
+            loadTable("dfs://daily_stock_run", "stg_1day_gds_indus_flag_cc1")
+            where m_nDate>=2019.12.03 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','S
+[2715583:MainThread](2026-02-26 20:12:08,840) INFO - qlib.timer - [log.py:117] - Time cost: 2.073s | DDB query: Done
+[2715583:MainThread](2026-02-26 20:12:08,849) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2715583:MainThread](2026-02-26 20:13:26,572) INFO - qlib.timer - [log.py:117] - Time cost: 77.719s | Instruments filter: Done
+[2715583:MainThread](2026-02-26 20:13:26,601) INFO - qlib.timer - [log.py:117] - Time cost: 79.839s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler.DDBIndusFlagHandler object at 0x70e67060acc0>) Done
+[2715583:MainThread](2026-02-26 20:13:26,602) INFO - qlib.timer - [log.py:117] - Time cost: 79.840s | Init data (<qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler.DDBIndusFlagHandler object at 0x70e67060acc0>) Done
+[2715583:MainThread](2026-02-26 20:13:26,603) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2715583:MainThread](2026-02-26 20:13:26,612) INFO - qlib.timer - [log.py:117] - Time cost: 0.008s | fetch_df_by_index Done
+[2715583:MainThread](2026-02-26 20:13:26,633) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-03 00:00:00'), datetime.date(2026, 2, 26), None)
+                       gds_CC10  gds_CC11  ...  gds_CC63  gds_CC70
+datetime   instrument                      ...                    
+2026-02-09 SH600000       False     False  ...     False     False
+           SH600004       False     False  ...     False     False
+           SH600006       False     False  ...     False     False
+           SH600007       False     False  ...     False     False
+           SH600008       False     False  ...     False     False
+...                         ...       ...  ...       ...       ...
+2026-02-26 SZ301658       False     False  ...     False     False
+           SZ301662       False     False  ...     False     False
+           SZ301665       False     False  ...     False     False
+           SZ301678       False     False  ...     False     False
+           SZ302132       False     False  ...     False     False
+
+[41168 rows x 30 columns]
+[2715583:MainThread](2026-02-26 20:13:26,634) INFO - qlib.timer - [log.py:117] - Time cost: 0.031s | Fetching dataframe Done
+[2715583:MainThread](2026-02-26 20:13:26,652) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,ST_Y,ST_S,ST_T,ST_L,ST_Z,ST_X from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_st_flag")
+            where m_nDate>=2019.12.03 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657','SZ002
+[2715583:MainThread](2026-02-26 20:13:55,744) INFO - qlib.timer - [log.py:117] - Time cost: 29.102s | DDB query: Done
+[2715583:MainThread](2026-02-26 20:13:56,520) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2715583:MainThread](2026-02-26 20:15:27,625) INFO - qlib.timer - [log.py:117] - Time cost: 90.586s | Instruments filter: Done
+[2715583:MainThread](2026-02-26 20:15:28,257) INFO - qlib.timer - [log.py:117] - Time cost: 121.621s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_st_flag_handler.DDBStFlagHandler object at 0x70e88c9710d0>) Done
+[2715583:MainThread](2026-02-26 20:15:28,257) INFO - qlib.timer - [log.py:117] - Time cost: 121.622s | Init data (<qlib.contrib.data.ddb_handlers.ddb_st_flag_handler.DDBStFlagHandler object at 0x70e88c9710d0>) Done
+[2715583:MainThread](2026-02-26 20:15:28,258) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2715583:MainThread](2026-02-26 20:15:28,867) INFO - qlib.timer - [log.py:117] - Time cost: 0.608s | fetch_df_by_index Done
+[2715583:MainThread](2026-02-26 20:15:28,875) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-03 00:00:00'), datetime.date(2026, 2, 26), None)
+                        ST_Y   ST_S   ST_T   ST_L   ST_Z   ST_X
+datetime   instrument                                          
+2019-12-03 SH600000    False  False  False  False  False  False
+           SH600004    False  False  False  False  False  False
+           SH600006    False  False  False  False  False  False
+           SH600007    False  False  False  False  False  False
+           SH600008    False  False  False  False  False  False
+...                      ...    ...    ...    ...    ...    ...
+2026-02-26 SZ301658    False  False  False  False  False  False
+           SZ301662    False  False  False  False  False  False
+           SZ301665    False  False  False  False  False  False
+           SZ301678    False  False  False  False  False  False
+           SZ302132    False  False  False  False  False  False
+
+[6903687 rows x 6 columns]
+[2715583:MainThread](2026-02-26 20:15:28,876) INFO - qlib.timer - [log.py:117] - Time cost: 0.617s | Fetching dataframe Done
+/home/guofu/.venv/alpha2/lib/python3.12/site-packages/qlib/contrib/utils/paral.py:22: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.
+  group_list = [_df.resample("M", level="datetime")\
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x70e88bd2a000>
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x70e88bd2a000>
+Query config: 
+#concepts: 2;
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x70e88c9cf6e0>
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x70e88c9cf6e0>
+Field list: ['gds_CC10', 'gds_CC11', 'gds_CC12', 'gds_CC20', 'gds_CC21', 'gds_CC22', 'gds_CC23', 'gds_CC24', 'gds_CC25', 'gds_CC26', 'gds_CC27', 'gds_CC28', 'gds_CC30', 'gds_CC31', 'gds_CC32', 'gds_CC33', 'gds_CC34', 'gds_CC35', 'gds_CC36', 'gds_CC37', 'gds_CC40', 'gds_CC41', 'gds_CC42', 'gds_CC43', 'gds_CC50', 'gds_CC60', 'gds_CC61', 'gds_CC62', 'gds_CC63', 'gds_CC70']
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x70e6706082f0>
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x70e65fdafd40>
+[2715583:MainThread](2026-02-26 20:15:32,735) INFO - qlib.timer - [log.py:117] - Time cost: 3.858s | Concat index: Done
+[2715583:MainThread](2026-02-26 20:15:32,737) INFO - qlib.timer - [log.py:117] - Time cost: 0.001s | Sort index: Done
+[2715583:MainThread](2026-02-26 20:15:36,349) INFO - qlib.timer - [log.py:117] - Time cost: 3.611s | Creating SepDataFrame: Done
+[2715583:MainThread](2026-02-26 20:15:37,245) INFO - qlib.timer - [log.py:117] - Time cost: 1040.537s | Loading data (<qlib.contrib.data.agg_handler.AggHandler object at 0x70e88b12b3e0>) Done
+[2715583:MainThread](2026-02-26 20:15:37,246) INFO - qlib.AggHandler - [handler.py:468] - Read-only True
+[]
+[2715583:MainThread](2026-02-26 20:15:37,248) INFO - qlib.AggHandler - [handler.py:476] - Will copy all groups of data-frame.
+[2715583:MainThread](2026-02-26 20:15:37,265) INFO - qlib.AggHandler - [handler.py:468] - Read-only True
+[]
+[2715583:MainThread](2026-02-26 20:15:37,266) INFO - qlib.AggHandler - [handler.py:476] - Will copy all groups of data-frame.
+[2715583:MainThread](2026-02-26 20:15:37,277) INFO - qlib.AggHandler - [handler.py:468] - Read-only True
+[]
+[2715583:MainThread](2026-02-26 20:15:37,277) INFO - qlib.AggHandler - [handler.py:476] - Will copy all groups of data-frame.
+[2715583:MainThread](2026-02-26 20:15:37,293) INFO - qlib.timer - [log.py:117] - Time cost: 0.047s | fit & process data Done
+[2715583:MainThread](2026-02-26 20:15:37,294) INFO - qlib.timer - [log.py:117] - Time cost: 1040.587s | Init data (<qlib.contrib.data.agg_handler.AggHandler object at 0x70e88b12b3e0>) Done
+[2715583:MainThread](2026-02-26 20:15:37,963) INFO - qlib.DataHandlerLP - [handler.py:487] - Will apply processor <qlib.contrib.data.processor.common.Diff object at 0x70e88bf4af30>
+[2715583:MainThread](2026-02-26 20:15:40,135) INFO - qlib.timer - [log.py:117] - Time cost: 2.171s | Diff Done
+[2715583:MainThread](2026-02-26 20:15:40,136) INFO - qlib.DataHandlerLP - [handler.py:487] - Will apply processor <qlib.contrib.data.processor.flag.FlagMarketInjector object at 0x70e88cd8fd40>
+All processors are readonly
+All processors are readonly
+All processors are readonly
+Did load data from config: /home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/handler.yaml
+Did load norm from: /home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/proc_list.proc
+Will assign `feature_ext` with 
+                       turnover  ...  con_rating_strength_diff
+datetime   instrument            ...                          
+2026-02-09 SH600000      0.1837  ...                       0.0
+           SH600004      0.6948  ...                       0.0
+           SH600006      0.5542  ...                       0.0
+           SH600007      0.2057  ...                       0.0
+           SH600008      0.9809  ...                       0.0
+...                         ...  ...                       ...
+2026-02-26 SZ301658      6.0785  ...                       0.0
+           SZ301662     12.5950  ...                       0.0
+           SZ301665     14.0077  ...                       0.0
+           SZ301678      6.6518  ...                       0.0
+           SZ302132      1.3868  ...                       0.0
+
+[41085 rows x 8 columns]
+---
+  ERROR: Failed to load data from Qlib pipeline: Cannot convert non-finite values (NA or inf) to integer
diff --git a/stock_1d/d033/alpha158_beta/scripts/run2.log b/stock_1d/d033/alpha158_beta/scripts/run2.log
new file mode 100644
index 0000000..dd3e579
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/run2.log
@@ -0,0 +1,373 @@
+[2730312:MainThread](2026-02-26 21:28:33,675) INFO - qlib.Initialization - [config.py:413] - default_conf: client.
+[2730312:MainThread](2026-02-26 21:28:33,679) INFO - qlib.Initialization - [__init__.py:74] - qlib successfully initialized based on client settings.
+[2730312:MainThread](2026-02-26 21:28:33,680) INFO - qlib.Initialization - [__init__.py:76] - data_path={'__DEFAULT_FREQ': PosixPath('/data/qlib/default/data_ops/target')}
+================================================================================
+DUMP GOLD-STANDARD DATA FROM QLIB PIPELINE
+================================================================================
+Date Range: 2020-01-02 to 2020-01-10
+Output Directory: /home/guofu/Workspaces/alpha_lab/stock_1d/d033/alpha158_beta/data
+Qlib Dataset Path: /home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/
+
+Step 1: Loading data from Qlib pipeline...
+  Loading since_date=2020-01-02
+  Loading raw data from handler.yaml...
+Will use `placehorder_value` from module: qlib.contrib.data.config
+Will init handler object from config:
+{'data_handler_config': {'ddb_config': {'host': '192.168.1.146',
+                                        'password': '123456',
+                                        'port': 8848,
+                                        'username': 'admin'},
+                         'end_time': datetime.date(2026, 2, 26),
+                         'handler_list': [{'class': 'DDBAlpha158Handler',
+                                           'kwargs': {'col_set': 'feature',
+                                                      'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                        'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': 'alpha158',
+                                                                        'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                          {'class': 'DDBMarketExtHandler',
+                                           'kwargs': {'col_set': 'feature_ext',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['Turnover '
+                                                                                       'as '
+                                                                                       'turnover',
+                                                                                       'FreeTurnover '
+                                                                                       'as '
+                                                                                       'free_turnover',
+                                                                                       'log(MarketValue) '
+                                                                                       'as '
+                                                                                       'log_size'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['con_rating_strength'],
+                                                                        'table_name': 'stg_1day_gds_con_rating'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                          {'class': 'DDBMarketFlagHandler',
+                                           'kwargs': {'col_set': 'feature_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['IsZt',
+                                                                                       'IsDt',
+                                                                                       'IsN',
+                                                                                       'IsXD',
+                                                                                       'IsXR',
+                                                                                       'IsDR'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['open_limit',
+                                                                                       'close_limit',
+                                                                                       'low_limit',
+                                                                                       'open_stop',
+                                                                                       'close_stop',
+                                                                                       'high_stop'],
+                                                                        'table_name': 'stg_1day_wind_market_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                          {'class': 'DDBIndusFlagHandler',
+                                           'kwargs': {'col_set': 'indus_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': 'industry_code_cc.csv',
+                                                                        'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                          {'class': 'DDBStFlagHandler',
+                                           'kwargs': {'col_set': 'st_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['ST_Y',
+                                                                                       'ST_S',
+                                                                                       'ST_T',
+                                                                                       'ST_L',
+                                                                                       'ST_Z',
+                                                                                       'ST_X'],
+                                                                        'table_name': 'stg_1day_wind_st_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                         'instruments': 'csiallx',
+                         'start_time': Timestamp('2019-12-13 00:00:00')},
+ 'ddb_config': {'host': '192.168.1.146',
+                'password': '123456',
+                'port': 8848,
+                'username': 'admin'},
+ 'handler': {'class': 'AggHandler',
+             'kwargs': {'ddb_config': {'host': '192.168.1.146',
+                                       'password': '123456',
+                                       'port': 8848,
+                                       'username': 'admin'},
+                        'end_time': [2730312:MainThread](2026-02-26 21:28:33,704) INFO - qlib.AggHandler - [agg_handler.py:79] - Will use AggHandler
+[2730312:MainThread](2026-02-26 21:28:33,704) WARNING - qlib.DataLoaderDH - [agg_handler.py:191] - instruments[csiallx] is ignored
+[2730312:MainThread](2026-02-26 21:28:34,011) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,KMID,KLEN,KMID2,KUP,KUP2,KLOW,KLOW2,KSFT,KSFT2,OPEN0,HIGH0,LOW0,VWAP0,ROC5,ROC10,ROC20,ROC30,ROC60,MA5,MA10,MA20,MA30,MA60,STD5,STD10,STD20,STD30,STD60,BETA5,BETA10,BETA20,BETA30,BETA60,RSQR5,RSQR10,RSQR20,RSQR30,RSQR60,RESI5,RESI10,RESI20,RESI30,RESI60,MAX5,MAX10,MAX20,MAX30,MAX60,MIN5,MIN10,MIN20,MIN30,MIN60,QTLU5,QTLU10,QTLU20,QTLU30,QTLU60,QTLD5,QTLD10,QTLD20,QTLD30,QTLD60,RANK5,RANK10,RANK20,RANK30,RANK60,RSV5,RSV10,RSV20,RSV30,RSV60,IMAX5,IMAX
+[2730312:MainThread](2026-02-26 21:36:00,317) INFO - qlib.timer - [log.py:117] - Time cost: 446.602s | DDB query: Done
+[2730312:MainThread](2026-02-26 21:36:01,106) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+datetime.date(2026, 2, 26),
+                        'handler_list': [{'class': 'DDBAlpha158Handler',
+                                          'kwargs': {'col_set': 'feature',
+                                                     'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                       'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': 'alpha158',
+                                                                       'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                         {'class': 'DDBMarketExtHandler',
+                                          'kwargs': {'col_set': 'feature_ext',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': ['Turnover '
+                                                                                      'as '
+                                                                                      'turnover',
+                                                                                      'FreeTurnover '
+                                                                                      'as '
+                                                                                      'free_turnover',
+                                                                                      'log(MarketValue) '
+                                                                                      'as '
+                                                                                      'log_size'],
+                                                                       'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                      {'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': ['con_rating_strength'],
+                                                                       'table_name': 'stg_1day_gds_con_rating'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                         {'class': 'DDBMarketFlagHandler',
+                                          'kwargs': {'col_set': 'feature_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['IsZt',
+                                                                                      'IsDt',
+                                                                                      'IsN',
+                                                                                      'IsXD',
+                                                                                      'IsXR',
+                                                                                      'IsDR'],
+                                                                       'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                      {'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['open_limit',
+                                                                                      'close_limit',
+                                                                                      'low_limit',
+                                                                                      'open_stop',
+                                                                                      'close_stop',
+                                                                                      'high_stop'],
+                                                                       'table_name': 'stg_1day_wind_market_flag'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                         {'class': 'DDBIndusFlagHandler',
+                                          'kwargs': {'col_set': 'indus_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': 'industry_code_cc.csv',
+                                                                       'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                         {'class': 'DDBStFlagHandler',
+                                          'kwargs': {'col_set': 'st_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['ST_Y',
+                                                                                      'ST_S',
+                                                                                      'ST_T',
+                                                                                      'ST_L',
+                                                                                      'ST_Z',
+                                                                                      'ST_X'],
+                                                                       'table_name': 'stg_1day_wind_st_flag'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                        'instruments': 'csiallx',
+                        'start_time': Timestamp('2019-12-13 00:00:00')},
+             'module_path': 'qlib.contrib.data.agg_handler'},
+ 'load_end': datetime.date(2026, 2, 26),
+ 'load_start': Timestamp('2019-12-13 00:00:00'),
+ 'market': 'csiallx',
+ 'qlib_init': {'provider_uri': '/home/guofu/.qlib/data_ops/target',
+               'region': 'cn'}}
+Query config: 
+#alpha158: 1;
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x761f37e75a60>
+[2730312:MainThread](2026-02-26 21:38:13,636) INFO - qlib.timer - [log.py:117] - Time cost: 123.423s | Instruments filter: Done
+[2730312:MainThread](2026-02-26 21:38:20,733) INFO - qlib.timer - [log.py:117] - Time cost: 587.024s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_alpha158_handler.DDBAlpha158Handler object at 0x761f366b3bc0>) Done
+[2730312:MainThread](2026-02-26 21:38:20,734) INFO - qlib.timer - [log.py:117] - Time cost: 587.026s | Init data (<qlib.contrib.data.ddb_handlers.ddb_alpha158_handler.DDBAlpha158Handler object at 0x761f366b3bc0>) Done
+[2730312:MainThread](2026-02-26 21:38:20,736) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2730312:MainThread](2026-02-26 21:38:24,302) INFO - qlib.timer - [log.py:117] - Time cost: 3.564s | fetch_df_by_index Done
+[2730312:MainThread](2026-02-26 21:38:25,946) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-13 00:00:00'), datetime.date(2026, 2, 26), None)
+                           KMID      KLEN  ...   VSUMD30   VSUMD60
+datetime   instrument                      ...                    
+2019-12-13 SH600000    0.011686  0.015025  ... -0.011573  0.039735
+           SH600004    0.000000  0.009169  ... -0.146051  0.024757
+           SH600006   -0.004329  0.015152  ...  0.136883  0.024626
+           SH600007    0.005590  0.019005  ... -0.012912  0.017215
+           SH600008    0.012270  0.012270  ...  0.039878 -0.013888
+...                         ...       ...  ...       ...       ...
+2026-02-26 SZ301658   -0.017231  0.025231  ... -0.018706  0.003708
+           SZ301662    0.060584  0.087834  ... -0.014658 -0.014613
+           SZ301665   -0.012899  0.040541  ...  0.083229  0.055994
+           SZ301678    0.018182  0.027879  ... -0.054124  0.014202
+           SZ302132    0.001754  0.016416  ... -0.049558 -0.038667
+
+[6858048 rows x 158 columns]
+[2730312:MainThread](2026-02-26 21:38:25,947) INFO - qlib.timer - [log.py:117] - Time cost: 5.212s | Fetching dataframe Done
+[2730312:MainThread](2026-02-26 21:38:25,965) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,Turnover as turnover,FreeTurnover as free_turnover,log(MarketValue) as log_size from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_kline_adjusted")
+            where m_nDate>=2019.12.13 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ3
+[2730312:MainThread](2026-02-26 21:38:43,081) INFO - qlib.timer - [log.py:117] - Time cost: 17.127s | DDB query: Done
+[2730312:MainThread](2026-02-26 21:38:43,874) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2730312:MainThread](2026-02-26 21:38:44,458) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,con_rating_strength from 
+            loadTable("dfs://daily_stock_run", "stg_1day_gds_con_rating")
+            where m_nDate>=2019.12.13 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657','SZ002833','SH
+[2730312:MainThread](2026-02-26 21:38:55,720) INFO - qlib.timer - [log.py:117] - Time cost: 11.271s | DDB query: Done
+[2730312:MainThread](2026-02-26 21:38:56,586) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-25 00:00:00
+[2730312:MainThread](2026-02-26 21:40:21,007) INFO - qlib.timer - [log.py:117] - Time cost: 81.315s | Instruments filter: Done
+[2730312:MainThread](2026-02-26 21:40:21,576) INFO - qlib.timer - [log.py:117] - Time cost: 115.627s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_market_ext_handler.DDBMarketExtHandler object at 0x7620fb822930>) Done
+[2730312:MainThread](2026-02-26 21:40:21,576) INFO - qlib.timer - [log.py:117] - Time cost: 115.628s | Init data (<qlib.contrib.data.ddb_handlers.ddb_market_ext_handler.DDBMarketExtHandler object at 0x7620fb822930>) Done
+[2730312:MainThread](2026-02-26 21:40:21,577) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2730312:MainThread](2026-02-26 21:40:22,309) INFO - qlib.timer - [log.py:117] - Time cost: 0.731s | fetch_df_by_index Done
+[2730312:MainThread](2026-02-26 21:40:22,317) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-13 00:00:00'), datetime.date(2026, 2, 26), None)
+                       turnover  free_turnover   log_size  con_rating_strength
+datetime   instrument                                                         
+2019-12-13 SH600000      0.2118         0.3879  17.343685               0.7143
+           SH600004      0.7518         1.5357  15.099485               0.8214
+           SH600006      0.7827         1.9762  13.732129               1.0000
+           SH600007      0.1368         0.7071  14.409998               0.7500
+           SH600008      0.2152         0.3990  14.444757               0.7500
+...                         ...            ...        ...                  ...
+2026-02-26 SZ301658      6.0785         6.0785  11.788368                  NaN
+           SZ301662     12.5950        12.5950  12.681215                  NaN
+           SZ301665     14.0077        14.0077  11.719415                  NaN
+           SZ301678      6.6518         6.6518  12.799973                  NaN
+           SZ302132      1.3868         3.0296  15.359885                  NaN
+
+[7572626 rows x 4 columns]
+[2730312:MainThread](2026-02-26 21:40:22,318) INFO - qlib.timer - [log.py:117] - Time cost: 0.741s | Fetching dataframe Done
+[2730312:MainThread](2026-02-26 21:40:22,334) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,IsZt,IsDt,IsN,IsXD,IsXR,IsDR from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_kline_adjusted")
+            where m_nDate>=2019.12.13 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657',
+[2730312:MainThread](2026-02-26 21:40:43,075) INFO - qlib.timer - [log.py:117] - Time cost: 20.751s | DDB query: Done
+[2730312:MainThread](2026-02-26 21:40:43,889) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2730312:MainThread](2026-02-26 21:40:44,394) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,open_limit,close_limit,low_limit,open_stop,close_stop,high_stop from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_market_flag")
+            where m_nDate>=2019.12.13 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','
+[2730312:MainThread](2026-02-26 21:41:04,632) INFO - qlib.timer - [log.py:117] - Time cost: 20.246s | DDB query: Done
+[2730312:MainThread](2026-02-26 21:41:05,434) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2730312:MainThread](2026-02-26 21:42:33,029) INFO - qlib.timer - [log.py:117] - Time cost: 84.294s | Instruments filter: Done
+[2730312:MainThread](2026-02-26 21:42:34,049) INFO - qlib.timer - [log.py:117] - Time cost: 131.730s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_market_flag_handler.DDBMarketFlagHandler object at 0x761f37e74470>) Done
+[2730312:MainThread](2026-02-26 21:42:34,050) INFO - qlib.timer - [log.py:117] - Time cost: 131.731s | Init data (<qlib.contrib.data.ddb_handlers.ddb_market_flag_handler.DDBMarketFlagHandler object at 0x761f37e74470>) Done
+[2730312:MainThread](2026-02-26 21:42:34,051) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2730312:MainThread](2026-02-26 21:42:34,895) INFO - qlib.timer - [log.py:117] - Time cost: 0.843s | fetch_df_by_index Done
+[2730312:MainThread](2026-02-26 21:42:34,907) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-13 00:00:00'), datetime.date(2026, 2, 26), None)
+                        IsZt   IsDt    IsN  ... open_stop close_stop high_stop
+datetime   instrument                       ...                               
+2019-12-13 SH600000    False  False  False  ...     False      False     False
+           SH600004    False  False  False  ...     False      False     False
+           SH600006    False  False  False  ...     False      False     False
+           SH600007    False  False  False  ...     False      False     False
+           SH600008    False  False  False  ...     False      False     False
+...                      ...    ...    ...  ...       ...        ...       ...
+2026-02-26 SZ301658    False  False  False  ...     False      False     False
+           SZ301662    False  False  False  ...     False      False     False
+           SZ301665    False  False  False  ...     False      False     False
+           SZ301678    False  False  False  ...     False      False     False
+           SZ302132    False  False  False  ...     False      False     False
+
+[6874830 rows x 12 columns]
+[2730312:MainThread](2026-02-26 21:42:34,908) INFO - qlib.timer - [log.py:117] - Time cost: 0.857s | Fetching dataframe Done
+[2730312:MainThread](2026-02-26 21:42:34,927) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,gds_CC10,gds_CC11,gds_CC12,gds_CC20,gds_CC21,gds_CC22,gds_CC23,gds_CC24,gds_CC25,gds_CC26,gds_CC27,gds_CC28,gds_CC30,gds_CC31,gds_CC32,gds_CC33,gds_CC34,gds_CC35,gds_CC36,gds_CC37,gds_CC40,gds_CC41,gds_CC42,gds_CC43,gds_CC50,gds_CC60,gds_CC61,gds_CC62,gds_CC63,gds_CC70 from 
+            loadTable("dfs://daily_stock_run", "stg_1day_gds_indus_flag_cc1")
+            where m_nDate>=2019.12.13 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','S
+[2730312:MainThread](2026-02-26 21:42:36,986) INFO - qlib.timer - [log.py:117] - Time cost: 2.069s | DDB query: Done
+[2730312:MainThread](2026-02-26 21:42:36,996) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2730312:MainThread](2026-02-26 21:43:53,198) INFO - qlib.timer - [log.py:117] - Time cost: 76.199s | Instruments filter: Done
+[2730312:MainThread](2026-02-26 21:43:53,230) INFO - qlib.timer - [log.py:117] - Time cost: 78.318s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler.DDBIndusFlagHandler object at 0x761f381e1c40>) Done
+[2730312:MainThread](2026-02-26 21:43:53,231) INFO - qlib.timer - [log.py:117] - Time cost: 78.319s | Init data (<qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler.DDBIndusFlagHandler object at 0x761f381e1c40>) Done
+[2730312:MainThread](2026-02-26 21:43:53,231) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2730312:MainThread](2026-02-26 21:43:53,239) INFO - qlib.timer - [log.py:117] - Time cost: 0.007s | fetch_df_by_index Done
+[2730312:MainThread](2026-02-26 21:43:53,257) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-13 00:00:00'), datetime.date(2026, 2, 26), None)
+                       gds_CC10  gds_CC11  ...  gds_CC63  gds_CC70
+datetime   instrument                      ...                    
+2026-02-09 SH600000       False     False  ...     False     False
+           SH600004       False     False  ...     False     False
+           SH600006       False     False  ...     False     False
+           SH600007       False     False  ...     False     False
+           SH600008       False     False  ...     False     False
+...                         ...       ...  ...       ...       ...
+2026-02-26 SZ301658       False     False  ...     False     False
+           SZ301662       False     False  ...     False     False
+           SZ301665       False     False  ...     False     False
+           SZ301678       False     False  ...     False     False
+           SZ302132       False     False  ...     False     False
+
+[41168 rows x 30 columns]
+[2730312:MainThread](2026-02-26 21:43:53,258) INFO - qlib.timer - [log.py:117] - Time cost: 0.027s | Fetching dataframe Done
+[2730312:MainThread](2026-02-26 21:43:53,274) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,ST_Y,ST_S,ST_T,ST_L,ST_Z,ST_X from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_st_flag")
+            where m_nDate>=2019.12.13 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657','SZ002
+[2730312:MainThread](2026-02-26 21:44:44,876) INFO - qlib.timer - [log.py:117] - Time cost: 51.611s | DDB query: Done
+[2730312:MainThread](2026-02-26 21:44:45,602) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2730312:MainThread](2026-02-26 21:46:07,184) INFO - qlib.timer - [log.py:117] - Time cost: 81.056s | Instruments filter: Done
+[2730312:MainThread](2026-02-26 21:46:07,747) INFO - qlib.timer - [log.py:117] - Time cost: 134.487s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_st_flag_handler.DDBStFlagHandler object at 0x761f387b3080>) Done
+[2730312:MainThread](2026-02-26 21:46:07,748) INFO - qlib.timer - [log.py:117] - Time cost: 134.488s | Init data (<qlib.contrib.data.ddb_handlers.ddb_st_flag_handler.DDBStFlagHandler object at 0x761f387b3080>) Done
+[2730312:MainThread](2026-02-26 21:46:07,748) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2730312:MainThread](2026-02-26 21:46:08,349) INFO - qlib.timer - [log.py:117] - Time cost: 0.600s | fetch_df_by_index Done
+[2730312:MainThread](2026-02-26 21:46:08,358) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-12-13 00:00:00'), datetime.date(2026, 2, 26), None)
+                        ST_Y   ST_S   ST_T   ST_L   ST_Z   ST_X
+datetime   instrument                                          
+2019-12-13 SH600000    False  False  False  False  False  False
+           SH600004    False  False  False  False  False  False
+           SH600006    False  False  False  False  False  False
+           SH600007    False  False  False  False  False  False
+           SH600008    False  False  False  False  False  False
+...                      ...    ...    ...    ...    ...    ...
+2026-02-26 SZ301658    False  False  False  False  False  False
+           SZ301662    False  False  False  False  False  False
+           SZ301665    False  False  False  False  False  False
+           SZ301678    False  False  False  False  False  False
+           SZ302132    False  False  False  False  False  False
+
+[6874833 rows x 6 columns]
+[2730312:MainThread](2026-02-26 21:46:08,359) INFO - qlib.timer - [log.py:117] - Time cost: 0.610s | Fetching dataframe Done
+/home/guofu/.venv/alpha2/lib/python3.12/site-packages/qlib/contrib/utils/paral.py:22: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.
+  group_list = [_df.resample("M", level="datetime")\
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x76203dfa91f0>
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x76203dfa91f0>
+Query config: 
+#concepts: 2;
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x761f346e7aa0>
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x761f346e7aa0>
+Field list: ['gds_CC10', 'gds_CC11', 'gds_CC12', 'gds_CC20', 'gds_CC21', 'gds_CC22', 'gds_CC23', 'gds_CC24', 'gds_CC25', 'gds_CC26', 'gds_CC27', 'gds_CC28', 'gds_CC30', 'gds_CC31', 'gds_CC32', 'gds_CC33', 'gds_CC34', 'gds_CC35', 'gds_CC36', 'gds_CC37', 'gds_CC40', 'gds_CC41', 'gds_CC42', 'gds_CC43', 'gds_CC50', 'gds_CC60', 'gds_CC61', 'gds_CC62', 'gds_CC63', 'gds_CC70']
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x761cc3995760>
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x761a968d1d00>
+[2730312:MainThread](2026-02-26 21:46:11,623) INFO - qlib.timer - [log.py:117] - Time cost: 3.264s | Concat index: Done
+[2730312:MainThread](2026-02-26 21:46:11,625) INFO - qlib.timer - [log.py:117] - Time cost: 0.001s | Sort index: Done
+[2730312:MainThread](2026-02-26 21:46:15,058) INFO - qlib.timer - [log.py:117] - Time cost: 3.433s | Creating SepDataFrame: Done
+[2730312:MainThread](2026-02-26 21:46:15,928) INFO - qlib.timer - [log.py:117] - Time cost: 1062.224s | Loading data (<qlib.contrib.data.agg_handler.AggHandler object at 0x761f36612720>) Done
+[2730312:MainThread](2026-02-26 21:46:15,929) INFO - qlib.AggHandler - [handler.py:468] - Read-only True
+[]
+[2730312:MainThread](2026-02-26 21:46:15,931) INFO - qlib.AggHandler - [handler.py:476] - Will copy all groups of data-frame.
+[2730312:MainThread](2026-02-26 21:46:15,935) INFO - qlib.AggHandler - [handler.py:468] - Read-only True
+[]
+[2730312:MainThread](2026-02-26 21:46:15,936) INFO - qlib.AggHandler - [handler.py:476] - Will copy all groups of data-frame.
+[2730312:MainThread](2026-02-26 21:46:15,939) INFO - qlib.AggHandler - [handler.py:468] - Read-only True
+[]
+[2730312:MainThread](2026-02-26 21:46:15,940) INFO - qlib.AggHandler - [handler.py:476] - Will copy all groups of data-frame.
+[2730312:MainThread](2026-02-26 21:46:15,943) INFO - qlib.timer - [log.py:117] - Time cost: 0.014s | fit & process data Done
+[2730312:MainThread](2026-02-26 21:46:15,943) INFO - qlib.timer - [log.py:117] - Time cost: 1062.239s | Init data (<qlib.contrib.data.agg_handler.AggHandler object at 0x761f36612720>) Done
+All processors are readonly
+All processors are readonly
+All processors are readonly
+  ERROR: Failed to load data from Qlib pipeline: 'SepDataFrame' object has no attribute 'shape'
diff --git a/stock_1d/d033/alpha158_beta/scripts/run3.log b/stock_1d/d033/alpha158_beta/scripts/run3.log
new file mode 100644
index 0000000..0745991
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/run3.log
@@ -0,0 +1,373 @@
+[2734404:MainThread](2026-02-26 22:10:11,609) INFO - qlib.Initialization - [config.py:413] - default_conf: client.
+[2734404:MainThread](2026-02-26 22:10:11,613) INFO - qlib.Initialization - [__init__.py:74] - qlib successfully initialized based on client settings.
+[2734404:MainThread](2026-02-26 22:10:11,613) INFO - qlib.Initialization - [__init__.py:76] - data_path={'__DEFAULT_FREQ': PosixPath('/data/qlib/default/data_ops/target')}
+================================================================================
+DUMP GOLD-STANDARD DATA FROM QLIB PIPELINE
+================================================================================
+Date Range: 2020-01-02 to 2020-01-10
+Output Directory: /home/guofu/Workspaces/alpha_lab/stock_1d/d033/alpha158_beta/data
+Qlib Dataset Path: /home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/
+
+Step 1: Loading data from Qlib pipeline...
+  Loading since_date=2020-01-02
+  Loading data with handler (load_start=2019-12-13)...
+Will use `placehorder_value` from module: qlib.contrib.data.config
+Will init handler object from config:
+{'data_handler_config': {'ddb_config': {'host': '192.168.1.146',
+                                        'password': '123456',
+                                        'port': 8848,
+                                        'username': 'admin'},
+                         'end_time': datetime.date(2026, 2, 26),
+                         'handler_list': [{'class': 'DDBAlpha158Handler',
+                                           'kwargs': {'col_set': 'feature',
+                                                      'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                        'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': 'alpha158',
+                                                                        'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                          {'class': 'DDBMarketExtHandler',
+                                           'kwargs': {'col_set': 'feature_ext',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['Turnover '
+                                                                                       'as '
+                                                                                       'turnover',
+                                                                                       'FreeTurnover '
+                                                                                       'as '
+                                                                                       'free_turnover',
+                                                                                       'log(MarketValue) '
+                                                                                       'as '
+                                                                                       'log_size'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['con_rating_strength'],
+                                                                        'table_name': 'stg_1day_gds_con_rating'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                          {'class': 'DDBMarketFlagHandler',
+                                           'kwargs': {'col_set': 'feature_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['IsZt',
+                                                                                       'IsDt',
+                                                                                       'IsN',
+                                                                                       'IsXD',
+                                                                                       'IsXR',
+                                                                                       'IsDR'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['open_limit',
+                                                                                       'close_limit',
+                                                                                       'low_limit',
+                                                                                       'open_stop',
+                                                                                       'close_stop',
+                                                                                       'high_stop'],
+                                                                        'table_name': 'stg_1day_wind_market_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                          {'class': 'DDBIndusFlagHandler',
+                                           'kwargs': {'col_set': 'indus_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': 'industry_code_cc.csv',
+                                                                        'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                          {'class': 'DDBStFlagHandler',
+                                           'kwargs': {'col_set': 'st_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['ST_Y',
+                                                                                       'ST_S',
+                                                                                       'ST_T',
+                                                                                       'ST_L',
+                                                                                       'ST_Z',
+                                                                                       'ST_X'],
+                                                                        'table_name': 'stg_1day_wind_st_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                         'instruments': 'csiallx',
+                         'start_time': Timestamp('2019-11-23 00:00:00')},
+ 'ddb_config': {'host': '192.168.1.146',
+                'password': '123456',
+                'port': 8848,
+                'username': 'admin'},
+ 'handler': {'class': 'AggHandler',
+             'kwargs': {'ddb_config': {'host': '192.168.1.146',
+                                       'password': '123456',
+                                       'port': 8848,
+                                       'username': 'admin'},
+                        [2734404:MainThread](2026-02-26 22:10:11,634) INFO - qlib.AggHandler - [agg_handler.py:79] - Will use AggHandler
+[2734404:MainThread](2026-02-26 22:10:11,634) WARNING - qlib.DataLoaderDH - [agg_handler.py:191] - instruments[csiallx] is ignored
+[2734404:MainThread](2026-02-26 22:10:11,842) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,KMID,KLEN,KMID2,KUP,KUP2,KLOW,KLOW2,KSFT,KSFT2,OPEN0,HIGH0,LOW0,VWAP0,ROC5,ROC10,ROC20,ROC30,ROC60,MA5,MA10,MA20,MA30,MA60,STD5,STD10,STD20,STD30,STD60,BETA5,BETA10,BETA20,BETA30,BETA60,RSQR5,RSQR10,RSQR20,RSQR30,RSQR60,RESI5,RESI10,RESI20,RESI30,RESI60,MAX5,MAX10,MAX20,MAX30,MAX60,MIN5,MIN10,MIN20,MIN30,MIN60,QTLU5,QTLU10,QTLU20,QTLU30,QTLU60,QTLD5,QTLD10,QTLD20,QTLD30,QTLD60,RANK5,RANK10,RANK20,RANK30,RANK60,RSV5,RSV10,RSV20,RSV30,RSV60,IMAX5,IMAX
+[2734404:MainThread](2026-02-26 22:17:41,432) INFO - qlib.timer - [log.py:117] - Time cost: 449.788s | DDB query: Done
+[2734404:MainThread](2026-02-26 22:17:42,271) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+'end_time': datetime.date(2026, 2, 26),
+                        'handler_list': [{'class': 'DDBAlpha158Handler',
+                                          'kwargs': {'col_set': 'feature',
+                                                     'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                       'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': 'alpha158',
+                                                                       'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                         {'class': 'DDBMarketExtHandler',
+                                          'kwargs': {'col_set': 'feature_ext',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': ['Turnover '
+                                                                                      'as '
+                                                                                      'turnover',
+                                                                                      'FreeTurnover '
+                                                                                      'as '
+                                                                                      'free_turnover',
+                                                                                      'log(MarketValue) '
+                                                                                      'as '
+                                                                                      'log_size'],
+                                                                       'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                      {'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': ['con_rating_strength'],
+                                                                       'table_name': 'stg_1day_gds_con_rating'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                         {'class': 'DDBMarketFlagHandler',
+                                          'kwargs': {'col_set': 'feature_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['IsZt',
+                                                                                      'IsDt',
+                                                                                      'IsN',
+                                                                                      'IsXD',
+                                                                                      'IsXR',
+                                                                                      'IsDR'],
+                                                                       'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                      {'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['open_limit',
+                                                                                      'close_limit',
+                                                                                      'low_limit',
+                                                                                      'open_stop',
+                                                                                      'close_stop',
+                                                                                      'high_stop'],
+                                                                       'table_name': 'stg_1day_wind_market_flag'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                         {'class': 'DDBIndusFlagHandler',
+                                          'kwargs': {'col_set': 'indus_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': 'industry_code_cc.csv',
+                                                                       'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                         {'class': 'DDBStFlagHandler',
+                                          'kwargs': {'col_set': 'st_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['ST_Y',
+                                                                                      'ST_S',
+                                                                                      'ST_T',
+                                                                                      'ST_L',
+                                                                                      'ST_Z',
+                                                                                      'ST_X'],
+                                                                       'table_name': 'stg_1day_wind_st_flag'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                        'instruments': 'csiallx',
+                        'start_time': Timestamp('2019-11-23 00:00:00')},
+             'module_path': 'qlib.contrib.data.agg_handler'},
+ 'load_end': datetime.date(2026, 2, 26),
+ 'load_start': Timestamp('2019-11-23 00:00:00'),
+ 'market': 'csiallx',
+ 'qlib_init': {'provider_uri': '/home/guofu/.qlib/data_ops/target',
+               'region': 'cn'}}
+Query config: 
+#alpha158: 1;
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x71c5e04773e0>
+[2734404:MainThread](2026-02-26 22:19:46,550) INFO - qlib.timer - [log.py:117] - Time cost: 115.118s | Instruments filter: Done
+[2734404:MainThread](2026-02-26 22:19:53,556) INFO - qlib.timer - [log.py:117] - Time cost: 581.918s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_alpha158_handler.DDBAlpha158Handler object at 0x71c5e0475d60>) Done
+[2734404:MainThread](2026-02-26 22:19:53,557) INFO - qlib.timer - [log.py:117] - Time cost: 581.920s | Init data (<qlib.contrib.data.ddb_handlers.ddb_alpha158_handler.DDBAlpha158Handler object at 0x71c5e0475d60>) Done
+[2734404:MainThread](2026-02-26 22:19:53,560) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2734404:MainThread](2026-02-26 22:19:57,060) INFO - qlib.timer - [log.py:117] - Time cost: 3.499s | fetch_df_by_index Done
+[2734404:MainThread](2026-02-26 22:19:58,834) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-11-23 00:00:00'), datetime.date(2026, 2, 26), None)
+                           KMID      KLEN  ...   VSUMD30   VSUMD60
+datetime   instrument                      ...                    
+2019-11-25 SH600000    0.003325  0.011638  ... -0.238055 -0.010125
+           SH600004   -0.013806  0.030012  ... -0.017610  0.039195
+           SH600006    0.009238  0.016166  ... -0.034782 -0.014306
+           SH600007   -0.014749  0.018879  ... -0.032427  0.034279
+           SH600008    0.009259  0.024691  ... -0.063490  0.003978
+...                         ...       ...  ...       ...       ...
+2026-02-26 SZ301658   -0.017231  0.025231  ... -0.018706  0.003708
+           SZ301662    0.060584  0.087834  ... -0.014658 -0.014613
+           SZ301665   -0.012899  0.040541  ...  0.083229  0.055994
+           SZ301678    0.018182  0.027879  ... -0.054124  0.014202
+           SZ302132    0.001754  0.016416  ... -0.049558 -0.038667
+
+[6908346 rows x 158 columns]
+[2734404:MainThread](2026-02-26 22:19:58,835) INFO - qlib.timer - [log.py:117] - Time cost: 5.276s | Fetching dataframe Done
+[2734404:MainThread](2026-02-26 22:19:59,042) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,Turnover as turnover,FreeTurnover as free_turnover,log(MarketValue) as log_size from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_kline_adjusted")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ3
+[2734404:MainThread](2026-02-26 22:20:16,326) INFO - qlib.timer - [log.py:117] - Time cost: 17.485s | DDB query: Done
+[2734404:MainThread](2026-02-26 22:20:17,102) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2734404:MainThread](2026-02-26 22:20:17,676) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,con_rating_strength from 
+            loadTable("dfs://daily_stock_run", "stg_1day_gds_con_rating")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657','SZ002833','SH
+[2734404:MainThread](2026-02-26 22:20:29,343) INFO - qlib.timer - [log.py:117] - Time cost: 11.676s | DDB query: Done
+[2734404:MainThread](2026-02-26 22:20:30,245) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-25 00:00:00
+[2734404:MainThread](2026-02-26 22:21:55,033) INFO - qlib.timer - [log.py:117] - Time cost: 81.592s | Instruments filter: Done
+[2734404:MainThread](2026-02-26 22:21:55,586) INFO - qlib.timer - [log.py:117] - Time cost: 116.751s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_market_ext_handler.DDBMarketExtHandler object at 0x71c7a492c4d0>) Done
+[2734404:MainThread](2026-02-26 22:21:55,587) INFO - qlib.timer - [log.py:117] - Time cost: 116.752s | Init data (<qlib.contrib.data.ddb_handlers.ddb_market_ext_handler.DDBMarketExtHandler object at 0x71c7a492c4d0>) Done
+[2734404:MainThread](2026-02-26 22:21:55,588) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2734404:MainThread](2026-02-26 22:21:56,302) INFO - qlib.timer - [log.py:117] - Time cost: 0.713s | fetch_df_by_index Done
+[2734404:MainThread](2026-02-26 22:21:56,309) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-11-23 00:00:00'), datetime.date(2026, 2, 26), None)
+                       turnover  free_turnover   log_size  con_rating_strength
+datetime   instrument                                                         
+2019-11-25 SH600000      0.0895         0.1639  17.339552               0.8214
+           SH600004      0.9386         1.9173  15.039255               0.8125
+           SH600006      0.2566         0.6479  13.680836               1.0000
+           SH600007      0.1647         0.8513  14.335590               0.7500
+           SH600008      0.1813         0.3362  14.435625               0.6875
+...                         ...            ...        ...                  ...
+2026-02-26 SZ301658      6.0785         6.0785  11.788368                  NaN
+           SZ301662     12.5950        12.5950  12.681215                  NaN
+           SZ301665     14.0077        14.0077  11.719415                  NaN
+           SZ301678      6.6518         6.6518  12.799973                  NaN
+           SZ302132      1.3868         3.0296  15.359885                  NaN
+
+[7623242 rows x 4 columns]
+[2734404:MainThread](2026-02-26 22:21:56,310) INFO - qlib.timer - [log.py:117] - Time cost: 0.722s | Fetching dataframe Done
+[2734404:MainThread](2026-02-26 22:21:56,327) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,IsZt,IsDt,IsN,IsXD,IsXR,IsDR from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_kline_adjusted")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657',
+[2734404:MainThread](2026-02-26 22:22:17,215) INFO - qlib.timer - [log.py:117] - Time cost: 20.899s | DDB query: Done
+[2734404:MainThread](2026-02-26 22:22:17,952) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2734404:MainThread](2026-02-26 22:22:18,463) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,open_limit,close_limit,low_limit,open_stop,close_stop,high_stop from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_market_flag")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','
+[2734404:MainThread](2026-02-26 22:22:38,963) INFO - qlib.timer - [log.py:117] - Time cost: 20.509s | DDB query: Done
+[2734404:MainThread](2026-02-26 22:22:39,774) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2734404:MainThread](2026-02-26 22:24:07,744) INFO - qlib.timer - [log.py:117] - Time cost: 84.654s | Instruments filter: Done
+[2734404:MainThread](2026-02-26 22:24:08,702) INFO - qlib.timer - [log.py:117] - Time cost: 132.391s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_market_flag_handler.DDBMarketFlagHandler object at 0x71c5e0847cb0>) Done
+[2734404:MainThread](2026-02-26 22:24:08,703) INFO - qlib.timer - [log.py:117] - Time cost: 132.392s | Init data (<qlib.contrib.data.ddb_handlers.ddb_market_flag_handler.DDBMarketFlagHandler object at 0x71c5e0847cb0>) Done
+[2734404:MainThread](2026-02-26 22:24:08,704) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2734404:MainThread](2026-02-26 22:24:09,549) INFO - qlib.timer - [log.py:117] - Time cost: 0.844s | fetch_df_by_index Done
+[2734404:MainThread](2026-02-26 22:24:09,561) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-11-23 00:00:00'), datetime.date(2026, 2, 26), None)
+                        IsZt   IsDt    IsN  ... open_stop close_stop high_stop
+datetime   instrument                       ...                               
+2019-11-25 SH600000    False  False  False  ...     False      False     False
+           SH600004    False  False  False  ...     False      False     False
+           SH600006    False  False  False  ...     False      False     False
+           SH600007    False  False  False  ...     False      False     False
+           SH600008    False  False  False  ...     False      False     False
+...                      ...    ...    ...  ...       ...        ...       ...
+2026-02-26 SZ301658    False  False  False  ...     False      False     False
+           SZ301662    False  False  False  ...     False      False     False
+           SZ301665    False  False  False  ...     False      False     False
+           SZ301678    False  False  False  ...     False      False     False
+           SZ302132    False  False  False  ...     False      False     False
+
+[6925320 rows x 12 columns]
+[2734404:MainThread](2026-02-26 22:24:09,562) INFO - qlib.timer - [log.py:117] - Time cost: 0.858s | Fetching dataframe Done
+[2734404:MainThread](2026-02-26 22:24:09,760) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,gds_CC10,gds_CC11,gds_CC12,gds_CC20,gds_CC21,gds_CC22,gds_CC23,gds_CC24,gds_CC25,gds_CC26,gds_CC27,gds_CC28,gds_CC30,gds_CC31,gds_CC32,gds_CC33,gds_CC34,gds_CC35,gds_CC36,gds_CC37,gds_CC40,gds_CC41,gds_CC42,gds_CC43,gds_CC50,gds_CC60,gds_CC61,gds_CC62,gds_CC63,gds_CC70 from 
+            loadTable("dfs://daily_stock_run", "stg_1day_gds_indus_flag_cc1")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','S
+[2734404:MainThread](2026-02-26 22:24:11,809) INFO - qlib.timer - [log.py:117] - Time cost: 2.238s | DDB query: Done
+[2734404:MainThread](2026-02-26 22:24:11,822) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2734404:MainThread](2026-02-26 22:25:28,259) INFO - qlib.timer - [log.py:117] - Time cost: 76.433s | Instruments filter: Done
+[2734404:MainThread](2026-02-26 22:25:28,285) INFO - qlib.timer - [log.py:117] - Time cost: 78.720s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler.DDBIndusFlagHandler object at 0x71c139b2af60>) Done
+[2734404:MainThread](2026-02-26 22:25:28,285) INFO - qlib.timer - [log.py:117] - Time cost: 78.720s | Init data (<qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler.DDBIndusFlagHandler object at 0x71c139b2af60>) Done
+[2734404:MainThread](2026-02-26 22:25:28,286) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2734404:MainThread](2026-02-26 22:25:28,290) INFO - qlib.timer - [log.py:117] - Time cost: 0.003s | fetch_df_by_index Done
+[2734404:MainThread](2026-02-26 22:25:28,310) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-11-23 00:00:00'), datetime.date(2026, 2, 26), None)
+                       gds_CC10  gds_CC11  ...  gds_CC63  gds_CC70
+datetime   instrument                      ...                    
+2026-02-09 SH600000       False     False  ...     False     False
+           SH600004       False     False  ...     False     False
+           SH600006       False     False  ...     False     False
+           SH600007       False     False  ...     False     False
+           SH600008       False     False  ...     False     False
+...                         ...       ...  ...       ...       ...
+2026-02-26 SZ301658       False     False  ...     False     False
+           SZ301662       False     False  ...     False     False
+           SZ301665       False     False  ...     False     False
+           SZ301678       False     False  ...     False     False
+           SZ302132       False     False  ...     False     False
+
+[41168 rows x 30 columns]
+[2734404:MainThread](2026-02-26 22:25:28,311) INFO - qlib.timer - [log.py:117] - Time cost: 0.025s | Fetching dataframe Done
+[2734404:MainThread](2026-02-26 22:25:28,470) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,ST_Y,ST_S,ST_T,ST_L,ST_Z,ST_X from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_st_flag")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657','SZ002
+[2734404:MainThread](2026-02-26 22:25:58,108) INFO - qlib.timer - [log.py:117] - Time cost: 29.791s | DDB query: Done
+[2734404:MainThread](2026-02-26 22:25:58,818) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2734404:MainThread](2026-02-26 22:27:21,291) INFO - qlib.timer - [log.py:117] - Time cost: 81.957s | Instruments filter: Done
+[2734404:MainThread](2026-02-26 22:27:21,828) INFO - qlib.timer - [log.py:117] - Time cost: 113.516s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_st_flag_handler.DDBStFlagHandler object at 0x71c5e0981ca0>) Done
+[2734404:MainThread](2026-02-26 22:27:21,829) INFO - qlib.timer - [log.py:117] - Time cost: 113.517s | Init data (<qlib.contrib.data.ddb_handlers.ddb_st_flag_handler.DDBStFlagHandler object at 0x71c5e0981ca0>) Done
+[2734404:MainThread](2026-02-26 22:27:21,830) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2734404:MainThread](2026-02-26 22:27:22,439) INFO - qlib.timer - [log.py:117] - Time cost: 0.608s | fetch_df_by_index Done
+[2734404:MainThread](2026-02-26 22:27:22,448) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-11-23 00:00:00'), datetime.date(2026, 2, 26), None)
+                        ST_Y   ST_S   ST_T   ST_L   ST_Z   ST_X
+datetime   instrument                                          
+2019-11-25 SH600000    False  False  False  False  False  False
+           SH600004    False  False  False  False  False  False
+           SH600006    False  False  False  False  False  False
+           SH600007    False  False  False  False  False  False
+           SH600008    False  False  False  False  False  False
+...                      ...    ...    ...    ...    ...    ...
+2026-02-26 SZ301658    False  False  False  False  False  False
+           SZ301662    False  False  False  False  False  False
+           SZ301665    False  False  False  False  False  False
+           SZ301678    False  False  False  False  False  False
+           SZ302132    False  False  False  False  False  False
+
+[6925323 rows x 6 columns]
+[2734404:MainThread](2026-02-26 22:27:22,448) INFO - qlib.timer - [log.py:117] - Time cost: 0.618s | Fetching dataframe Done
+/home/guofu/.venv/alpha2/lib/python3.12/site-packages/qlib/contrib/utils/paral.py:22: FutureWarning: 'M' is deprecated and will be removed in a future version, please use 'ME' instead.
+  group_list = [_df.resample("M", level="datetime")\
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x71c5e4d5d940>
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x71c5e4d5d940>
+Query config: 
+#concepts: 2;
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x71c13b9b8b60>
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x71c13b9b8b60>
+Field list: ['gds_CC10', 'gds_CC11', 'gds_CC12', 'gds_CC20', 'gds_CC21', 'gds_CC22', 'gds_CC23', 'gds_CC24', 'gds_CC25', 'gds_CC26', 'gds_CC27', 'gds_CC28', 'gds_CC30', 'gds_CC31', 'gds_CC32', 'gds_CC33', 'gds_CC34', 'gds_CC35', 'gds_CC36', 'gds_CC37', 'gds_CC40', 'gds_CC41', 'gds_CC42', 'gds_CC43', 'gds_CC50', 'gds_CC60', 'gds_CC61', 'gds_CC62', 'gds_CC63', 'gds_CC70']
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x71c139b28aa0>
+Will use bool for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x71c5e07e8f20>
+[2734404:MainThread](2026-02-26 22:27:25,764) INFO - qlib.timer - [log.py:117] - Time cost: 3.315s | Concat index: Done
+[2734404:MainThread](2026-02-26 22:27:25,766) INFO - qlib.timer - [log.py:117] - Time cost: 0.001s | Sort index: Done
+[2734404:MainThread](2026-02-26 22:27:29,485) INFO - qlib.timer - [log.py:117] - Time cost: 3.718s | Creating SepDataFrame: Done
+[2734404:MainThread](2026-02-26 22:27:30,310) INFO - qlib.timer - [log.py:117] - Time cost: 1038.675s | Loading data (<qlib.contrib.data.agg_handler.AggHandler object at 0x71c5e17ec230>) Done
+[2734404:MainThread](2026-02-26 22:27:30,311) INFO - qlib.AggHandler - [handler.py:468] - Read-only True
+[]
+[2734404:MainThread](2026-02-26 22:27:30,313) INFO - qlib.AggHandler - [handler.py:476] - Will copy all groups of data-frame.
+[2734404:MainThread](2026-02-26 22:27:30,318) INFO - qlib.AggHandler - [handler.py:468] - Read-only True
+[]
+[2734404:MainThread](2026-02-26 22:27:30,319) INFO - qlib.AggHandler - [handler.py:476] - Will copy all groups of data-frame.
+[2734404:MainThread](2026-02-26 22:27:30,322) INFO - qlib.AggHandler - [handler.py:468] - Read-only True
+[]
+[2734404:MainThread](2026-02-26 22:27:30,323) INFO - qlib.AggHandler - [handler.py:476] - Will copy all groups of data-frame.
+[2734404:MainThread](2026-02-26 22:27:30,326) INFO - qlib.timer - [log.py:117] - Time cost: 0.015s | fit & process data Done
+[2734404:MainThread](2026-02-26 22:27:30,327) INFO - qlib.timer - [log.py:117] - Time cost: 1038.692s | Init data (<qlib.contrib.data.agg_handler.AggHandler object at 0x71c5e17ec230>) Done
+All processors are readonly
+All processors are readonly
+All processors are readonly
+  ERROR: Failed to load data from Qlib pipeline: 'SepDataFrame' object has no attribute 'shape'
diff --git a/stock_1d/d033/alpha158_beta/scripts/run4.log b/stock_1d/d033/alpha158_beta/scripts/run4.log
new file mode 100644
index 0000000..42eef2a
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/run4.log
@@ -0,0 +1,321 @@
+[2739486:MainThread](2026-02-26 22:59:30,849) INFO - qlib.Initialization - [config.py:413] - default_conf: client.
+[2739486:MainThread](2026-02-26 22:59:30,854) INFO - qlib.Initialization - [__init__.py:74] - qlib successfully initialized based on client settings.
+[2739486:MainThread](2026-02-26 22:59:30,855) INFO - qlib.Initialization - [__init__.py:76] - data_path={'__DEFAULT_FREQ': PosixPath('/data/qlib/default/data_ops/target')}
+================================================================================
+DUMP GOLD-STANDARD DATA FROM QLIB PIPELINE
+================================================================================
+Date Range: 2020-01-02 to 2020-01-10
+Output Directory: /home/guofu/Workspaces/alpha_lab/stock_1d/d033/alpha158_beta/data
+Qlib Dataset Path: /home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/
+
+Step 1: Loading data from Qlib pipeline...
+  Loading since_date=2020-01-02
+  Loading data with handler (load_start=2019-12-13)...
+Will use `placehorder_value` from module: qlib.contrib.data.config
+Will init handler object from config:
+{'data_handler_config': {'ddb_config': {'host': '192.168.1.146',
+                                        'password': '123456',
+                                        'port': 8848,
+                                        'username': 'admin'},
+                         'end_time': datetime.date(2026, 2, 26),
+                         'handler_list': [{'class': 'DDBAlpha158Handler',
+                                           'kwargs': {'col_set': 'feature',
+                                                      'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                        'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': 'alpha158',
+                                                                        'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                          {'class': 'DDBMarketExtHandler',
+                                           'kwargs': {'col_set': 'feature_ext',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['Turnover '
+                                                                                       'as '
+                                                                                       'turnover',
+                                                                                       'FreeTurnover '
+                                                                                       'as '
+                                                                                       'free_turnover',
+                                                                                       'log(MarketValue) '
+                                                                                       'as '
+                                                                                       'log_size'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['con_rating_strength'],
+                                                                        'table_name': 'stg_1day_gds_con_rating'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                          {'class': 'DDBMarketFlagHandler',
+                                           'kwargs': {'col_set': 'feature_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['IsZt',
+                                                                                       'IsDt',
+                                                                                       'IsN',
+                                                                                       'IsXD',
+                                                                                       'IsXR',
+                                                                                       'IsDR'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['open_limit',
+                                                                                       'close_limit',
+                                                                                       'low_limit',
+                                                                                       'open_stop',
+                                                                                       'close_stop',
+                                                                                       'high_stop'],
+                                                                        'table_name': 'stg_1day_wind_market_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                          {'class': 'DDBIndusFlagHandler',
+                                           'kwargs': {'col_set': 'indus_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': 'industry_code_cc.csv',
+                                                                        'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                          {'class': 'DDBStFlagHandler',
+                                           'kwargs': {'col_set': 'st_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['ST_Y',
+                                                                                       'ST_S',
+                                                                                       'ST_T',
+                                                                                       'ST_L',
+                                                                                       'ST_Z',
+                                                                                       'ST_X'],
+                                                                        'table_name': 'stg_1day_wind_st_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                         'instruments': 'csiallx',
+                         'start_time': Timestamp('2019-11-23 00:00:00')},
+ 'ddb_config': {'host': '192.168.1.146',
+                'password': '123456',
+                'port': 8848,
+                'username': 'admin'},
+ 'handler': {'class': 'AggHandler',
+             'kwargs': {'ddb_config': {'host': '192.168.1.146',
+                                       'password': '123456',
+                                       'port': 8848,
+                                       'username': 'admin'},
+                        [2739486:MainThread](2026-02-26 22:59:30,878) INFO - qlib.AggHandler - [agg_handler.py:79] - Will use AggHandler
+[2739486:MainThread](2026-02-26 22:59:30,878) WARNING - qlib.DataLoaderDH - [agg_handler.py:191] - instruments[csiallx] is ignored
+[2739486:MainThread](2026-02-26 22:59:30,938) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,KMID,KLEN,KMID2,KUP,KUP2,KLOW,KLOW2,KSFT,KSFT2,OPEN0,HIGH0,LOW0,VWAP0,ROC5,ROC10,ROC20,ROC30,ROC60,MA5,MA10,MA20,MA30,MA60,STD5,STD10,STD20,STD30,STD60,BETA5,BETA10,BETA20,BETA30,BETA60,RSQR5,RSQR10,RSQR20,RSQR30,RSQR60,RESI5,RESI10,RESI20,RESI30,RESI60,MAX5,MAX10,MAX20,MAX30,MAX60,MIN5,MIN10,MIN20,MIN30,MIN60,QTLU5,QTLU10,QTLU20,QTLU30,QTLU60,QTLD5,QTLD10,QTLD20,QTLD30,QTLD60,RANK5,RANK10,RANK20,RANK30,RANK60,RSV5,RSV10,RSV20,RSV30,RSV60,IMAX5,IMAX
+[2739486:MainThread](2026-02-26 23:07:16,353) INFO - qlib.timer - [log.py:117] - Time cost: 465.464s | DDB query: Done
+[2739486:MainThread](2026-02-26 23:07:17,149) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+'end_time': datetime.date(2026, 2, 26),
+                        'handler_list': [{'class': 'DDBAlpha158Handler',
+                                          'kwargs': {'col_set': 'feature',
+                                                     'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                       'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': 'alpha158',
+                                                                       'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                         {'class': 'DDBMarketExtHandler',
+                                          'kwargs': {'col_set': 'feature_ext',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': ['Turnover '
+                                                                                      'as '
+                                                                                      'turnover',
+                                                                                      'FreeTurnover '
+                                                                                      'as '
+                                                                                      'free_turnover',
+                                                                                      'log(MarketValue) '
+                                                                                      'as '
+                                                                                      'log_size'],
+                                                                       'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                      {'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'float32',
+                                                                       'field_list': ['con_rating_strength'],
+                                                                       'table_name': 'stg_1day_gds_con_rating'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                         {'class': 'DDBMarketFlagHandler',
+                                          'kwargs': {'col_set': 'feature_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['IsZt',
+                                                                                      'IsDt',
+                                                                                      'IsN',
+                                                                                      'IsXD',
+                                                                                      'IsXR',
+                                                                                      'IsDR'],
+                                                                       'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                      {'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['open_limit',
+                                                                                      'close_limit',
+                                                                                      'low_limit',
+                                                                                      'open_stop',
+                                                                                      'close_stop',
+                                                                                      'high_stop'],
+                                                                       'table_name': 'stg_1day_wind_market_flag'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                         {'class': 'DDBIndusFlagHandler',
+                                          'kwargs': {'col_set': 'indus_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': 'industry_code_cc.csv',
+                                                                       'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                         {'class': 'DDBStFlagHandler',
+                                          'kwargs': {'col_set': 'st_flag',
+                                                     'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                       'dtype': 'bool',
+                                                                       'field_list': ['ST_Y',
+                                                                                      'ST_S',
+                                                                                      'ST_T',
+                                                                                      'ST_L',
+                                                                                      'ST_Z',
+                                                                                      'ST_X'],
+                                                                       'table_name': 'stg_1day_wind_st_flag'}]},
+                                          'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                        'instruments': 'csiallx',
+                        'start_time': Timestamp('2019-11-23 00:00:00')},
+             'module_path': 'qlib.contrib.data.agg_handler'},
+ 'load_end': datetime.date(2026, 2, 26),
+ 'load_start': Timestamp('2019-11-23 00:00:00'),
+ 'market': 'csiallx',
+ 'qlib_init': {'provider_uri': '/home/guofu/.qlib/data_ops/target',
+               'region': 'cn'}}
+Query config: 
+#alpha158: 1;
+Will use float32 for <qlib.contrib.data.ddb_data_loader.DDBDataLoader object at 0x71847694be90>
+[2739486:MainThread](2026-02-26 23:09:19,001) INFO - qlib.timer - [log.py:117] - Time cost: 112.707s | Instruments filter: Done
+[2739486:MainThread](2026-02-26 23:09:26,016) INFO - qlib.timer - [log.py:117] - Time cost: 595.133s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_alpha158_handler.DDBAlpha158Handler object at 0x7184769a5fa0>) Done
+[2739486:MainThread](2026-02-26 23:09:26,017) INFO - qlib.timer - [log.py:117] - Time cost: 595.135s | Init data (<qlib.contrib.data.ddb_handlers.ddb_alpha158_handler.DDBAlpha158Handler object at 0x7184769a5fa0>) Done
+[2739486:MainThread](2026-02-26 23:09:26,019) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2739486:MainThread](2026-02-26 23:09:29,432) INFO - qlib.timer - [log.py:117] - Time cost: 3.412s | fetch_df_by_index Done
+[2739486:MainThread](2026-02-26 23:09:31,228) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-11-23 00:00:00'), datetime.date(2026, 2, 26), None)
+                           KMID      KLEN  ...   VSUMD30   VSUMD60
+datetime   instrument                      ...                    
+2019-11-25 SH600000    0.003325  0.011638  ... -0.238055 -0.010125
+           SH600004   -0.013806  0.030012  ... -0.017610  0.039195
+           SH600006    0.009238  0.016166  ... -0.034782 -0.014306
+           SH600007   -0.014749  0.018879  ... -0.032427  0.034279
+           SH600008    0.009259  0.024691  ... -0.063490  0.003978
+...                         ...       ...  ...       ...       ...
+2026-02-26 SZ301658   -0.017231  0.025231  ... -0.018706  0.003708
+           SZ301662    0.060584  0.087834  ... -0.014658 -0.014613
+           SZ301665   -0.012899  0.040541  ...  0.083229  0.055994
+           SZ301678    0.018182  0.027879  ... -0.054124  0.014202
+           SZ302132    0.001754  0.016416  ... -0.049558 -0.038667
+
+[6908346 rows x 158 columns]
+[2739486:MainThread](2026-02-26 23:09:31,229) INFO - qlib.timer - [log.py:117] - Time cost: 5.211s | Fetching dataframe Done
+[2739486:MainThread](2026-02-26 23:09:31,242) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,Turnover as turnover,FreeTurnover as free_turnover,log(MarketValue) as log_size from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_kline_adjusted")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ3
+[2739486:MainThread](2026-02-26 23:09:54,142) INFO - qlib.timer - [log.py:117] - Time cost: 22.909s | DDB query: Done
+[2739486:MainThread](2026-02-26 23:09:54,927) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2739486:MainThread](2026-02-26 23:09:55,507) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,con_rating_strength from 
+            loadTable("dfs://daily_stock_run", "stg_1day_gds_con_rating")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657','SZ002833','SH
+[2739486:MainThread](2026-02-26 23:10:10,691) INFO - qlib.timer - [log.py:117] - Time cost: 15.192s | DDB query: Done
+[2739486:MainThread](2026-02-26 23:10:11,588) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2739486:MainThread](2026-02-26 23:11:37,528) INFO - qlib.timer - [log.py:117] - Time cost: 82.525s | Instruments filter: Done
+[2739486:MainThread](2026-02-26 23:11:38,259) INFO - qlib.timer - [log.py:117] - Time cost: 127.029s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_market_ext_handler.DDBMarketExtHandler object at 0x7185777e3e90>) Done
+[2739486:MainThread](2026-02-26 23:11:38,260) INFO - qlib.timer - [log.py:117] - Time cost: 127.030s | Init data (<qlib.contrib.data.ddb_handlers.ddb_market_ext_handler.DDBMarketExtHandler object at 0x7185777e3e90>) Done
+[2739486:MainThread](2026-02-26 23:11:38,261) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2739486:MainThread](2026-02-26 23:11:39,000) INFO - qlib.timer - [log.py:117] - Time cost: 0.738s | fetch_df_by_index Done
+[2739486:MainThread](2026-02-26 23:11:39,009) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-11-23 00:00:00'), datetime.date(2026, 2, 26), None)
+                       turnover  free_turnover   log_size  con_rating_strength
+datetime   instrument                                                         
+2019-11-25 SH600000      0.0895         0.1639  17.339552               0.8214
+           SH600004      0.9386         1.9173  15.039255               0.8125
+           SH600006      0.2566         0.6479  13.680836               1.0000
+           SH600007      0.1647         0.8513  14.335590               0.7500
+           SH600008      0.1813         0.3362  14.435625               0.6875
+...                         ...            ...        ...                  ...
+2026-02-26 SZ301658      6.0785         6.0785  11.788368                  NaN
+           SZ301662     12.5950        12.5950  12.681215               1.0000
+           SZ301665     14.0077        14.0077  11.719415               1.0000
+           SZ301678      6.6518         6.6518  12.799973               0.7500
+           SZ302132      1.3868         3.0296  15.359885               0.8750
+
+[7623255 rows x 4 columns]
+[2739486:MainThread](2026-02-26 23:11:39,010) INFO - qlib.timer - [log.py:117] - Time cost: 0.749s | Fetching dataframe Done
+[2739486:MainThread](2026-02-26 23:11:39,191) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,IsZt,IsDt,IsN,IsXD,IsXR,IsDR from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_kline_adjusted")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657',
+[2739486:MainThread](2026-02-26 23:12:05,839) INFO - qlib.timer - [log.py:117] - Time cost: 26.825s | DDB query: Done
+[2739486:MainThread](2026-02-26 23:12:06,554) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2739486:MainThread](2026-02-26 23:12:07,075) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,open_limit,close_limit,low_limit,open_stop,close_stop,high_stop from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_market_flag")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','
+[2739486:MainThread](2026-02-26 23:12:32,695) INFO - qlib.timer - [log.py:117] - Time cost: 25.629s | DDB query: Done
+[2739486:MainThread](2026-02-26 23:12:33,566) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2739486:MainThread](2026-02-26 23:14:02,232) INFO - qlib.timer - [log.py:117] - Time cost: 85.158s | Instruments filter: Done
+[2739486:MainThread](2026-02-26 23:14:03,155) INFO - qlib.timer - [log.py:117] - Time cost: 144.143s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_market_flag_handler.DDBMarketFlagHandler object at 0x718478991880>) Done
+[2739486:MainThread](2026-02-26 23:14:03,156) INFO - qlib.timer - [log.py:117] - Time cost: 144.144s | Init data (<qlib.contrib.data.ddb_handlers.ddb_market_flag_handler.DDBMarketFlagHandler object at 0x718478991880>) Done
+[2739486:MainThread](2026-02-26 23:14:03,156) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2739486:MainThread](2026-02-26 23:14:04,046) INFO - qlib.timer - [log.py:117] - Time cost: 0.889s | fetch_df_by_index Done
+[2739486:MainThread](2026-02-26 23:14:04,060) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-11-23 00:00:00'), datetime.date(2026, 2, 26), None)
+                        IsZt   IsDt    IsN  ... open_stop close_stop high_stop
+datetime   instrument                       ...                               
+2019-11-25 SH600000    False  False  False  ...     False      False     False
+           SH600004    False  False  False  ...     False      False     False
+           SH600006    False  False  False  ...     False      False     False
+           SH600007    False  False  False  ...     False      False     False
+           SH600008    False  False  False  ...     False      False     False
+...                      ...    ...    ...  ...       ...        ...       ...
+2026-02-26 SZ301658    False  False  False  ...     False      False     False
+           SZ301662    False  False  False  ...     False      False     False
+           SZ301665    False  False  False  ...     False      False     False
+           SZ301678    False  False  False  ...     False      False     False
+           SZ302132    False  False  False  ...     False      False     False
+
+[6925320 rows x 12 columns]
+[2739486:MainThread](2026-02-26 23:14:04,061) INFO - qlib.timer - [log.py:117] - Time cost: 0.904s | Fetching dataframe Done
+[2739486:MainThread](2026-02-26 23:14:04,079) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,gds_CC10,gds_CC11,gds_CC12,gds_CC20,gds_CC21,gds_CC22,gds_CC23,gds_CC24,gds_CC25,gds_CC26,gds_CC27,gds_CC28,gds_CC30,gds_CC31,gds_CC32,gds_CC33,gds_CC34,gds_CC35,gds_CC36,gds_CC37,gds_CC40,gds_CC41,gds_CC42,gds_CC43,gds_CC50,gds_CC60,gds_CC61,gds_CC62,gds_CC63,gds_CC70 from 
+            loadTable("dfs://daily_stock_run", "stg_1day_gds_indus_flag_cc1")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','S
+[2739486:MainThread](2026-02-26 23:14:06,440) INFO - qlib.timer - [log.py:117] - Time cost: 2.370s | DDB query: Done
+[2739486:MainThread](2026-02-26 23:14:06,448) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
+[2739486:MainThread](2026-02-26 23:15:23,146) INFO - qlib.timer - [log.py:117] - Time cost: 76.695s | Instruments filter: Done
+[2739486:MainThread](2026-02-26 23:15:23,184) INFO - qlib.timer - [log.py:117] - Time cost: 79.120s | Loading data (<qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler.DDBIndusFlagHandler object at 0x7184782fa0c0>) Done
+[2739486:MainThread](2026-02-26 23:15:23,185) INFO - qlib.timer - [log.py:117] - Time cost: 79.121s | Init data (<qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler.DDBIndusFlagHandler object at 0x7184782fa0c0>) Done
+[2739486:MainThread](2026-02-26 23:15:23,186) INFO - qlib.timer - [log.py:117] - Time cost: 0.000s | fetch_df_by_cols Done
+[2739486:MainThread](2026-02-26 23:15:23,190) INFO - qlib.timer - [log.py:117] - Time cost: 0.003s | fetch_df_by_index Done
+[2739486:MainThread](2026-02-26 23:15:23,210) INFO - qlib.DataLoaderDH - [agg_handler.py:215] - Did fetch @slice(Timestamp('2019-11-23 00:00:00'), datetime.date(2026, 2, 26), None)
+                       gds_CC10  gds_CC11  ...  gds_CC63  gds_CC70
+datetime   instrument                      ...                    
+2026-02-09 SH600000       False     False  ...     False     False
+           SH600004       False     False  ...     False     False
+           SH600006       False     False  ...     False     False
+           SH600007       False     False  ...     False     False
+           SH600008       False     False  ...     False     False
+...                         ...       ...  ...       ...       ...
+2026-02-26 SZ301658       False     False  ...     False     False
+           SZ301662       False     False  ...     False     False
+           SZ301665       False     False  ...     False     False
+           SZ301678       False     False  ...     False     False
+           SZ302132       False     False  ...     False     False
+
+[41168 rows x 30 columns]
+[2739486:MainThread](2026-02-26 23:15:23,210) INFO - qlib.timer - [log.py:117] - Time cost: 0.025s | Fetching dataframe Done
+[2739486:MainThread](2026-02-26 23:15:23,226) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,ST_Y,ST_S,ST_T,ST_L,ST_Z,ST_X from 
+            loadTable("dfs://daily_stock_run", "stg_1day_wind_st_flag")
+            where m_nDate>=2019.11.23 and m_nDate<=2026.02.26 and code in ('SH600373','SZ300557','SZ000416','SZ002156','SH600500','SZ002123','SZ000610','SH601699','SH603336','SZ000663','SH600713','SZ300623','SZ002840','SH601881','SZ000632','SH600030','SZ002101','SH600633','SH603797','SZ300563','SZ002281','SZ000972','SH600077','SZ300657','SZ002
+[2739486:MainThread](2026-02-26 23:15:53,388) INFO - qlib.timer - [log.py:117] - Time cost: 30.171s | DDB query: Done
+[2739486:MainThread](2026-02-26 23:15:54,166) INFO - qlib.DDBDataLoader - [__init__.py:219] - The last time point: 2026-02-26 00:00:00
diff --git a/stock_1d/d033/alpha158_beta/scripts/run_simple.log b/stock_1d/d033/alpha158_beta/scripts/run_simple.log
new file mode 100644
index 0000000..c72ec48
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/run_simple.log
@@ -0,0 +1,104 @@
+[2745445:MainThread](2026-02-26 23:18:06,410) INFO - qlib.Initialization - [config.py:413] - default_conf: client.
+[2745445:MainThread](2026-02-26 23:18:06,414) INFO - qlib.Initialization - [__init__.py:74] - qlib successfully initialized based on client settings.
+[2745445:MainThread](2026-02-26 23:18:06,415) INFO - qlib.Initialization - [__init__.py:76] - data_path={'__DEFAULT_FREQ': PosixPath('/data/qlib/default/data_ops/target')}
+================================================================================
+DUMP GOLD-STANDARD RAW DATA FROM QLIB PIPELINE
+================================================================================
+Date Range: 2020-01-02 to 2020-01-10
+Output Directory: ../data/
+Qlib Dataset Path: /home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/
+
+Step 1: Loading raw data from Qlib pipeline...
+  Loading raw data from handler (load_start=2019-12-13)...
+Will use `placehorder_value` from module: qlib.contrib.data.config
+Will init handler object from config:
+{'data_handler_config': {'ddb_config': {'host': '192.168.1.146',
+                                        'password': '123456',
+                                        'port': 8848,
+                                        'username': 'admin'},
+                         'end_time': datetime.date(2026, 2, 26),
+                         'handler_list': [{'class': 'DDBAlpha158Handler',
+                                           'kwargs': {'col_set': 'feature',
+                                                      'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                        'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': 'alpha158',
+                                                                        'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                          {'class': 'DDBMarketExtHandler',
+                                           'kwargs': {'col_set': 'feature_ext',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['Turnover '
+                                                                                       'as '
+                                                                                       'turnover',
+                                                                                       'FreeTurnover '
+                                                                                       'as '
+                                                                                       'free_turnover',
+                                                                                       'log(MarketValue) '
+                                                                                       'as '
+                                                                                       'log_size'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['con_rating_strength'],
+                                                                        'table_name': 'stg_1day_gds_con_rating'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                          {'class': 'DDBMarketFlagHandler',
+                                           'kwargs': {'col_set': 'feature_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['IsZt',
+                                                                                       'IsDt',
+                                                                                       'IsN',
+                                                                                       'IsXD',
+                                                                                       'IsXR',
+                                                                                       'IsDR'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['open_limit',
+                                                                                       'close_limit',
+                                                                                       'low_limit',
+                                                                                       'open_stop',
+                                                                                       'close_stop',
+                                                                                       'high_stop'],
+                                                                        'table_name': 'stg_1day_wind_market_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                          {'class': 'DDBIndusFlagHandler',
+                                           'kwargs': {'col_set': 'indus_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': 'industry_code_cc.csv',
+                                                                        'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                          {'class': 'DDBStFlagHandler',
+                                           'kwargs': {'col_set': 'st_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['ST_Y',
+                                                                                       'ST_S',
+                                                                                       'ST_T',
+                                                                                       'ST_L',
+                                                                                       'ST_Z',
+                                                                                       'ST_X'],
+                                                                        'table_name': 'stg_1day_wind_st_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                         'instruments': 'csiallx',
+                         'start_time': Timestamp('2019-11-23 00:00:00')},
+ 'ddb_config': {'host': '192.168.1.146',
+                'password': '123456',
+                'port': 8848,
+                'username': 'admin'},
+ 'handler': {'class': 'AggHandler',
+             'kwargs': {'ddb_config': {'host': '192.168.1.146',
+                                       'password': '123456',
+                                       'port': 8848,
+                                       'username': 'admin'},
+                        'end_time': datetime.date(2026, 2, 26),
+                        'handler_list': [{[2745445:MainThread](2026-02-26 23:18:06,436) INFO - qlib.AggHandler - [agg_handler.py:79] - Will use AggHandler
+[2745445:MainThread](2026-02-26 23:18:06,437) WARNING - qlib.DataLoaderDH - [agg_handler.py:191] - instruments[csiallx] is ignored
+[2745445:MainThread](2026-02-26 23:18:06,492) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,KMID,KLEN,KMID2,KUP,KUP2,KLOW,KLOW2,KSFT,KSFT2,OPEN0,HIGH0,LOW0,VWAP0,ROC5,ROC10,ROC20,ROC30,ROC60,MA5,MA10,MA20,MA30,MA60,STD5,STD10,STD20,STD30,STD60,BETA5,BETA10,BETA20,BETA30,BETA60,RSQR5,RSQR10,RSQR20,RSQR30,RSQR60,RESI5,RESI10,RESI20,RESI30,RESI60,MAX5,MAX10,MAX20,MAX30,MAX60,MIN5,MIN10,MIN20,MIN30,MIN60,QTLU5,QTLU10,QTLU20,QTLU30,QTLU60,QTLD5,QTLD10,QTLD20,QTLD30,QTLD60,RANK5,RANK10,RANK20,RANK30,RANK60,RSV5,RSV10,RSV20,RSV30,RSV60,IMAX5,IMAX
diff --git a/stock_1d/d033/alpha158_beta/scripts/run_simple2.log b/stock_1d/d033/alpha158_beta/scripts/run_simple2.log
new file mode 100644
index 0000000..8a868fe
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/run_simple2.log
@@ -0,0 +1,103 @@
+[2746177:MainThread](2026-02-26 23:21:56,618) INFO - qlib.Initialization - [config.py:413] - default_conf: client.
+[2746177:MainThread](2026-02-26 23:21:56,622) INFO - qlib.Initialization - [__init__.py:74] - qlib successfully initialized based on client settings.
+[2746177:MainThread](2026-02-26 23:21:56,623) INFO - qlib.Initialization - [__init__.py:76] - data_path={'__DEFAULT_FREQ': PosixPath('/data/qlib/default/data_ops/target')}
+================================================================================
+DUMP GOLD-STANDARD RAW DATA FROM QLIB PIPELINE
+================================================================================
+Date Range: 2020-01-02 to 2020-01-10
+Output Directory: ../data/
+Qlib Dataset Path: /home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/
+
+Step 1: Loading raw data from Qlib pipeline...
+  Loading raw data from handler (load_start=2019-12-13)...
+  Filtering instruments: ['SH600000', 'SH600004', 'SH600006', 'SH600007', 'SH600008']... (5 total)
+Will use `placehorder_value` from module: qlib.contrib.data.config
+Will init handler object from config:
+{'data_handler_config': {'ddb_config': {'host': '192.168.1.146',
+                                        'password': '123456',
+                                        'port': 8848,
+                                        'username': 'admin'},
+                         'end_time': datetime.date(2026, 2, 26),
+                         'handler_list': [{'class': 'DDBAlpha158Handler',
+                                           'kwargs': {'col_set': 'feature',
+                                                      'query_config': [{'alpha158_config': 'alpha158_expr.csv',
+                                                                        'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': 'alpha158',
+                                                                        'table_name': 'stg_1day_wind_alpha158_0_7'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_alpha158_handler'},
+                                          {'class': 'DDBMarketExtHandler',
+                                           'kwargs': {'col_set': 'feature_ext',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['Turnover '
+                                                                                       'as '
+                                                                                       'turnover',
+                                                                                       'FreeTurnover '
+                                                                                       'as '
+                                                                                       'free_turnover',
+                                                                                       'log(MarketValue) '
+                                                                                       'as '
+                                                                                       'log_size'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'float32',
+                                                                        'field_list': ['con_rating_strength'],
+                                                                        'table_name': 'stg_1day_gds_con_rating'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_ext_handler'},
+                                          {'class': 'DDBMarketFlagHandler',
+                                           'kwargs': {'col_set': 'feature_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['IsZt',
+                                                                                       'IsDt',
+                                                                                       'IsN',
+                                                                                       'IsXD',
+                                                                                       'IsXR',
+                                                                                       'IsDR'],
+                                                                        'table_name': 'stg_1day_wind_kline_adjusted'},
+                                                                       {'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['open_limit',
+                                                                                       'close_limit',
+                                                                                       'low_limit',
+                                                                                       'open_stop',
+                                                                                       'close_stop',
+                                                                                       'high_stop'],
+                                                                        'table_name': 'stg_1day_wind_market_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_market_flag_handler'},
+                                          {'class': 'DDBIndusFlagHandler',
+                                           'kwargs': {'col_set': 'indus_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': 'industry_code_cc.csv',
+                                                                        'table_name': 'stg_1day_gds_indus_flag_cc1'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_indus_flag_handler'},
+                                          {'class': 'DDBStFlagHandler',
+                                           'kwargs': {'col_set': 'st_flag',
+                                                      'query_config': [{'db_path': 'dfs://daily_stock_run',
+                                                                        'dtype': 'bool',
+                                                                        'field_list': ['ST_Y',
+                                                                                       'ST_S',
+                                                                                       'ST_T',
+                                                                                       'ST_L',
+                                                                                       'ST_Z',
+                                                                                       'ST_X'],
+                                                                        'table_name': 'stg_1day_wind_st_flag'}]},
+                                           'module_path': 'qlib.contrib.data.ddb_handlers.ddb_st_flag_handler'}],
+                         'instruments': 'csiallx',
+                         'start_time': Timestamp('2019-11-23 00:00:00')},
+ 'ddb_config': {'host': '192.168.1.146',
+                'password': '123456',
+                'port': 8848,
+                'username': 'admin'},
+ 'handler': {'class': 'AggHandler',
+             'kwargs': {'ddb_config': {'host': '192.168.1.146',
+                                       'password': '123456',
+                                       'port': 8848,
+                                       'username': 'admin'}[2746177:MainThread](2026-02-26 23:21:56,647) INFO - qlib.AggHandler - [agg_handler.py:79] - Will use AggHandler
+[2746177:MainThread](2026-02-26 23:21:56,648) WARNING - qlib.DataLoaderDH - [agg_handler.py:191] - instruments[csiallx] is ignored
+[2746177:MainThread](2026-02-26 23:21:56,716) INFO - qlib.DDBDataLoader - [__init__.py:196] - Will use sql template on 192.168.1.146: 
+
+        use mytt;
+        select code,m_nDate,KMID,KLEN,KMID2,KUP,KUP2,KLOW,KLOW2,KSFT,KSFT2,OPEN0,HIGH0,LOW0,VWAP0,ROC5,ROC10,ROC20,ROC30,ROC60,MA5,MA10,MA20,MA30,MA60,STD5,STD10,STD20,STD30,STD60,BETA5,BETA10,BETA20,BETA30,BETA60,RSQR5,RSQR10,RSQR20,RSQR30,RSQR60,RESI5,RESI10,RESI20,RESI30,RESI60,MAX5,MAX10,MAX20,MAX30,MAX60,MIN5,MIN10,MIN20,MIN30,MIN60,QTLU5,QTLU10,QTLU20,QTLU30,QTLU60,QTLD5,QTLD10,QTLD20,QTLD30,QTLD60,RANK5,RANK10,RANK20,RANK30,RANK60,RSV5,RSV10,RSV20,RSV30,RSV60,IMAX5,IMAX
diff --git a/stock_1d/d033/alpha158_beta/scripts/verify_feature_order.py b/stock_1d/d033/alpha158_beta/scripts/verify_feature_order.py
new file mode 100644
index 0000000..d08a7b0
--- /dev/null
+++ b/stock_1d/d033/alpha158_beta/scripts/verify_feature_order.py
@@ -0,0 +1,187 @@
+#!/usr/bin/env python
+"""
+Verify feature column order between standalone pipeline and qlib gold standard.
+
+This script:
+1. Loads a small sample using the qlib pipeline
+2. Runs the same sample through the standalone generate_beta_embedding pipeline
+3. Compares the column order and feature values
+"""
+
+import pickle as pkl
+import ruamel.yaml as yaml
+import pandas as pd
+import polars as pl
+import numpy as np
+import sys
+import os
+
+# Patch yaml.safe_load for compatibility
+_yaml = yaml.YAML(typ='safe', pure=True)
+def patched_safe_load(stream):
+    import io
+    if isinstance(stream, str):
+        stream = io.StringIO(stream)
+    return _yaml.load(stream)
+yaml.safe_load = patched_safe_load
+
+# Add scripts directory to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'scripts'))
+
+def main():
+    print("=" * 70)
+    print("VERIFY FEATURE ORDER: Standalone vs Qlib Gold Standard")
+    print("=" * 70)
+
+    # Step 1: Load processor list
+    print("\nStep 1: Loading processor list...")
+    proc_path = "/home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/proc_list.proc"
+    with open(proc_path, "rb") as f:
+        proc_list = pkl.load(f)
+    print(f"  Loaded {len(proc_list)} processors")
+
+    # Step 2: Load small sample from qlib pipeline
+    print("\nStep 2: Loading sample from qlib pipeline...")
+
+    import qlib
+    from qlib.config import REG_CN
+    qlib.init(provider_uri='/home/guofu/.qlib/data_ops/target', region=REG_CN)
+
+    from qlib.workflow.cli import sys_config
+    from qlib.utils import fill_placeholder
+    import datetime as dt
+
+    yaml_path = "/home/guofu/Workspaces/alpha/data_ops/tasks/dwm_feature_vae/dataset/csiallx_feature2_ntrla_flag_pnlnorm/handler.yaml"
+    with open(yaml_path) as fin:
+        config = yaml.safe_load(fin)
+
+    sys_config(config, "qlib.contrib.data.config")
+    qlib.init(**config.get("qlib_init"))
+
+    load_start = pd.to_datetime("2020-01-02") - dt.timedelta(days=20)
+    placehorder_value = {
+        "<SINCE_DATE>": load_start,
+        "<TODAY>": dt.date.today()
+    }
+
+    config_filled = fill_placeholder(config, placehorder_value)
+    handler = qlib.init_instance_by_config(config_filled["handler"])
+    handler_data = handler._data
+
+    # Get data from SepDataFrame
+    if hasattr(handler_data, '_data'):
+        df_dict = handler_data._data
+        print(f"  Handler groups: {list(df_dict.keys())}")
+
+        # Concatenate groups
+        raw_dfs = []
+        for group, df in df_dict.items():
+            df_copy = df.copy()
+            df_copy.columns = [f"{group}::{col}" for col in df_copy.columns]
+            raw_dfs.append(df_copy)
+            print(f"    {group}: {len(df_copy.columns)} columns")
+
+        raw_df = pd.concat(raw_dfs, axis=1)
+        print(f"  Raw concatenated shape: {raw_df.shape}")
+
+    # Step 3: Apply processors to get gold standard features
+    print("\nStep 3: Applying processors (qlib gold standard)...")
+    from qlib.contrib.data.utils import apply_proc_list
+
+    # Strip group prefixes for processor application
+    col_mapping = {col: col.split('::', 1)[1] for col in raw_df.columns if '::' in col}
+    raw_df_stripped = raw_df.rename(columns=col_mapping)
+
+    # Convert bool to object for processor compatibility
+    bool_cols = raw_df_stripped.select_dtypes(include=['bool']).columns
+    for col in bool_cols:
+        raw_df_stripped[col] = raw_df_stripped[col].astype(object)
+
+    df_gold = apply_proc_list(raw_df_stripped, proc_list=proc_list, with_fit=False)
+    print(f"  Gold standard shape after processors: {df_gold.shape}")
+
+    # Restore group prefixes
+    reverse_mapping = {v: k for k, v in col_mapping.items()}
+    df_gold = df_gold.rename(columns=reverse_mapping)
+
+    # Get gold standard column order
+    gold_columns = list(df_gold.columns)
+    print(f"\nGold standard column groups:")
+
+    feature_cols = [c for c in gold_columns if c.startswith('feature::')]
+    feature_ext_cols = [c for c in gold_columns if c.startswith('feature_ext::')]
+    feature_flag_cols = [c for c in gold_columns if c.startswith('feature_flag::')]
+    indus_idx_cols = [c for c in gold_columns if c.startswith('indus_idx::')]
+
+    print(f"  feature:: {len(feature_cols)} cols")
+    print(f"  feature_ext:: {len(feature_ext_cols)} cols")
+    print(f"  feature_flag:: {len(feature_flag_cols)} cols")
+    print(f"  indus_idx:: {len(indus_idx_cols)} cols")
+
+    # Step 4: Now run standalone pipeline on same data
+    print("\nStep 4: Running standalone pipeline...")
+
+    # Load parquet data for same date range
+    from generate_beta_embedding import load_all_data, merge_data_sources, apply_feature_pipeline
+
+    df_alpha, df_kline, df_flag, df_industry = load_all_data("2020-01-02", "2020-01-10")
+    df_standalone = merge_data_sources(df_alpha, df_kline, df_flag, df_industry)
+
+    print(f"  Standalone loaded shape: {df_standalone.shape}")
+
+    # Apply feature pipeline
+    df_processed, feature_cols_standalone = apply_feature_pipeline(df_standalone)
+    print(f"  Standalone processed shape: {df_processed.shape}")
+    print(f"  Standalone feature columns: {len(feature_cols_standalone)}")
+
+    # Step 5: Compare column counts
+    print("\n" + "=" * 70)
+    print("COMPARISON SUMMARY")
+    print("=" * 70)
+
+    print(f"\nGold standard total columns: {len(gold_columns)}")
+    print(f"  feature:: {len(feature_cols)}")
+    print(f"  feature_ext:: {len(feature_ext_cols)}")
+    print(f"  feature_flag:: {len(feature_flag_cols)}")
+    print(f"  indus_idx:: {len(indus_idx_cols)}")
+
+    print(f"\nStandalone feature columns: {len(feature_cols_standalone)}")
+
+    # The gold standard columns (without prefix) should match standalone
+    gold_feature_cols = [c.split('::', 1)[1] for c in feature_cols]
+    gold_feature_ext_cols = [c.split('::', 1)[1] for c in feature_ext_cols]
+    gold_feature_flag_cols = [c.split('::', 1)[1] for c in feature_flag_cols]
+    gold_indus_idx_cols = [c.split('::', 1)[1] for c in indus_idx_cols]
+
+    gold_all = gold_feature_cols + gold_feature_ext_cols + gold_feature_flag_cols + gold_indus_idx_cols
+
+    print(f"\nGold standard (flat): {len(gold_all)} features")
+    print(f"Standalone: {len(feature_cols_standalone)} features")
+
+    if len(gold_all) != len(feature_cols_standalone):
+        print(f"\nWARNING: Feature count mismatch! Difference: {len(gold_all) - len(feature_cols_standalone)}")
+
+    # Check column order
+    print("\nFirst 20 column comparison:")
+    print(f"{'Idx':<5} {'Gold Standard':<40} {'Standalone':<40} {'Match':<6}")
+    print("-" * 90)
+    for i in range(min(20, len(gold_all), len(feature_cols_standalone))):
+        match = "✓" if gold_all[i] == feature_cols_standalone[i] else "✗"
+        print(f"{i:<5} {gold_all[i]:<40} {feature_cols_standalone[i]:<40} {match:<6}")
+
+    # Check if orders match
+    if gold_all == feature_cols_standalone:
+        print("\n✓ Column order MATCHES!")
+    else:
+        print("\n✗ Column order DOES NOT MATCH!")
+        print("\nFinding differences...")
+        diff_count = 0
+        for i in range(min(len(gold_all), len(feature_cols_standalone))):
+            if gold_all[i] != feature_cols_standalone[i]:
+                diff_count += 1
+                if diff_count <= 20:
+                    print(f"  [{i}] Gold: {gold_all[i]} vs Standalone: {feature_cols_standalone[i]}")
+        print(f"Total differences: {diff_count}")
+
+if __name__ == "__main__":
+    main()