diff --git a/.codeboarding/Conditional_Information_Handler.md b/.codeboarding/Conditional_Information_Handler.md
new file mode 100644
index 00000000..ea8fe4a7
--- /dev/null
+++ b/.codeboarding/Conditional_Information_Handler.md
@@ -0,0 +1,197 @@
+```mermaid
+
+graph LR
+
+ Conditional_Information_Core["Conditional Information Core"]
+
+ Focus_Region_Modeler["Focus Region Modeler"]
+
+ Configuration_Management["Configuration Management"]
+
+ GFN_Task_Definitions["GFN Task Definitions"]
+
+ GFN_Algorithm_Implementations["GFN Algorithm Implementations"]
+
+ GFN_Trainer["GFN Trainer"]
+
+ Conditional_Information_Core -- "uses" --> Focus_Region_Modeler
+
+ Conditional_Information_Core -- "is configured by" --> Configuration_Management
+
+ GFN_Task_Definitions -- "uses" --> Conditional_Information_Core
+
+ GFN_Algorithm_Implementations -- "uses" --> Conditional_Information_Core
+
+ GFN_Trainer -- "orchestrates" --> GFN_Task_Definitions
+
+ GFN_Trainer -- "orchestrates" --> GFN_Algorithm_Implementations
+
+ GFN_Trainer -- "uses" --> Configuration_Management
+
+ click GFN_Algorithm_Implementations href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//GFN_Algorithm_Implementations.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+Overview of the `Conditional Information Handler` subsystem, detailing its structure, flow, purpose, and interactions with other core components of the GFlowNet framework.
+
+
+
+### Conditional Information Core
+
+This is the heart of the subsystem, defining the abstract interface for all conditional information and providing concrete implementations for various conditioning strategies. It allows the GFlowNet to be guided by different external signals.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.utils.conditioning.Conditional` (22:34)
+
+- `gflownet.utils.conditioning.TemperatureConditional` (37:93)
+
+- `gflownet.utils.conditioning.MultiObjectiveWeightedPreferences` (96:133)
+
+- `gflownet.utils.conditioning.FocusRegionConditional` (136:249)
+
+
+
+
+
+### Focus Region Modeler
+
+This component is specialized in defining and providing "focus regions," which are specific areas of interest in the state space that the GFlowNet should prioritize during generation. It works in conjunction with `FocusRegionConditional`.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.utils.focus_model.FocusModel` (8:43)
+
+- `gflownet.utils.focus_model.TabularFocusModel` (46:116)
+
+
+
+
+
+### Configuration Management
+
+This component is responsible for defining and loading the parameters and settings for all types of conditional information, ensuring that the conditioning strategies are properly initialized and configured.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.config.Config` (48:109)
+
+- `gflownet.utils.config.ConditionalsConfig` (75:80)
+
+- `gflownet.utils.config.TempCondConfig` (7:28)
+
+- `gflownet.utils.config.MultiObjectiveConfig` (32:34)
+
+- `gflownet.utils.config.FocusRegionConfig` (55:71)
+
+- `gflownet.utils.config.WeightedPreferencesConfig` (38:51)
+
+
+
+
+
+### GFN Task Definitions
+
+This component encapsulates the definition of various generative tasks that GFlowNet can perform (e.g., molecule generation, sequence generation). These tasks explicitly *utilize* conditional information to shape their objectives and guide the generative process towards desired outcomes.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.tasks.gfn_task.GFNTask` (1:1)
+
+- `gflownet.tasks.qm9.QM9GapTask` (21:109)
+
+- `gflownet.tasks.seh_frag.SEHTask` (22:69)
+
+- `gflownet.tasks.qm9_moo.QM9GapMOOTask` (28:189)
+
+- `gflownet.tasks.seh_moo.SEHMOOTask` (1:1)
+
+
+
+
+
+### GFN Algorithm Implementations [[Expand]](./GFN_Algorithm_Implementations.md)
+
+This component contains the core GFlowNet algorithms (e.g., Trajectory Balance, Flow Matching, Soft Q-Learning). These algorithms *process* the conditional information provided by the `Conditional Information Core` to compute probabilities and guide the generative policy.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.algo.gfn_algorithm.GFNAlgorithm` (1:1)
+
+- `gflownet.algo.trajectory_balance.TrajectoryBalance` (70:776)
+
+- `gflownet.algo.flow_matching.FlowMatching` (35:190)
+
+- `gflownet.algo.soft_q_learning.SoftQLearning` (12:190)
+
+- `gflownet.algo.multi_objective_reinforce.MultiObjectiveReinforce` (1:1)
+
+
+
+
+
+### GFN Trainer
+
+This component orchestrates the entire training process of a GFlowNet. It is responsible for initializing the GFN tasks, algorithms, and crucially, for loading and passing the configured conditional information to the relevant components during the training loop.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.trainer.GFNTrainer` (36:371)
+
+- `gflownet.online_trainer.StandardOnlineTrainer` (27:133)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Configuration_Manager.md b/.codeboarding/Configuration_Manager.md
new file mode 100644
index 00000000..e96e0beb
--- /dev/null
+++ b/.codeboarding/Configuration_Manager.md
@@ -0,0 +1,213 @@
+```mermaid
+
+graph LR
+
+ Strict_Data_Class_Base["Strict Data Class Base"]
+
+ Core_Framework_Configuration["Core Framework Configuration"]
+
+ Algorithm_Configuration["Algorithm Configuration"]
+
+ Model_Configuration["Model Configuration"]
+
+ Data_Management_Configuration["Data Management Configuration"]
+
+ Task_Specific_Configuration["Task-Specific Configuration"]
+
+ Conditional_Generation_Configuration["Conditional Generation Configuration"]
+
+ Optimizer_Configuration["Optimizer Configuration"]
+
+ Strict_Data_Class_Base -- "is inherited by" --> Core_Framework_Configuration
+
+ Core_Framework_Configuration -- "is inherited by" --> Algorithm_Configuration
+
+ Core_Framework_Configuration -- "is inherited by" --> Model_Configuration
+
+ Core_Framework_Configuration -- "is inherited by" --> Data_Management_Configuration
+
+ Core_Framework_Configuration -- "is inherited by" --> Task_Specific_Configuration
+
+ Core_Framework_Configuration -- "is inherited by" --> Conditional_Generation_Configuration
+
+ Core_Framework_Configuration -- "is inherited by" --> Optimizer_Configuration
+
+ Core_Framework_Configuration -- "provides settings to" --> GFN_Trainer
+
+ Algorithm_Configuration -- "provides settings to" --> GFN_Algorithms
+
+ Model_Configuration -- "provides settings to" --> Neural_Network_Models
+
+ Data_Management_Configuration -- "provides settings to" --> Data_Management_components
+
+ Task_Specific_Configuration -- "provides settings to" --> GFN_Tasks
+
+ Conditional_Generation_Configuration -- "provides settings to" --> Conditional_Utilities
+
+ Optimizer_Configuration -- "provides settings to" --> GFN_Trainer
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The Configuration Manager subsystem in GFlowNet is a cornerstone of its architecture, embodying a configuration-driven design that ensures consistency, reproducibility, and flexibility across the entire framework. It centralizes the management of hyperparameters and operational settings, allowing for precise control over algorithms, models, data handling, and tasks. The subsystem is built around a hierarchical structure of configuration classes, all stemming from a strict data class base. This design promotes modularity and clear separation of concerns. These components were chosen because they collectively represent the core of GFlowNet's configuration-driven design, which is explicitly highlighted in the project's architectural patterns. They are fundamental for reproducibility, modularity and extensibility, centralized control, and flexibility. In essence, the Configuration Manager is not just a collection of settings; it's an active architectural pattern that dictates how the GFlowNet framework operates, ensuring robustness, adaptability, and scientific rigor.
+
+
+
+### Strict Data Class Base
+
+This is the foundational component for all configuration classes within GFlowNet. It leverages `StrictDataClass` to enforce type-checking and immutability for all configuration parameters. This ensures that configurations are well-defined, consistent, and cannot be accidentally modified during runtime, which is crucial for reproducible machine learning experiments.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `StrictDataClass` (1:1)
+
+
+
+
+
+### Core Framework Configuration
+
+Serving as the top-level configuration, this component aggregates and manages global hyperparameters and settings that apply to the entire GFlowNet framework. It acts as the central entry point for defining the overall system behavior.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `Config` (48:109)
+
+
+
+
+
+### Algorithm Configuration
+
+This component defines and manages hyperparameters specific to the various GFlowNet algorithms, such as Trajectory Balance (TB), Flow Matching (FM), Advantage Actor-Critic (A2C), Soft Q-Learning (SQL), and Multi-Objective Q-Learning (MOQL). It allows for precise tuning of each algorithm's operational parameters.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `AlgoConfig` (1:1)
+
+
+
+
+
+### Model Configuration
+
+This component specifies the architectural details and training parameters for the neural network models employed within GFlowNet, including Graph Transformers and Sequence Transformers. It ensures that models are instantiated and trained with consistent settings.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `ModelConfig` (1:1)
+
+
+
+
+
+### Data Management Configuration
+
+Manages settings related to data handling within the framework, including parameters for data loading, sampling strategies, and the configuration of replay buffers. These settings are vital for efficient and stable training processes.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `ReplayConfig` (1:1)
+
+
+
+
+
+### Task-Specific Configuration
+
+Encapsulates hyperparameters and settings unique to individual GFlowNet tasks, such as specific reward functions, dataset paths, or evaluation metrics for tasks like QM9 or SEH. This allows for flexible adaptation to diverse generative problems.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `TasksConfig` (1:1)
+
+
+
+
+
+### Conditional Generation Configuration
+
+Defines parameters for utility components that enable conditional generation, such as temperature conditioning for exploration/exploitation balance or focus regions for multi-objective optimization.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `ConditionalsConfig` (1:1)
+
+
+
+
+
+### Optimizer Configuration
+
+Manages the configuration settings for the optimization process, including the choice of optimizer (e.g., Adam, SGD), learning rate schedules, and other related parameters that dictate how models are trained.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `OptimizerConfig` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Data_Manager.md b/.codeboarding/Data_Manager.md
new file mode 100644
index 00000000..afcc1b25
--- /dev/null
+++ b/.codeboarding/Data_Manager.md
@@ -0,0 +1,99 @@
+```mermaid
+
+graph LR
+
+ DataSource["DataSource"]
+
+ ReplayBuffer["ReplayBuffer"]
+
+ QM9Dataset["QM9Dataset"]
+
+ DataSource -- "uses" --> ReplayBuffer
+
+ DataSource -- "uses" --> QM9Dataset
+
+ GFN_Trainer -- "uses" --> DataSource
+
+ GFN_Tasks -- "uses" --> QM9Dataset
+
+ Environments -- "provides trajectories to" --> DataSource
+
+ Configuration_Management -- "configures" --> DataSource
+
+ Configuration_Management -- "configures" --> ReplayBuffer
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `Data Management` component is crucial for the GFlowNet framework as it underpins the entire training process by providing and managing the data necessary for learning. It handles the initial datasets and the dynamic storage of experience replay data, which is vital for the stability and efficiency of off-policy reinforcement learning algorithms used in GFlowNets.
+
+
+
+### DataSource
+
+The `DataSource` acts as a unified interface for providing data to the GFlowNet trainer. It can combine multiple data sources, such as samples generated by the GFlowNet model itself, data from a replay buffer, or pre-existing datasets. It orchestrates the sampling process, computes properties and rewards for trajectories, and manages the flow of data to the training algorithms.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.data.data_source` (1:1)
+
+
+
+
+
+### ReplayBuffer
+
+The `ReplayBuffer` stores past trajectories (experiences) generated by the GFlowNet model. It allows for efficient sampling of these experiences, which is critical for off-policy learning algorithms like those used in GFlowNets. By re-using past data, it helps to decorrelate samples, improve data efficiency, and stabilize training.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.data.replay_buffer` (1:1)
+
+
+
+
+
+### QM9Dataset
+
+QM9Dataset is a concrete implementation of a dataset handler specifically for the QM9 dataset, a widely used benchmark in computational chemistry for molecular property prediction. It loads molecular data (SMILES strings) and their associated properties (e.g., 'gap') from HDF5 or XYZ files, converting them into a format usable by the GFlowNet.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.data.qm9` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Environment_Simulator.md b/.codeboarding/Environment_Simulator.md
new file mode 100644
index 00000000..7bee9c00
--- /dev/null
+++ b/.codeboarding/Environment_Simulator.md
@@ -0,0 +1,199 @@
+```mermaid
+
+graph LR
+
+ GraphBuildingEnv["GraphBuildingEnv"]
+
+ GraphBuildingEnvContext["GraphBuildingEnvContext"]
+
+ MolBuildingEnvContext["MolBuildingEnvContext"]
+
+ FragMolBuildingEnvContext["FragMolBuildingEnvContext"]
+
+ SeqBuildingEnv["SeqBuildingEnv"]
+
+ AutoregressiveSeqBuildingContext["AutoregressiveSeqBuildingContext"]
+
+ GraphAction["GraphAction"]
+
+ GraphActionType["GraphActionType"]
+
+ GraphBuildingEnv -- "uses" --> GraphBuildingEnvContext
+
+ GraphBuildingEnv -- "generates/processes" --> GraphAction
+
+ GraphBuildingEnv -- "uses" --> GraphActionType
+
+ MolBuildingEnvContext -- "inherits from" --> GraphBuildingEnvContext
+
+ FragMolBuildingEnvContext -- "inherits from" --> GraphBuildingEnvContext
+
+ SeqBuildingEnv -- "inherits from" --> GraphBuildingEnv
+
+ AutoregressiveSeqBuildingContext -- "inherits from" --> GraphBuildingEnvContext
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `Environment Simulator` component is crucial for defining the generative process within the GFlowNet framework. It abstracts the concept of building structured data (graphs, molecules, sequences) into a Markov Decision Process (MDP), specifying the state space, valid actions, and transition dynamics. This allows the GFlowNet algorithms to interact with a consistent interface regardless of the specific data type being generated. These components are fundamental because they collectively define the "rules of the game" for the GFlowNet. Without a well-defined environment, the GFlowNet cannot explore the state space, take meaningful actions, or learn the generative process. The modular design, with base classes for environments and contexts, allows for easy extension to new data types and generative paradigms while maintaining a consistent interface for the core GFlowNet algorithms.
+
+
+
+### GraphBuildingEnv
+
+This is the abstract base class for all generative environments. It defines the fundamental interface for managing the state space, valid actions, and state transition dynamics for building structured data, particularly graphs. It provides methods for stepping through the generative process, resetting the environment, and obtaining information about the current state.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.envs.graph_building_env.GraphBuildingEnv` (127:373)
+
+
+
+
+
+### GraphBuildingEnvContext
+
+This class serves as the base context for graph-building environments. It encapsulates common utilities, rules, and definitions necessary for the generative process, such as atom types, bond types, and methods for converting between internal graph representations and external formats (e.g., RDKit molecules). It's responsible for providing the environment with the necessary domain-specific knowledge.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.envs.graph_building_env.GraphBuildingEnvContext` (898:1020)
+
+
+
+
+
+### MolBuildingEnvContext
+
+A concrete implementation of `GraphBuildingEnvContext` specifically tailored for molecule generation. It defines molecular-specific properties like atom types, bond types, and valency rules, and provides methods for validating molecular structures.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.envs.mol_building_env.MolBuildingEnvContext` (16:471)
+
+
+
+
+
+### FragMolBuildingEnvContext
+
+Another concrete implementation of `GraphBuildingEnvContext`, designed for fragment-based molecule generation. This context handles the specific rules and actions involved when building molecules by adding predefined fragments rather than individual atoms and bonds.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.envs.frag_mol_env.FragMolBuildingEnvContext` (15:379)
+
+
+
+
+
+### SeqBuildingEnv
+
+A concrete environment for sequence generation, inheriting from `GraphBuildingEnv`. It adapts the graph-building paradigm to sequential data, defining states as partial sequences and actions as appending tokens.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.envs.seq_building_env.SeqBuildingEnv` (30:57)
+
+
+
+
+
+### AutoregressiveSeqBuildingContext
+
+A concrete implementation of `GraphBuildingEnvContext` (via `SeqBuildingEnv`) for autoregressive sequence building. It defines the vocabulary and rules specific to generating sequences token by token.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.envs.seq_building_env.AutoregressiveSeqBuildingContext` (81:132)
+
+
+
+
+
+### GraphAction
+
+Represents a single action that can be taken within a `GraphBuildingEnv`. It encapsulates the type of action (e.g., add node, add edge) and any associated parameters (e.g., node type, edge type, target nodes).
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.envs.graph_building_env.GraphAction` (99:124)
+
+
+
+
+
+### GraphActionType
+
+An enumeration defining the various types of actions that can be performed in a graph-building environment (e.g., `ADD_NODE`, `ADD_EDGE`, `SET_NODE_ATTR`, `STOP`).
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.envs.graph_building_env.GraphActionType` (57:80)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/GFN_Algorithm_Implementations.md b/.codeboarding/GFN_Algorithm_Implementations.md
new file mode 100644
index 00000000..bd3bb5da
--- /dev/null
+++ b/.codeboarding/GFN_Algorithm_Implementations.md
@@ -0,0 +1,241 @@
+```mermaid
+
+graph LR
+
+ GFNAlgorithm["GFNAlgorithm"]
+
+ TrajectoryBalance["TrajectoryBalance"]
+
+ FlowMatching["FlowMatching"]
+
+ A2C["A2C"]
+
+ SoftQLearning["SoftQLearning"]
+
+ EnvelopeQLearning["EnvelopeQLearning"]
+
+ MultiObjectiveReinforce["MultiObjectiveReinforce"]
+
+ GraphSampler["GraphSampler"]
+
+ AlgoConfig["AlgoConfig"]
+
+ GFNAlgorithm -- "is inherited by" --> TrajectoryBalance
+
+ GFNAlgorithm -- "is inherited by" --> A2C
+
+ GFNAlgorithm -- "is inherited by" --> SoftQLearning
+
+ GFNAlgorithm -- "is inherited by" --> EnvelopeQLearning
+
+ TrajectoryBalance -- "is inherited by" --> FlowMatching
+
+ TrajectoryBalance -- "is inherited by" --> MultiObjectiveReinforce
+
+ TrajectoryBalance -- "uses" --> GraphSampler
+
+ FlowMatching -- "uses" --> GraphSampler
+
+ A2C -- "uses" --> GraphSampler
+
+ SoftQLearning -- "uses" --> GraphSampler
+
+ EnvelopeQLearning -- "uses" --> GraphSampler
+
+ MultiObjectiveReinforce -- "uses" --> GraphSampler
+
+ TrajectoryBalance -- "uses" --> AlgoConfig
+
+ FlowMatching -- "uses" --> AlgoConfig
+
+ A2C -- "uses" --> AlgoConfig
+
+ SoftQLearning -- "uses" --> AlgoConfig
+
+ EnvelopeQLearning -- "uses" --> AlgoConfig
+
+ MultiObjectiveReinforce -- "uses" --> AlgoConfig
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The GFN Algorithm Implementations component is the heart of the GFlowNet framework, encapsulating the core learning algorithms that drive the generative policy optimization. It defines the specific loss functions and learning rules, enabling the model to learn to generate structured data (e.g., graphs) by optimizing a policy that explores the state space. This component interacts closely with the environment to collect trajectories and with neural network models to update the generative policy based on the computed losses.
+
+
+
+### GFNAlgorithm
+
+This abstract base class defines the common interface and shared functionalities for all GFlowNet learning algorithms. It provides a blueprint for how different algorithms should interact with the environment, models, and data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `GFNAlgorithm`
+
+
+
+
+
+### TrajectoryBalance
+
+Implements the Trajectory Balance (TB) algorithm, a foundational GFlowNet learning rule that aims to balance the flow of probability along forward and backward trajectories.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `TrajectoryBalance` (70:776)
+
+
+
+
+
+### FlowMatching
+
+Implements the Flow Matching (FM) algorithm, another key GFlowNet variant that focuses on matching the flow of probability at each state.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `FlowMatching` (35:190)
+
+
+
+
+
+### A2C
+
+Implements the Advantage Actor-Critic (A2C) algorithm adapted for GFlowNet, combining policy-based and value-based methods for learning.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `A2C`
+
+
+
+
+
+### SoftQLearning
+
+Implements the Soft Q-Learning (SQL) algorithm, which incorporates an entropy regularization term to encourage exploration and improve robustness.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `SoftQLearning` (12:190)
+
+
+
+
+
+### EnvelopeQLearning
+
+Implements the Envelope Q-Learning (EQL) algorithm, a variant of Q-learning designed for GFlowNets.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `EnvelopeQLearning` (158:406)
+
+
+
+
+
+### MultiObjectiveReinforce
+
+Implements a Reinforce-based algorithm specifically tailored for multi-objective GFlowNet tasks, where multiple rewards need to be optimized simultaneously.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `MultiObjectiveReinforce`
+
+
+
+
+
+### GraphSampler
+
+This component is responsible for generating trajectories (sequences of states and actions) by interacting with the environment and using the current generative policy (neural network model).
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `GraphSampler`
+
+
+
+
+
+### AlgoConfig
+
+This component defines the configuration parameters specific to the GFlowNet algorithms, allowing for flexible and reproducible experimentation.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `AlgoConfig`
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Metrics_and_Evaluation.md b/.codeboarding/Metrics_and_Evaluation.md
new file mode 100644
index 00000000..88261eea
--- /dev/null
+++ b/.codeboarding/Metrics_and_Evaluation.md
@@ -0,0 +1,117 @@
+```mermaid
+
+graph LR
+
+ Metrics_and_Evaluation["Metrics and Evaluation"]
+
+ GFN_Trainer["GFN Trainer"]
+
+ GFN_Tasks["GFN Tasks"]
+
+ Data_Management["Data Management"]
+
+ Utilities["Utilities"]
+
+ Metrics_and_Evaluation -- "uses" --> Utilities
+
+ GFN_Trainer -- "uses" --> Metrics_and_Evaluation
+
+ GFN_Tasks -- "interacts with" --> Metrics_and_Evaluation
+
+ Metrics_and_Evaluation -- "interacts with" --> Data_Management
+
+ click Metrics_and_Evaluation href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Metrics_and_Evaluation.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `Metrics and Evaluation` component is fundamental to the GFlowNet framework as it provides the necessary mechanisms to quantify the performance of generative models, especially in complex multi-objective optimization scenarios. Its integration with the training process ensures that model development is guided by clear, measurable objectives, enabling effective hyperparameter tuning and model selection.
+
+
+
+### Metrics and Evaluation [[Expand]](./Metrics_and_Evaluation.md)
+
+This component is responsible for computing and tracking various performance metrics, with a particular focus on multi-objective optimization metrics like Hypervolume, IGD (Inverted Generational Distance), and HSR (Hypervolume Success Rate). It integrates with logging mechanisms to monitor training progress, evaluate model performance, and provide insights into the generative process.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.utils.metrics.compute_metrics`
+
+- `gflownet.utils.metrics.hypervolume`
+
+- `gflownet.utils.metrics.igd`
+
+- `gflownet.utils.multiobjective_hooks.TopKHook` (214:238)
+
+
+
+
+
+### GFN Trainer
+
+As the orchestrator of the learning process, the GFN Trainer is central. It brings together the model, environment, data, and algorithms to facilitate training. Its reliance on Metrics and Evaluation highlights the importance of performance monitoring during training.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### GFN Tasks
+
+These components define the "what" of the GFlowNet. They encapsulate the specific problem being solved, including the state space, actions, and reward functions. Without well-defined tasks, the GFlowNet has no objective to optimize.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Data Management
+
+Essential for feeding data to the models and algorithms. In generative models, this includes handling generated samples, replay buffers, and potentially external datasets for training or evaluation.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Utilities
+
+These components provide foundational support across the entire framework, ensuring code reusability, consistency, and maintainability. Metrics and other components often rely on these general-purpose functions.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Policy_Network.md b/.codeboarding/Policy_Network.md
new file mode 100644
index 00000000..dd780527
--- /dev/null
+++ b/.codeboarding/Policy_Network.md
@@ -0,0 +1,67 @@
+```mermaid
+
+graph LR
+
+ Policy_Network["Policy Network"]
+
+ Environments -- "provides states to" --> Policy_Network
+
+ Policy_Network -- "outputs predictions to" --> GFN_Algorithms
+
+ Configuration_Management -- "configures" --> Policy_Network
+
+ Policy_Network -- "outputs predictions to" --> GFN_Trainer
+
+ click Policy_Network href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Policy_Network.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `Policy Network` is the "brain" of the GFlowNet. It's responsible for learning the underlying generative distribution of the data. Without a well-designed and trained policy network, the GFlowNet cannot effectively explore the state space or generate high-quality data. The different model architectures (Graph Transformers, Sequence Transformers, MXMNet) allow the framework to be applied to various types of structured data (graphs, sequences), making it versatile. The `config.py` file is crucial for managing the complexity of these models and enabling easy experimentation with different architectures and hyperparameters.
+
+
+
+### Policy Network [[Expand]](./Policy_Network.md)
+
+Implements the neural network architectures (e.g., Graph Transformers, MXMNet, Sequence Transformers) that represent the GFlowNet policy. It takes the current environment state and conditional information as input and outputs predictions (e.g., action probabilities, state values) to guide the generative process. These models are fundamental as they learn the generative policy that guides the construction of structured data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.models.graph_transformer.GraphTransformerGFN` (152:292)
+
+- `gflownet.models.seq_transformer.SeqTransformerGFN` (29:122)
+
+- `gflownet.models.mxmnet.MXMNet` (33:157)
+
+- `gflownet.models.bengio2021flow`
+
+- `gflownet.models.config.ModelConfig` (26:41)
+
+- `gflownet.models.config.GraphTransformerConfig` (7:11)
+
+- `gflownet.models.config.SeqTransformerConfig` (20:22)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Task_Specific_Logic.md b/.codeboarding/Task_Specific_Logic.md
new file mode 100644
index 00000000..390ee837
--- /dev/null
+++ b/.codeboarding/Task_Specific_Logic.md
@@ -0,0 +1,243 @@
+```mermaid
+
+graph LR
+
+ GFN_Tasks["GFN Tasks"]
+
+ Task_Configuration["Task Configuration"]
+
+ Environments["Environments"]
+
+ GFN_Trainer["GFN Trainer"]
+
+ GFN_Algorithms["GFN Algorithms"]
+
+ Data_Sources["Data Sources"]
+
+ Conditioning["Conditioning"]
+
+ Neural_Network_Models["Neural Network Models"]
+
+ GFN_Tasks -- "defines objectives for" --> GFN_Algorithms
+
+ GFN_Tasks -- "evaluates states from" --> Environments
+
+ GFN_Trainer -- "queries rewards from" --> GFN_Tasks
+
+ GFN_Tasks -- "uses data from" --> Data_Sources
+
+ GFN_Tasks -- "can be modified by" --> Conditioning
+
+ Task_Configuration -- "configures" --> GFN_Tasks
+
+ GFN_Trainer -- "trains" --> Neural_Network_Models
+
+ Environments -- "interact with" --> Neural_Network_Models
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `Task Specific Logic` component, identified as `GFN Tasks`, is central to defining the objectives and reward mechanisms within the GFlowNet framework. It encapsulates the problem-specific evaluation of generated data, providing crucial reward signals that guide the GFlowNet's learning algorithms.
+
+
+
+### GFN Tasks
+
+This is the core of the `Task Specific Logic`. `gflownet.GFNTask` serves as the abstract base class, defining the interface for all GFlowNet tasks, primarily through methods for reward calculation. Concrete implementations like `gflownet.tasks.qm9.QM9GapTask`, `gflownet.tasks.seh_frag.SEHTask`, and their multi-objective (MOO) variants (`gflownet.tasks.qm9_moo.QM9GapMOOTask`, `gflownet.tasks.seh_frag_moo.SEHMOOTask`) provide the specific logic for evaluating generated data (e.g., molecules from QM9 dataset, SEH molecules) and computing scalar or multi-objective rewards.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.GFNTask`
+
+- `gflownet.tasks.qm9.QM9GapTask` (21:109)
+
+- `gflownet.tasks.seh_frag.SEHTask` (22:69)
+
+- `gflownet.tasks.qm9_moo.QM9GapMOOTask` (28:189)
+
+- `gflownet.tasks.seh_frag_moo.SEHMOOTask` (53:207)
+
+- `gflownet.tasks.make_rings.MakeRingsTask` (14:26)
+
+- `gflownet.tasks.toy_seq.ToySeqTask` (15:37)
+
+
+
+
+
+### Task Configuration
+
+`gflownet.tasks.config.TasksConfig` and its specialized subclasses (e.g., `QM9TaskConfig`, `SEHTaskConfig`) manage the configuration parameters specific to each GFlowNet task. This includes settings related to reward functions, dataset paths, and other task-specific hyperparameters.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.tasks.config.TasksConfig` (65:69)
+
+- `gflownet.tasks.config.QM9TaskConfig` (35:37)
+
+- `gflownet.tasks.config.SEHTaskConfig` (7:8)
+
+
+
+
+
+### Environments
+
+`gflownet.envs.graph_building_env.GraphBuildingEnvContext` (and its concrete implementations like `MolBuildingEnvContext`, `FragMolBuildingEnvContext`, `AutoregressiveSeqBuildingContext`) defines the state space, actions, and rules for generating structured data (graphs or sequences). These environments produce the states that the `GFN Tasks` component then evaluates.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.envs.graph_building_env.GraphBuildingEnvContext` (898:1020)
+
+- `gflownet.envs.mol_building_env.MolBuildingEnvContext` (16:471)
+
+- `gflownet.envs.frag_mol_env.FragMolBuildingEnvContext` (15:379)
+
+- `gflownet.envs.seq_building_env.AutoregressiveSeqBuildingContext` (81:132)
+
+
+
+
+
+### GFN Trainer
+
+`gflownet.trainer.GFNTrainer` and its primary implementation `gflownet.online_trainer.StandardOnlineTrainer` orchestrate the entire GFlowNet training process. This includes sampling trajectories, computing losses, and updating the GFlowNet model. It queries the `GFN Tasks` component for reward signals to guide the learning.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.trainer.GFNTrainer` (36:371)
+
+- `gflownet.online_trainer.StandardOnlineTrainer` (27:133)
+
+
+
+
+
+### GFN Algorithms
+
+`gflownet.GFNAlgorithm` and its concrete implementations (e.g., `gflownet.algo.trajectory_balance.TrajectoryBalance`, `gflownet.algo.flow_matching.FlowMatching`, `gflownet.algo.multiobjective_reinforce.MultiObjectiveReinforce`) define the specific GFlowNet learning rules and loss functions. These algorithms consume the reward signals provided by `GFN Tasks` to update the parameters of the generative model.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.GFNAlgorithm`
+
+- `gflownet.algo.trajectory_balance.TrajectoryBalance` (70:776)
+
+- `gflownet.algo.flow_matching.FlowMatching` (35:190)
+
+- `gflownet.algo.multiobjective_reinforce.MultiObjectiveReinforce` (9:53)
+
+
+
+
+
+### Data Sources
+
+`gflownet.data.data_source.DataSource` and specific dataset implementations like `gflownet.data.qm9.QM9Dataset` provide the necessary data for tasks to compute rewards. For instance, QM9 tasks might require access to pre-calculated properties of molecules.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.data.data_source.DataSource` (20:320)
+
+- `gflownet.data.qm9.QM9Dataset` (13:54)
+
+- `gflownet.tasks.seh_frag.LittleSEHDataset` (101:121)
+
+
+
+
+
+### Conditioning
+
+`gflownet.utils.conditioning.Conditional` and its subclasses (e.g., `gflownet.utils.conditioning.TemperatureConditional`, `gflownet.utils.conditioning.FocusRegionConditional`, `gflownet.utils.conditioning.MultiObjectiveWeightedPreferences`) allow for modifying the reward signal or the sampling process based on specific conditions. This is particularly important for multi-objective optimization or controlling exploration.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.utils.conditioning.Conditional` (22:34)
+
+- `gflownet.utils.conditioning.TemperatureConditional` (37:93)
+
+- `gflownet.utils.conditioning.FocusRegionConditional` (136:249)
+
+- `gflownet.utils.conditioning.MultiObjectiveWeightedPreferences` (96:133)
+
+
+
+
+
+### Neural Network Models
+
+`gflownet.models.graph_transformer.GraphTransformerGFN` and `gflownet.models.seq_transformer.SeqTransformerGFN` represent the neural network architectures (e.g., Graph Transformers, Sequence Transformers) that the GFlowNet algorithms train. While not directly part of `GFN Tasks`, these models are the generative agents whose outputs are evaluated by the tasks.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet.models.graph_transformer.GraphTransformerGFN` (152:292)
+
+- `gflownet.models.seq_transformer.SeqTransformerGFN` (29:122)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Training_Orchestrator.md b/.codeboarding/Training_Orchestrator.md
new file mode 100644
index 00000000..07e8fa10
--- /dev/null
+++ b/.codeboarding/Training_Orchestrator.md
@@ -0,0 +1,319 @@
+```mermaid
+
+graph LR
+
+ Training_Orchestrator["Training Orchestrator"]
+
+ GFN_Algorithms["GFN Algorithms"]
+
+ Neural_Network_Models["Neural Network Models"]
+
+ Environments["Environments"]
+
+ GFN_Tasks["GFN Tasks"]
+
+ Configuration_Management["Configuration Management"]
+
+ Data_Management["Data Management"]
+
+ Graph_Sampler["Graph Sampler"]
+
+ Conditional_Generation["Conditional Generation"]
+
+ Logging["Logging"]
+
+ Training_Orchestrator -- "Uses" --> GFN_Algorithms
+
+ Training_Orchestrator -- "Interacts with" --> Environments
+
+ Training_Orchestrator -- "Passes states to" --> Neural_Network_Models
+
+ Training_Orchestrator -- "Queries" --> GFN_Tasks
+
+ Training_Orchestrator -- "Utilizes" --> Data_Management
+
+ Training_Orchestrator -- "Reads settings from" --> Configuration_Management
+
+ Training_Orchestrator -- "Uses" --> Logging
+
+ Training_Orchestrator -- "Employs" --> Graph_Sampler
+
+ Training_Orchestrator -- "Applies" --> Conditional_Generation
+
+ GFN_Algorithms -- "Uses" --> Neural_Network_Models
+
+ GFN_Algorithms -- "Receives data from" --> Graph_Sampler
+
+ Neural_Network_Models -- "Receives input states from" --> Environments
+
+ Neural_Network_Models -- "Configured by" --> Configuration_Management
+
+ Environments -- "Provides states to" --> Neural_Network_Models
+
+ Graph_Sampler -- "Uses" --> Environments
+
+ GFN_Tasks -- "Can influence" --> Conditional_Generation
+
+ Configuration_Management -- "Configures" --> Training_Orchestrator
+
+ Configuration_Management -- "Configures" --> Neural_Network_Models
+
+ Configuration_Management -- "Configures" --> GFN_Algorithms
+
+ Data_Management -- "Provides data to" --> GFN_Algorithms
+
+ Graph_Sampler -- "Interacts with" --> Environments
+
+ Graph_Sampler -- "Queries" --> Neural_Network_Models
+
+ Logging -- "Receives data from" --> GFN_Algorithms
+
+ Logging -- "Receives data from" --> GFN_Tasks
+
+ click Training_Orchestrator href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Training_Orchestrator.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The Training Orchestrator is the central component responsible for managing and coordinating the entire GFlowNet training loop. It initializes and integrates various sub-components, including the GFlowNet algorithm, neural network models, generative environments, and data management systems. Its primary responsibilities include: Training Loop Management: Iteratively samples trajectories from the environment, computes losses based on the chosen GFlowNet algorithm, and updates the model parameters. Component Coordination: Ensures seamless interaction and data flow between the GFN Algorithms, Neural Network Models, Environments, GFN Tasks, and Data Management components. Optimization: Manages the optimization process, applying gradients to update the model's parameters. Logging and Monitoring: Integrates with logging utilities to record training progress, metrics, and other relevant information. Configuration Application: Reads and applies training parameters and configurations defined by the Configuration Management component.
+
+
+
+### Training Orchestrator [[Expand]](./Training_Orchestrator.md)
+
+Orchestrates the entire GFlowNet training process. It initializes and coordinates the interaction between algorithms, models, environments, and data to learn generative policies, managing the training loop, optimization, and logging.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/trainer.py` (1:1)
+
+- `gflownet/online_trainer.py` (1:1)
+
+
+
+
+
+### GFN Algorithms
+
+Implement the core GFlowNet learning rules and loss functions (e.g., Trajectory Balance, Flow Matching). They define how the model parameters are updated based on sampled trajectories and rewards.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/algo/trajectory_balance.py` (1:1)
+
+- `gflownet/algo/flow_matching.py` (1:1)
+
+- `gflownet/algo/advantage_actor_critic.py` (1:1)
+
+- `gflownet/algo/envelope_q_learning.py` (1:1)
+
+- `gflownet/algo/soft_q_learning.py` (1:1)
+
+
+
+
+
+### Neural Network Models
+
+Parameterized functions (e.g., Graph Transformers, Sequence Transformers) that represent the GFlowNet's policy. They learn to map states to actions or flow values, enabling the generation of structured data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/models/graph_transformer.py` (1:1)
+
+- `gflownet/models/seq_transformer.py` (1:1)
+
+- `gflownet/models/mxmnet.py` (1:1)
+
+
+
+
+
+### Environments
+
+Define the problem space and the generative process. They provide the states, actions, and transitions that the GFlowNet learns to navigate and generate, representing the structured data (e.g., molecules, sequences).
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/envs/graph_building_env.py` (1:1)
+
+- `gflownet/envs/mol_building_env.py` (1:1)
+
+- `gflownet/envs/frag_mol_env.py` (1:1)
+
+- `gflownet/envs/seq_building_env.py` (1:1)
+
+
+
+
+
+### GFN Tasks
+
+Encapsulate the specific objective or reward function for a generative problem. They provide the crucial feedback signal that guides the GFlowNet's learning towards desired outcomes.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/tasks/qm9.py` (1:1)
+
+- `gflownet/tasks/make_rings.py` (1:1)
+
+- `gflownet/tasks/toy_seq.py` (1:1)
+
+- `gflownet/tasks/seh_frag.py` (1:1)
+
+- `gflownet/tasks/qm9_moo.py` (1:1)
+
+- `gflownet/tasks/seh_frag_moo.py` (1:1)
+
+
+
+
+
+### Configuration Management
+
+Manages hyperparameters and settings across all components, ensuring reproducibility and facilitating experimentation. It provides a centralized way to define and load configurations for algorithms, models, environments, and training.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/config.py` (1:1)
+
+- `gflownet/algo/config.py` (1:1)
+
+- `gflownet/models/config.py` (1:1)
+
+- `gflownet/tasks/config.py` (1:1)
+
+- `gflownet/data/config.py` (1:1)
+
+- `gflownet/utils/config.py` (1:1)
+
+
+
+
+
+### Data Management
+
+Handles the storage, retrieval, and sampling of data, particularly trajectories generated during training. This includes replay buffers for off-policy learning and dataset handling.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/data/replay_buffer.py` (1:1)
+
+- `gflownet/data/data_source.py` (1:1)
+
+- `gflownet/data/qm9.py` (1:1)
+
+
+
+
+
+### Graph Sampler
+
+Responsible for generating trajectories (sequences of states and actions) within the environment by interacting with the neural network models. It simulates the generative process of the GFlowNet.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/algo/graph_sampling.py` (1:1)
+
+
+
+
+
+### Conditional Generation
+
+Provides mechanisms to guide the GFlowNet's generative process based on specific conditions or preferences (e.g., temperature conditioning, multi-objective preferences, focus regions). This allows for targeted generation of desired outputs.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/utils/conditioning.py` (1:1)
+
+
+
+
+
+### Logging
+
+Manages the recording of training progress, metrics, and other relevant information to a persistent store (e.g., SQLite database). Essential for monitoring experiments, debugging, and analyzing results.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/utils/sqlite_log.py` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md
new file mode 100644
index 00000000..10734530
--- /dev/null
+++ b/.codeboarding/on_boarding.md
@@ -0,0 +1,323 @@
+```mermaid
+
+graph LR
+
+ Configuration_Manager["Configuration Manager"]
+
+ Training_Orchestrator["Training Orchestrator"]
+
+ GFN_Algorithm_Implementations["GFN Algorithm Implementations"]
+
+ Environment_Simulator["Environment Simulator"]
+
+ Policy_Network["Policy Network"]
+
+ Data_Manager["Data Manager"]
+
+ Task_Specific_Logic["Task Specific Logic"]
+
+ Conditional_Information_Handler["Conditional Information Handler"]
+
+ Metrics_and_Evaluation["Metrics and Evaluation"]
+
+ Core_Utilities["Core Utilities"]
+
+ Configuration_Manager -- "Configures" --> Training_Orchestrator
+
+ Training_Orchestrator -- "Drives Learning in" --> GFN_Algorithm_Implementations
+
+ Training_Orchestrator -- "Manages Parameters of" --> Policy_Network
+
+ Training_Orchestrator -- "Interacts with" --> Environment_Simulator
+
+ Training_Orchestrator -- "Retrieves Data From" --> Data_Manager
+
+ Training_Orchestrator -- "Utilizes" --> Task_Specific_Logic
+
+ Training_Orchestrator -- "Utilizes" --> Conditional_Information_Handler
+
+ Training_Orchestrator -- "Reports Metrics To" --> Metrics_and_Evaluation
+
+ GFN_Algorithm_Implementations -- "Queries" --> Policy_Network
+
+ GFN_Algorithm_Implementations -- "Interacts with" --> Environment_Simulator
+
+ GFN_Algorithm_Implementations -- "Consumes Data From" --> Data_Manager
+
+ GFN_Algorithm_Implementations -- "Uses Conditioning From" --> Conditional_Information_Handler
+
+ GFN_Algorithm_Implementations -- "Receives Rewards From" --> Task_Specific_Logic
+
+ Environment_Simulator -- "Provides States/Actions To" --> GFN_Algorithm_Implementations
+
+ Environment_Simulator -- "Provides States/Actions To" --> Policy_Network
+
+ Policy_Network -- "Receives Input From" --> Environment_Simulator
+
+ Policy_Network -- "Receives Input From" --> Conditional_Information_Handler
+
+ Policy_Network -- "Outputs Predictions To" --> GFN_Algorithm_Implementations
+
+ Data_Manager -- "Provides Data To" --> Training_Orchestrator
+
+ Data_Manager -- "Provides Data To" --> GFN_Algorithm_Implementations
+
+ Task_Specific_Logic -- "Provides Rewards To" --> GFN_Algorithm_Implementations
+
+ Task_Specific_Logic -- "Evaluates States From" --> Environment_Simulator
+
+ Task_Specific_Logic -- "Uses Conditioning From" --> Conditional_Information_Handler
+
+ Conditional_Information_Handler -- "Provides Conditioning To" --> Policy_Network
+
+ Conditional_Information_Handler -- "Provides Conditioning To" --> GFN_Algorithm_Implementations
+
+ Conditional_Information_Handler -- "Provides Conditioning To" --> Task_Specific_Logic
+
+ Metrics_and_Evaluation -- "Receives Data From" --> Training_Orchestrator
+
+ Metrics_and_Evaluation -- "Receives Data From" --> Task_Specific_Logic
+
+ click Configuration_Manager href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Configuration_Manager.md" "Details"
+
+ click Training_Orchestrator href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Training_Orchestrator.md" "Details"
+
+ click GFN_Algorithm_Implementations href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//GFN_Algorithm_Implementations.md" "Details"
+
+ click Environment_Simulator href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Environment_Simulator.md" "Details"
+
+ click Policy_Network href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Policy_Network.md" "Details"
+
+ click Data_Manager href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Data_Manager.md" "Details"
+
+ click Task_Specific_Logic href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Task_Specific_Logic.md" "Details"
+
+ click Conditional_Information_Handler href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Conditional_Information_Handler.md" "Details"
+
+ click Metrics_and_Evaluation href "https://github.com/recursionpharma/gflownet/blob/trunk/.codeboarding//Metrics_and_Evaluation.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `gflownet` project is structured as a modular Machine Learning Framework for Generative Models of Structured Data (Graphs), exhibiting clear separation of concerns across its core components. The architecture facilitates the development and experimentation of GFlowNet algorithms by providing distinct modules for configuration, training orchestration, algorithm implementation, environment simulation, policy modeling, data management, task-specific logic, conditional guidance, and performance evaluation.
+
+
+
+### Configuration Manager [[Expand]](./Configuration_Manager.md)
+
+Centralized management of hyperparameters and configuration settings, defining the operational parameters for the entire GFlowNet framework. It ensures consistent setup across all modules.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/config.py` (1:1)
+
+- `gflownet/algo/config.py` (1:1)
+
+- `gflownet/models/config.py` (1:1)
+
+- `gflownet/data/config.py` (1:1)
+
+- `gflownet/tasks/config.py` (1:1)
+
+- `gflownet/utils/config.py` (1:1)
+
+
+
+
+
+### Training Orchestrator [[Expand]](./Training_Orchestrator.md)
+
+Orchestrates the entire GFlowNet training process. It initializes and coordinates the interaction between algorithms, models, environments, and data to learn generative policies, managing the training loop, optimization, and logging.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/trainer.py` (1:1)
+
+- `gflownet/online_trainer.py` (1:1)
+
+
+
+
+
+### GFN Algorithm Implementations [[Expand]](./GFN_Algorithm_Implementations.md)
+
+Implements the core GFlowNet learning algorithms (e.g., Trajectory Balance, Flow Matching). These components define the specific loss functions and learning rules that guide the policy optimization based on collected trajectories.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/algo/*.py` (1:1)
+
+
+
+
+
+### Environment Simulator [[Expand]](./Environment_Simulator.md)
+
+Defines the state space, valid actions, and transition dynamics for building structured data (graphs, molecules, sequences). It simulates the generative process, allowing the GFlowNet to explore and construct data instances step-by-step.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/envs/*.py` (1:1)
+
+
+
+
+
+### Policy Network [[Expand]](./Policy_Network.md)
+
+Implements the neural network architectures (e.g., Graph Transformers, MXMNet, Sequence Transformers) that represent the GFlowNet policy. It takes the current environment state and conditional information as input and outputs predictions (e.g., action probabilities, state values) to guide the generative process.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/models/*.py` (1:1)
+
+
+
+
+
+### Data Manager [[Expand]](./Data_Manager.md)
+
+Handles the loading, sampling, and storage of data. This includes managing initial datasets (e.g., QM9) and maintaining replay buffers for experience replay, which are crucial for off-policy learning in GFlowNets.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/data/*.py` (1:1)
+
+- `gflownet/tasks/*.py` (1:1)
+
+
+
+
+
+### Task Specific Logic [[Expand]](./Task_Specific_Logic.md)
+
+Defines the specific objectives and reward functions for different GFlowNet applications (e.g., QM9 property prediction, molecule generation, sequence generation). It encapsulates the problem-specific evaluation of generated data and provides reward signals to the learning algorithms.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/tasks/*.py` (1:1)
+
+
+
+
+
+### Conditional Information Handler [[Expand]](./Conditional_Information_Handler.md)
+
+Generates, encodes, and transforms conditional information (e.g., temperature, multi-objective preferences, focus regions) that guides the GFlowNet's generative process. This allows for controlled and targeted generation of structured data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/utils/conditioning.py` (1:1)
+
+- `gflownet/utils/focus_model.py` (1:1)
+
+
+
+
+
+### Metrics and Evaluation [[Expand]](./Metrics_and_Evaluation.md)
+
+Computes and tracks various performance metrics, especially for multi-objective optimization (e.g., Hypervolume, IGD, HSR). It integrates with logging mechanisms to monitor training progress, evaluate model performance, and provide insights into the generative process.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/utils/metrics.py` (1:1)
+
+- `gflownet/utils/multiobjective_hooks.py` (1:1)
+
+
+
+
+
+### Core Utilities
+
+Provides a collection of general-purpose helper functions and foundational classes that support operations across the entire framework. This includes device management, random number generation, data transformations, multiprocessing wrappers, and basic logging functionalities.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `gflownet/utils/misc.py` (1:1)
+
+- `gflownet/utils/transforms.py` (1:1)
+
+- `gflownet/utils/sqlite_log.py` (1:1)
+
+- `gflownet/utils/multiprocessing_proxy.py` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file