如何将条件动作语句输入前馈神经网络并生成决策树？能否用强化学习实现？

Great question—let’s break this down into two clear parts: getting your conditional-action statements into a feedforward neural network (FFNN) effectively, and using reinforcement learning (RL) to turn the network’s outputs into decision trees.

Formatting Conditional-Action Statements for FFNN #

Word2Vec is a valid option for capturing semantic meaning, but it’s not the most efficient fit here. Your statements have strict logical structure (condition → action) with explicit variables, operators, thresholds, and actionable commands—pure word vectors would blur these distinct components, making it harder for the FFNN to learn the precise mappings needed for decision tree generation.

Instead, structured feature engineering is better. Here’s how to implement it:

• Split each statement into two core segments: the condition clause and the action clause.
• For the condition clause:
  • Encode the target variable (e.g., airthrusthold → assign a unique integer ID, or one-hot encode if you have a fixed set of variables).
  • Encode comparison operators (e.g., > = 2, < = 1, == = 3—use a consistent mapping for all operators).
  • Normalize threshold values (e.g., 90 → scale to 0.9 if your variable’s range is 0-100, so values stay within [0,1]).
• For the action clause:
  • Encode action types (e.g., power up engine = 1, rotate shaft = 2).
  • Normalize any numeric parameters (e.g., 5 degree → scale to 0.05 if your shaft rotation max is 100 degrees).

Example Input Vector #

For your statement:
if airthrusthold > 90, power up the engine else rotate shaft 5 degree wide

The structured input vector might look like:

[1, 2, 0.9, 1, 0, 2, 0.05]

(Where: 1=airthrusthold, 2=>, 0.9=normalized threshold, 1=power up engine, 0=no param for this action, 2=rotate shaft, 0.05=normalized rotation degree)

If you have rare variables/actions, you can pair this structured encoding with learned embeddings (like Word2Vec) for variable/action names—this combines semantic understanding for edge cases with precise logical structure for core components.

Generating Decision Trees from FFNN Outputs via Reinforcement Learning #

Absolutely! This can be framed as a sequential decision-making task where the RL agent builds the decision tree step-by-step. Here’s a practical approach:

1. Define RL Problem Components #

• State: Combine two pieces of data:
  • The FFNN’s output vector (which distills the key logic of the input conditional-action statement).
  • The current state of the partially built tree (e.g., depth, number of split/leaf nodes, parameters of recent splits—encode this as a fixed-length vector).
• Action Space: All possible steps to construct the tree:
  • Select a variable to split on.
  • Choose a comparison operator and threshold for the split.
  • Assign an action to a leaf node.
• Reward Function: Design rewards to encourage accurate, concise trees:
  • High positive reward if the generated tree exactly replicates the input statement’s logic (test with sample inputs to verify outputs match).
  • Small positive reward for shorter trees (to avoid overcomplication).
  • Negative reward for invalid tree structures or incorrect outputs.

2. Choose an RL Algorithm #

• DQN (Deep Q-Network): Works well if your action space is discrete (which it likely is, with fixed variables/operators/actions). It’s great for learning optimal action selections in sequential tasks.
• PPO (Proximal Policy Optimization): A stable choice for larger or more complex action spaces—handles continuous parameters (like threshold values) smoothly.

3. Implementation Workflow #

1. First, train your FFNN to map structured conditional-action inputs to a meaningful latent space. This compresses the statement’s logic into a vector the RL agent can use.
2. Train the RL agent to incrementally build the decision tree:
   • Start with an empty root node.
   • At each step, the agent selects an action (split node or assign leaf action) based on the current state (FFNN output + partial tree state).
   • Once the tree is complete, evaluate it against the input statement’s logic to compute the reward.
   • Use the reward to update the agent’s policy, so it learns to build better trees over time.

Key Tips #

• Tree State Encoding: Keep the partial tree representation simple—for example, track the depth of the current node, the parent node’s split parameters, and how many branches are pending.
• Training Data: Use a dataset of conditional-action statements to train both the FFNN and RL agent. You can also generate synthetic data from existing decision trees to bootstrap RL training.

内容的提问来源于stack exchange，提问作者Madhi