{"id":"ff4d9c3c-2929-421f-aa0e-810f304ec5e5","arxiv_id":"2504.17356","paper_version":3,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":6,"one_line_summary":"HRLFS combines LLM semantic feature states with Gaussian mixture distributions and hierarchical multi-agent reinforcement learning to select feature subsets, reporting improved downstream performance and reduced agent count on tabular benchmarks.","lead":"This paper introduces HRLFS, a hierarchical reinforcement learning method that uses language-model descriptions and statistical summaries of columns to choose the best feature subset for machine learning. The authors report better accuracy and shorter runtime than one-agent-per-feature methods on most of 21 tabular datasets, but one result contradicts their claim of winning everywhere.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Efficiency claim is not established: the O(log N) proof assumes p=1/2 delegation, yet reported active-agent counts are linear-scale, and Section 5.9 does not validate p.","rationale":"The Reader identified Assumption 2 (p=1/2) and the inconsistency with Section 5.2 as the weakest assumption, and I agree: this is the single most load-bearing concern because the paper's central novelty claim is that HRLFS 'reduces the number of agents involved' with O(log N) complexity, which is the headline advance beyond one-agent-per-feature MARL. The proof of Theorem 3.3 is conditional on a probability that is neither enforced nor measured, and the arithmetic slip in equation (23) (unrolling gives log2(N+1)+1, not 2log2(N+1)+O(1)) further weakens the theoretical claim. The empirical evidence in Table 2 is not merely an absence of support but is positively inconsistent with the O(log N) bound: the remaining active-agent counts are far above any logarithmic curve and scale approximately linearly with N. One could argue the practical significance of HRLFS persists even with a weaker scaling claim, since Table 1 shows strong empirical performance and 35-55% runtime savings, but the strongest claim as written ('accelerating total run time by reducing the number of agents involved' and the explicit O(log N) statement) is overstated. I do not recommend REJECT because the empirical wins are substantial and the flaw is correctable by restating the complexity claim as empirical, not asymptotic, or by proving a bound under an empirically validated p. CONDITIONAL with revision requirements is the honest verdict: keep the acceptance conditional on either (a) demonstrating that the learned delegation probability is indeed near 1/2 (or that the O(log N) bound holds for the realized p), or (b) removing the O(log N) guarantee and replacing it with a measured-complexity claim. This matches the Reader's CONDITIONAL verdict; the same correction path resolves both of our concerns.","tokens_in":29478,"tokens_out":2209,"duration_ms":18328,"concrete_test":"Restore the Dropbox link, then instrument the released code to log for each of the 21 datasets: (i) the observed per-node delegation probability p averaged over episodes, and (ii) the per-iteration number of active agents as a function of N. Fit log(active) vs log(N): a slope near 0 supports O(log N); a slope near 1 supports O(N). Separately re-derive Eq. (19)-(20) to confirm the claimed closed form; the current unrolling yields E(N)=log2(N+1)+1 at p=1/2, which differs from Eq. (20). If p is far from 1/2 or the slope is near 1, revise the abstract and Section 3.5 to replace the unproven O(log N) guarantee with an empirical efficiency claim.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"Section 3.5's average-case result is the load-bearing support for the paper's headline efficiency advantage. Theorem 3.3 depends on Assumption 2, which fixes the learned delegation probability at p=1/2. That p is a property of the trained policy, not a design parameter; the proof does not derive it, and Section 5.9's reported balance-factor and height checks validate only Assumption 1 (tree shape), never Assumption 2. The experiments actually undercut the claim: OAPF active agents are 5616.46, 7613.45, 104.39, and 156.73 for SpamBase, Mice-Protein, Coil-20, and MNIST, and HRLFS reductions of 70.61%-82.30% imply remaining active agents of roughly 1652, 1348, 27, and 31 for the same datasets. For N=57, 77, 400, and 784, an O(log N) model predicts about 7-19 active agents, so the measured counts are orders of magnitude higher, growing roughly linearly in N. Moreover, the proof contains an arithmetic slip: the p=1/2 substitution gives E(N)=log2(N+1)+1, not E(N)=2log2(N+1)+O(1), so the stated form is internally inconsistent. Additionally, Section 3.4 claims the agent 'totally using 2N-1 agents to make log(N) decisions on N features,' but the active-agent definition and the runtime metric are distinct, and Table 2 converts a 70-82% reduction in active agents into only a 35-55% runtime reduction, showing runtime is not dominated by agent count as claimed. The efficiency claim is therefore not established by proof or experiment.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"This paper introduces HRLFS, a feature selection method that builds a hybrid state representation from GMM distributional features and LLM-based semantic embeddings, constructs a hierarchical clustering over features, and learns actor-critic policies for select/drop decisions at each tree node. The stated contributions are improved downstream performance relative to eight filter, embedded, deep-learning, and RL baselines on 21 tabular datasets, and an O(log N) average number of active agents compared with the O(N) one-agent-per-feature baseline. The paper also reports ablations on state representation, hierarchy granularity, clustering algorithm, policy backend, and hyperparameters.","tokens_in":29898,"tokens_out":9051,"duration_ms":81565,"significance":"The work addresses a real scalability bottleneck in RL-based feature selection, and the overall design is a plausible and potentially useful contribution: the evaluation covers diverse datasets, the ablations are informative, and the code and data are released. If the claims were fully supported, the hierarchy-plus-semantic-state architecture would be a meaningful step beyond one-agent-per-feature methods. However, the two headline claims are not established as stated: the universal performance superiority is contradicted by specific rows in Table 1, and the theoretical O(log N) efficiency result depends on an unvalidated assumption about the learned delegation probability, while the measured active-agent counts in Table 2 are more consistent with a constant-fraction-of-N behavior than with logarithmic scaling.","major_comments":[{"comment":"The claim that 'HRLFS outperforms the classical, deep learning-based, and RL-based methods on all tasks' is contradicted by Table 1. On Cao, RLAS achieves 90.57 while HRLFS achieves 89.37±0.13, and on Openml_637, RLAS achieves 42.04 while HRLFS achieves 40.54±0.37. In addition, baseline standard deviations are not reported, so several wins of less than one point (e.g., Credit_Default and Ionosphere) cannot be distinguished from noise. The performance claim should be restricted to the datasets where the advantage is statistically supported, and the authors should provide baseline error bars or significance tests.","section":"Section 5.1, Table 1"},{"comment":"The closed-form solution at p=1/2 is arithmetically incorrect. With E(1)=1 and E(N)=1+E(N/2), unrolling gives E(N)=log2(N+1)+1 for N=2^h−1. The displayed equality E(N)=log2(N+1)+1=2log2(N+1)+O(1) is false because the left- and right-hand sides differ by a term that grows logarithmically in N. The O(log N) conclusion survives the correction, but the theorem and the displayed equations must be fixed.","section":"Section 3.5, Eq. (20) and Eq. (23)"},{"comment":"The O(log N) average-case result holds only if each non-leaf agent delegates with fixed probability p=1/2. This probability is a property of the learned policy, not a design parameter, and Section 5.9 validates only Assumption 1 (balance factor and tree height), never Assumption 2. The measured active-agent counts in Table 2 (16.46 of 57, 13.45 of 77, 104.39 of 400, and 156.73 of 784) are roughly constant fractions of N (17–29%), not logarithmic; for these N values an O(log N) process with p=1/2 would activate about 7–19 agents. The authors should measure the empirical delegation probability or effective branching factor and either prove the expected active-agent count under the observed value or substantially weaken the complexity claim.","section":"Section 3.5, Assumption 2; Section 5.9; Table 2"},{"comment":"The paper states that the reduction in active agents 'directly translates' into time savings, but the reported runtime reductions (35.49–55.26%) are far smaller than the active-agent reductions (70.61–82.30%). This indicates that runtime is not dominated by agent count; downstream model evaluation and state construction likely dominate. The efficiency claim should be rephrased, and the definition of 'active agents' (per decision step versus cumulative over training) should be stated explicitly, since the current table mixes both readings.","section":"Section 5.2, Table 2"}],"minor_comments":[{"comment":"The numeric entries are run together: '5616.46' should likely be '57 16.46', '7613.45' should likely be '77 13.45', '400104.39' should likely be '400 104.39', and '784156.73' should likely be '784 156.73'. This makes the table hard to read and easy to misinterpret.","section":"Table 2"},{"comment":"The statement that the method 'totally using 2N−1 agents to make log(N) decisions on N features' conflates the total number of agents with the number of active agents per decision step; please rephrase to distinguish per-step active agents from the total agent population.","section":"Section 3.4"},{"comment":"Assumption 2 is introduced with p∈[0,1], but the theorem requires p=1/2; state explicitly that p=1/2 is an assumption that must be empirically validated, not a consequence of the framework.","section":"Section 3.5, Assumption 2"},{"comment":"The claim that GPT-4's 'data screening and cleaning criteria reduce errors and biases' is not tested by the model comparison and should be removed or supported with evidence.","section":"Section 5.5"},{"comment":"The notation mixes the dataset-level log-likelihood with per-feature parameters θ*_i; please define Θ_i explicitly before the EM step.","section":"Section 3.2, Eq. (2)"}],"recommendation":"major_revision","confidential_remarks":"The paper has a substantial empirical core and the main issues are correctable in revision: the performance claims need to be aligned with the table, the complexity proof needs a corrected closed form and an empirical check of the delegation probability, and the time-complexity discussion needs to separate agent counts from runtime. I do not see grounds for rejection, but the revised version should be re-reviewed."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things to know before reading. The genuinely new piece is the hybrid state extractor—GMM distribution parameters plus LLM semantic embeddings—used to cluster features into a hierarchical agent tree. That is a real departure from the flat one-agent-per-feature and simple-statistic grouping in MARLFS, AutoGFS, and AutoFS. The paper also does something rare: it runs an extensive empirical comparison across 21 datasets with multiple ablations. But the headline efficiency claim is not established.\n\nSection 3.5's O(log N) proof assumes each non-leaf agent delegates with fixed probability p=1/2—a property of the learned policy, not a design parameter—and Section 5.9 only validates tree balance (Assumption 1), never the delegation probability (Assumption 2). The algebra slip in Eq. 23 (log2(N+1)+1 claimed equal to 2log2(N+1)+O(1)) further undermines confidence in the theorem. More telling, the experiments are inconsistent with O(log N): Table 2's 70–82% active-agent reductions leave roughly 157 active agents for MNIST (N=784), about 20%, where O(log N) predicts around 10; the counts grow roughly linearly in N. Also, a 70–82% reduction in active agents translating to only 35–55% runtime reduction shows agent count is not the runtime bottleneck. This does not kill the method, but it kills the complexity claim as stated.\n\nOn performance: HRLFS wins on most datasets, and the ablations (hybrid vs GMM-only or LLM-only state, hierarchical vs one-agent-per-feature) are informative. But the abstract and Section 5.1 say 'outperforms on all tasks,' and Table 1's Cao row shows RLAS 90.57 vs HRLFS 89.37. Baseline error bars are absent, so many sub-1% leads are not statistically distinguishable. The code link is a Dropbox footnote with no resolvable URL—not reproducible as written.\n\nA serious referee should see this, because the core method is promising and the empirical evidence is broad. The revision should fix the proof, validate or abandon the p=1/2 assumption, report baseline variances, and temper the claims. Readers building RL-based feature selection or data-centric AI pipelines will get more from the state extraction idea than from the theorem.","headline":"Hybrid LLM/GMM state extraction for hierarchical RL feature selection is a real novelty, but the O(log N) efficiency proof and the 'all tasks' claim do not hold as written.","tokens_in":30431,"tokens_out":1968,"would_cite":true,"duration_ms":19903,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper proposes replacing one RL agent per feature with a hierarchy of agents that prune clusters, claiming better feature selection accuracy and average active-agent count O(log N) instead of O(N).","keywords":["feature selection","hierarchical reinforcement learning","multi-agent reinforcement learning","feature subspace exploration","large language models","Gaussian mixture models","tabular data","wrapper methods"],"falsifier":"Record the empirical delegation rate of trained non-leaf agents on a benchmark dataset. If the share of non-leaf agents that choose 'select' is consistently above $1/2$, the closed form $E(N) = ((2p)^{\\log_2(N+1)} - 1)/(2p - 1)$ predicts active-agent counts that grow toward linear in $N$; for MNIST's 784 features, the $p=1/2$ prediction is roughly $2\\log_2(785)\\approx 19$ active agents, whereas the paper reports 156.73, so a small logging change during exploration would settle whether the logarithmic bound is actually observed.","tokens_in":29272,"feed_emoji":"🤖","tokens_out":8447,"duration_ms":78306,"temperature":0.7,"pith_summary":"Feature selection for tabular machine learning usually means scanning hundreds or thousands of features one by one, and RL-based wrappers multiply that cost by assigning one agent to each feature. This paper proposes HRLFS, which first represents every feature by both a fitted Gaussian mixture model and a semantic embedding of its name or description, clusters the features into a tree, and places an RL agent at each cluster node. A node that says 'drop' prunes its entire subtree, so many features can be rejected in one decision; a node that says 'select' delegates to its children. The paper's central claim is that this hierarchical delegation improves downstream model performance on all 21 tested datasets while cutting the average number of active agents from O(N) to O(log N) under the proof's assumptions, with measured active-agent reductions of 70.61% to 82.30% and runtime reductions of 35.49% to 55.26% against one-agent-per-feature.","feed_headline":"Cluster-then-prune feature selection wins with 70-82% fewer agents","feed_subtitle":"Semantic plus statistical grouping lets each agent drop whole feature subtrees, beating per-feature RL on 21 datasets.","key_machinery":"The load-bearing object is the hierarchical agent tree over feature clusters, built by agglomerative clustering on hybrid feature states. The state of each feature is a vector combining GMM parameters (capturing the shape of the feature's distribution) with a semantic embedding from an LLM (capturing what the feature means), so clustering groups features that are both statistically and semantically similar. In the decision process, an internal node's 'drop' action deactivates all its descendants, which is the pruning mechanism that turns per-feature decisions into per-subspace decisions; the 'select' action recurses to children. The recurrence $E(N) = 1 + 2pE(N/2)$ for the expected number of active agents, with $p$ the probability that a non-leaf agent delegates, is what the efficiency proof manipulates to obtain $O(\\log N)$ at $p=1/2$.","core_discovery":"The discovery the paper argues for is that feature selection is best organized as hierarchical coarse-to-fine pruning rather than independent per-feature voting. The pipeline has three stages: comprehend, divide, conquer. Comprehend combines a Gaussian Mixture Model of each feature's value distribution with an LLM-produced semantic state from feature metadata; divide uses agglomerative clustering over those hybrid states to build a binary agent tree; conquer lets each internal agent choose between 'select' (delegate to children) and 'drop' (prune the whole subtree), with leaf agents deciding individual features. The paper claims that HRLFS outperforms filter, deep learning-based, and RL-based baselines on every task in its benchmark, and that the hierarchy's expected active agents follow $E(N)=1+2pE(N/2)$, giving $O(\\log N)$ when the delegation probability is $p=1/2$, in contrast to the $O(N)$ agents of one-agent-per-feature methods.","pith_inferences":["The paper's proof needs the delegation probability $p$ to be close to $1/2$, but it never reports measuring $p$ on trained agents; a direct measurement on the benchmark trees would turn the average-case complexity claim from a conditional result into an empirical one.","The observed active-agent counts, such as roughly 157 of 784 for MNIST, are far above the $2\\log_2(N+1)$ curve, so the measured savings may reflect cluster-level pruning rather than the logarithmic bound itself.","A natural extension is to use the same hybrid state and hierarchy for feature transformation or feature generation, where the search space is also exponential and semantic grouping could prune it.","Because the framework only needs tabular features and their names, it could slot into automated ML pipelines as a preprocessing layer, but the LLM embedding cost would need to be amortized across many downstream evaluations."],"forward_implications":["On the paper's 21 benchmark datasets, HRLFS is reported as the best-performing method across classification, multi-label classification, and regression tasks.","HRLFS is reported to cut active agents by 70.61% to 82.30% and runtime by 35.49% to 55.26% relative to one-agent-per-feature reinforcement learning.","If the $O(\\log N)$ average-case bound holds, high-dimensional tabular feature selection becomes practical at feature counts where per-feature agent architectures are prohibitive.","The hierarchy granularity is a tunable lever: finer hierarchies improve performance and lower variance but activate more agents.","The method transfers best to datasets whose column names or descriptions carry genuine meaning, because the semantic state is what lets the clustering recognize related features."],"supporting_citations":[{"why":"Defines the single-agent RL feature selection paradigm whose O(N) per-feature decisions HRLFS replaces.","marker":"[22]"},{"why":"The one-agent-per-feature multi-agent baseline that supplies the O(N) active-agent complexity HRLFS compares against.","marker":"[23]"},{"why":"Group-based agent architecture whose purely statistical feature grouping HRLFS extends by adding semantic states.","marker":"[25]"},{"why":"Interaction-wise agent architecture that motivates the cluster-level decision design.","marker":"[26]"},{"why":"Provides the hierarchical agglomerative clustering method used to construct the agent tree in Algorithm 1.","marker":"[32]"},{"why":"Supplies prioritized experience replay used for each agent's memory and optimization phase.","marker":"[33]"},{"why":"Supplies the actor-critic backend that defines the policy and value optimization for the hierarchical agents.","marker":"[34]"},{"why":"Provides the feature selection benchmark datasets used in the main comparison.","marker":"[36]"},{"why":"Supplies the text embedding model that produces the semantic feature states.","marker":"[50]"},{"why":"Supplies the large language model used to generate missing feature descriptions from metadata.","marker":"[51]"}],"fun_headline_variants":["Hierarchical RL prunes feature subtrees, cutting agents from N to log N","LLM-augmented clustering enables hierarchical feature selection with O(log N) agents","Coarse-to-fine agent tree drops whole feature groups, slashing RL agents","Semantic plus statistical states build hierarchical agents that prune subtrees","Multi-agent hierarchy for feature selection: fewer agents, better performance"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is Assumption 2 in Section 3.5: every non-leaf agent delegates to its children independently with a fixed probability $p = 1/2$; the paper treats this as a learned policy property and never measures it, so the average-case $O(\\log N)$ claim stands or falls with an unverified constant.","fun_headline_variants_meta":{"raw":{"variants":["Hierarchical RL prunes feature subtrees, cutting agents from N to log N","LLM-augmented clustering enables hierarchical feature selection with O(log N) agents","Coarse-to-fine agent tree drops whole feature groups, slashing RL agents","Semantic plus statistical states build hierarchical agents that prune subtrees","Multi-agent hierarchy for feature selection: fewer agents, better performance"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000245,"raw_usage":{"total_tokens":1540,"prompt_tokens":957,"completion_tokens":583,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":573,"completion_tokens_details":{"reasoning_tokens":485}},"tokens_in":573,"tokens_out":583,"duration_ms":5739,"temperature":1.0,"reasoning_tokens":485,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T10:42:36.156955+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Record the empirical delegation rate of trained non-leaf agents on a benchmark dataset. If the share of non-leaf agents that choose 'select' is consistently above $1/2$, the closed form $E(N) = ((2p)^{\\log_2(N+1)} - 1)/(2p - 1)$ predicts active-agent counts that grow toward linear in $N$; for MNIST's 784 features, the $p=1/2$ prediction is roughly $2\\log_2(785)\\approx 19$ active agents, whereas the paper reports 156.73, so a small logging change during exploration would settle whether the logarithmic bound is actually observed.","supporting_citations":[{"cited_title":"Efficient reinforced feature selection via early stopping traverse strategy,","cited_arxiv_id":null,"evidence_quote":"Defines the single-agent RL feature selection paradigm whose O(N) per-feature decisions HRLFS replaces."},{"cited_title":"Automating feature subspace exploration via multi-agent reinforcement learning,","cited_arxiv_id":null,"evidence_quote":"The one-agent-per-feature multi-agent baseline that supplies the O(N) active-agent complexity HRLFS compares against."},{"cited_title":"Autogfs: Automated group-based feature selection via interactive reinforcement learning,","cited_arxiv_id":null,"evidence_quote":"Group-based agent architecture whose purely statistical feature grouping HRLFS extends by adding semantic states."},{"cited_title":"Autofs: Automated feature selection via diversity-aware interactive reinforcement learning,","cited_arxiv_id":null,"evidence_quote":"Interaction-wise agent architecture that motivates the cluster-level decision design."},{"cited_title":"Hierarchical grouping to optimize an objective function,","cited_arxiv_id":null,"evidence_quote":"Provides the hierarchical agglomerative clustering method used to construct the agent tree in Algorithm 1."},{"cited_title":"A performance-driven benchmark for feature selection in tabular deep learning,","cited_arxiv_id":null,"evidence_quote":"Provides the feature selection benchmark datasets used in the main comparison."},{"cited_title":"New embedding models and api updates,","cited_arxiv_id":null,"evidence_quote":"Supplies the text embedding model that produces the semantic feature states."},{"cited_title":"Gpt-4 is openai’s most advanced system, producing safer and more useful responses,","cited_arxiv_id":null,"evidence_quote":"Supplies the large language model used to generate missing feature descriptions from metadata."}],"review_version":1}