main.py

# import json, datetime
# from config import *
# import pandas as pd
# import scipy.io as scio
# from modules.expression_pool import init_db, add_expr, top_exprs
# from agents.generator_agent import GeneratorAgent
# from agents.evaluator_agent import evaluate_expression
# from modules.utils import load_mat_as_numeric
# # prepare
# conn = init_db(DB_PATH)
# # df = pd.read_csv(DATASET_PATH)
# # df = scio.loadmat(DATASET_PATH)  # 读取数据文件
# X, y = load_mat_as_numeric(DATASET_PATH)
# X_df = pd.DataFrame(X)
# # print(df)
# # X_df = pd.DataFrame(df['X'])  # 读取训练数据
# # print(df['Y'])
# # y0 = pd.DataFrame(df['Y'])  # 读取标签
# # X_df = df.drop(columns=['label'])
# # y = y0.values
# # print("y type:", type(y), "dtype:", getattr(y, "dtype", None))
# # print("y example:", y[:10])


# # load seed
# with open(EXPR_SEED_PATH) as f:
#     seeds = json.load(f)
# # evaluate seeds first
# for s in seeds:
#     score, fvals, top_idx = evaluate_expression(s['expression'], X_df, y, TOP_K, CV_FOLDS)
#     add_expr(conn, s['expression'], score, s.get('explanation',''), str(s.get('complexity','')))

# # init generator
# gen = GeneratorAgent(MODEL_NAME)

# # iterative loop
# for it in range(ITERATIONS):
#     print("Iteration", it+1)
#     refs = top_exprs(conn, k=TOP_K)
#     # build prompt_text with refs + feature stats
#     # prompt = "Given top expressions: " + str(refs) + "\nGenerate expressions in format: Expression: ... Rationale: ..."
#     top_expressions = []  # List[(expr, score)]
#     top_expressions.append((refs, score))
#     top_expressions = sorted(
#         top_expressions,
#         key=lambda x: -x[1]
#     )[:5]
#     new_text = gen.generate_candidates(top_expressions)
#     for out in new_text:
#         # extract Expression line
#         expr_line = None
#         for line in out.splitlines():
#             if line.strip().lower().startswith("expression"):
#                 expr_line = line.split(":",1)[1].strip()
#                 break
#         if not expr_line: expr_line = out.strip()
#         score, fvals, top_idx = evaluate_expression(expr_line, X_df, y, TOP_K, CV_FOLDS)
#         add_expr(conn, expr_line, score, out, "")
#         print(f"Candidate {expr_line} -> score {score:.4f}")



# results = []

# for expr in EXPRESSIONS:
#     exec_out = executor.run(expr, X, y)
#     analysis = analyzer.analyze(expr, exec_out["cv_score"])

#     results.append({
#         "expression": expr,
#         "score": exec_out["cv_score"],
#         "analysis": analysis
#     })

# ranking = judge.rank(results)
#-----------------------------------------------------------------------2.0---------------

# from agents.analyzer_agent import AnalyzerAgent

# MODEL_PATH = "/data1/fangsensen/deepseek-math-7b-rl"

# agent = AnalyzerAgent(
#     name="AnalyzerAgent",
#     model_path=MODEL_PATH
# )

# expressions = [
#     "I(X;Y)",
#     "I(X;Y|Z)",
#     "I(X;Y) - I(X;Z)",
#     "I(X;Y|Z) - I(X;Y)",
#     "I(X;Y;Z)"
# ]
# # expressions = [
# #     "I(X;Y|Z) - I(X;Y)",
# # ]
# for expr in expressions:
#     print("=" * 80)
#     result = agent.analyze_expression(expr)
#     print(result)
#-----------------------------------------------------------------------路由---------------
import numpy as np
from agents.router_agent import FSRouterAgent

import scipy.io as scio
import pandas as pd
from sklearn.preprocessing import LabelEncoder

def load_mat_dataset(
    file_path,
    feature_keys=("X", "data", "fea"),
    label_keys=("Y", "y", "label"),
):
    """
    通用 .mat 数据集读取函数（FSExecutor / Agent 兼容）

    Parameters
    ----------
    file_path : str
        .mat 文件路径
    feature_keys : tuple
        特征矩阵可能的 key
    label_keys : tuple
        标签可能的 key

    Returns
    -------
    X : np.ndarray, shape (n_samples, n_features)
    y : np.ndarray, shape (n_samples,)
    meta : dict
        元信息（类别数、样本数等）
    """

    data = scio.loadmat(file_path)

    # ---------- 1. 读取 X ----------
    X = None
    for key in feature_keys:
        if key in data:
            X = data[key]
            break
    if X is None:
        raise KeyError(f"Cannot find feature matrix in {file_path}")

    X = np.asarray(X)

    if X.dtype == object:
        X = np.array(
            [[float(v[0]) if isinstance(v, (list, np.ndarray)) else float(v)
            for v in row]
            for row in X]
        )
    else:
        X = X.astype(float)


    # ---------- 2. 读取 y ----------
    y = None
    for key in label_keys:
        if key in data:
            y = data[key]
            break
    if y is None:
        raise KeyError(f"Cannot find label vector in {file_path}")

    # y 常见是 (n,1)
    y = np.asarray(y).reshape(-1)

    # ---------- 3. 标签清洗 & 编码 ----------
    # 处理 object / string / 混合类型
    if y.dtype == object:
        y = pd.Series(y).apply(lambda x: x[0] if isinstance(x, (list, np.ndarray)) else x)

    label_encoder = LabelEncoder()
    y = label_encoder.fit_transform(y)

    # ---------- 4. 元信息 ----------
    meta = {
        "n_samples": X.shape[0],
        "n_features": X.shape[1],
        "n_classes": len(np.unique(y)),
        "classes": np.unique(y),
        "label_encoder": label_encoder,
    }

    return X, y, meta

base_url = "/home/fangsensen/AutoFS/data/"
datanames = ['dna','Factors','madelon','Movement_libras','Musk1','spambase','splice','Synthetic_control',  'Waveform','Wdbc',]
# dataname = 'Authorship'
def main(dataname):
    X, y, meta = load_mat_dataset(
    base_url + dataname + ".mat"
)
    # X = data.data
    # y = data.target
    #

    task = {
        "X": X,
        "y": y,
        "algorithms": ["JMIM","CFR","DCSF","IWFS","MRI","MRMD","UCRFS","CSMDCCMR",],
        "n_selected_features": 5,
        "class_specific": False,
        "classifiers": ["nb", "svm", "rf"],
        "cv": 10,
        "random_state": 19,
        "params":{"n_selected_features":15,},
        "dataname":dataname,
    }


    router = FSRouterAgent()
    leaderboard = router.run(task)
    
    for rank, res in enumerate(leaderboard, 1):
        print(f"Rank {rank}: {res}")
    return leaderboard

if __name__ == "__main__":
    for dataname in datanames:
        main(dataname)




# {'selected_features': [59, 50, 56, 4, 38, 9, 29, 23, 0, 20, 34, 36, 24, 26, 28], 
#  'num_features': 15, 
#  'metrics': {'nb': {'f1': 0.9181133571145461, 'auc': 0.9807805770573524}, 
#              'svm': {'f1': 0.9282600079270711, 'auc': 0.980695564275392}, 
#              'rf': {'f1': 0.9219976218787156, 'auc': 0.9768411621948705}}, 
#  'time': 7.378173112869263, 
#  'algorithm': 'JMIM'}, 


# {'selected_features': [59, 50, 56, 4, 38, 0, 9, 29, 23, 20, 36, 34, 24, 28, 26], 
#  'num_features': 15, 
#  'metrics': {'nb': {'f1': 0.9163694015061433, 'auc': 0.9805189493459717}, 
#              'svm': {'f1': 0.9265953230281413, 'auc': 0.98064247666047}, 
#              'rf': {'f1': 0.9189853349187476, 'auc': 0.9769441217042379}}, 
#  'time': 2.0774385929107666, 
#  'algorithm': 'CFR'}