SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Minsu Kim $^{1}$  Federico Berto $^{1}$  Sungsoo Ahn $^{2}$  Jinkyoo Park $^{1}$
$^{1}$ Korea Advanced Institute of Science and Technology (KAIST)
$^{2}$ Pohang University of Science and Technology (POSTECH)
{min-su, fberto, jinkyoo.park}@kaist.ac.kr
{sungsoo.ahn}@postech.ac.kr
We study the problem of optimizing biological sequences, e.g., proteins, DNA, and RNA, to maximize a black-box score function that is only evaluated in an offline dataset. We propose a novel solution, bootstrapped training of score-conditioned generator (BOOTGEN) algorithm. Our algorithm repeats a two-stage process. In the first stage, our algorithm trains the biological sequence generator with rank-based weights to enhance the accuracy of sequence generation based on high scores. The subsequent stage involves bootstrapping, which augments the training dataset with self-generated data labeled by a proxy score function. Our key idea is to align the score-based generation with a proxy score function, which distills the knowledge of the proxy score function to the generator. After training, we aggregate samples from multiple bootstrapped generators and proxies to produce a diverse design. Extensive experiments show that our method outperforms competitive baselines on biological sequential design tasks. We provide reproducible source code: https://github.com/kaist-silab/bootgen.
The automatic design of biological sequences, e.g., DNA, RNA, and proteins, with a specific property, e.g., high binding affinity, is a vital task within the field of biotechnology [5, 54, 41, 33]. To solve this problem, researchers have developed algorithms to optimize a biological sequence to maximize a score function [40, 9, 10, 2, 29]. Here, the main challenge is the expensive evaluation of the score function that requires experiments in a laboratory setting or clinical trials.
To resolve this issue, recent works have investigated offline model-based optimization [32, 21, 44, 52, 12, 45, MBO]. Given an offline dataset of biological sequences paired with scores, offline MBO algorithms train a proxy for the score function, e.g., a deep neural network (DNN), and maximize the proxy function without querying the true score function. Therefore, such offline MBO algorithms bypass the expense of iteratively querying the true score function whenever a new solution is proposed. However, even optimizing such a proxy function is challenging due to the vast search space over the biological sequences.
On the one hand, several works [21, 44, 52, 12] considered applying gradient-based maximization of the proxy function. However, when the proxy function is parameterized using a DNN, these methods often generate solutions where the true score is low despite the high proxy score. This is due to the fragility of DNNs against adversarial optimization of inputs [52, 44, 21]. Furthermore, the gradient-based methods additionally require reformulating biological sequence optimization as a continuous optimization, e.g., continuous relaxation [21, 44, 12] or mapping discrete designs to a continuous latent space [52].
On the other hand, one may consider training deep generative models to learn a distribution over high-scoring designs [32, 29]. They learn to generate solutions from scratch, which amortizes optimization over the design space.
To be specific, Kumar and Levine [32] suggests learning an inverse map from a score to a solution with a focus on generating high-scoring solutions. Next, Jain et al. [29] proposed training a generative flow network [7, GFN] as the generative distribution of high-scoring solutions.
Contribution In this paper, we propose a bootstrapped training of score-conditioned generator (BOOTGEN) for the offline design of biological sequences. Our key idea is to enhance the score-conditioned generator by suggesting a variation of the classical ensemble strategy of bootstrapping and aggregating. We train multiple generators using bootstrapped datasets from training and combine them with proxy models to create a reliable and diverse sampling solution.
In the bootstrapped training, we aim to align a score-conditioned generator with a proxy function by bootstrapping the training dataset of the generator. To be specific, we repeat multiple stages of (1) training the conditional generator on the training dataset with a focus on high-scoring sequences and (2) augmenting the training dataset using sequences that are sampled from the generator and labeled using the proxy function. Intuitively, our framework improves the score-to-sequence mapping (generator) to be consistent with the sequence-to-score mapping (proxy function), which is typically more accurate.
When training the score-conditioned generator, we assign high rank-based weights [46] to high-scoring sequences. Sequences that are highly ranked among the training dataset are more frequently sampled to train the generator. This leads to shifting the training distribution towards an accurate generation of high-scoring samples. Compared with the value-based weighting scheme previously proposed by Kumar and Levine [32], the rank-based weighting scheme is more robust to the change of training dataset from bootstrapping.
To further boost the performance of our algorithm, we propose two post-processing processes after the training: filtering and diversity aggregation (DA). The filtering process aims to filter samples from generators using the proxy function to gather samples with cross-agreement between the proxy and generator. On the other hand, DA collects sub-samples from multiple generators and combines them into complete samples. DA enables diverse decision-making with reduced variance in generating quality, as it collects samples from multiple bootstrapped generators.
We perform extensive experiments on six offline biological design tasks: green fluorescent protein design [54, GFP], DNA optimization for expression level on an untranslated region [41, UTR], transcription factor binding [5, TFBind8], and RNA optimization for binding to three types of transcription factors [33, RNA-Binding]. Our BOOTGEN demonstrates superior performance, surpassing the 100th percentile score and 50th percentile score of the design-bench baselines [45], a generative flow network (GFN)-based work [29] and bidirectional learning method (BDI) [12]. Furthermore, we additionally verify the superior performance of BOOTGEN in various design scenarios, particularly when given a few opportunities to propose solutions.
2.1 Automatic Design of Biological Sequences
Researchers have investigated machine learning methods to automatically design biological sequences, e.g., Bayesian optimization [50, 6, 36, 38, 43], evolutionary methods [3, 8, 18, 4, 40], model-based reinforcement learning [2], and generative methods [9, 32, 20, 29, 19, 11, 14]. These methods aim to optimize biological sequence (e.g., protein, RNA, and DNA) for maximizing the target objective of binding activity and folding, which has crucial application in drug discovery and health care [29].
2.2 Offline Model-based Optimization
Offline model-based optimization (MBO) aims to find the design  $x$  that maximizes a score function  $f(x)$ , using only pre-collected offline data. The most common approach is to use gradient-based optimization on differentiable proxy models trained on an offline dataset [49, 44, 52, 21, 12]. How-
Figure 2.1: Illustration of the bootstrapped training process for learning score-conditioned generator.
ever, they can lead to poor scores due to the non-smoothness of the proxy landscape. To address this issue, Trabucco et al. [44] proposed conservative objective models (COMs), which use adversarial training to create a smooth proxy. Yu et al. [52] suggests the direct imposition of a Gaussian prior on the proxy model to create a smooth landscape and model adaptation to perform robust estimation on the specific set of candidate design space. While these methods are effective for high-dimensional continuous design tasks, their performance on discrete spaces is often inferior to classical methods, e.g., gradient ascent [45].
2.3 Bootstrapping
Bootstrapping means maximizing the utilization of existing resources. In a narrow sense, it refers to a statistical method where the original dataset is repeatedly sampled to create various datasets [25]. In a broader sense, it also encompasses concepts frequently used in machine learning to improve machine learning scenarios where the label is expensive, e.g., self-training and semi-supervised learning [37, 1, 22]. These methods utilize an iterative training scheme to augment the dataset with self-labeled samples with high confidence.
The bootstrapping strategy at machine learning showed great success in various domains, e.g., fully-labeled classification [51], self-supervised learning [17] and offline reinforcement learning [48]. We introduce a novel bootstrapping strategy utilizing score-conditioned generators and apply it to offline biological sequence design, addressing the challenge of working with a limited amount of poor-quality offline datasets.
2.4 Design by Conditional Generation
Conditional generation is a promising method with several high-impact applications, e.g., class-conditional image generation [35], language-to-image generation [39], reinforcement learning [16]. With the success of conditional generation, several studies proposed to use it for design tasks, e.g., molecule and biological sequence design.
Hottung et al. [27] proposed an instance-conditioned variational auto-encoder [31] for routing problems, which can generate near-optimal routing paths conditioned on routing instances. Igashov et al. [28] suggested a conditional diffusion model to generate 3D molecules given their fragments. Specifically, the molecular fragments are injected into the latent space of the diffusion model, and the diffusion model generates links between fragments to make the 3D molecular compound.
3 Bootstrapped Training of Score-Conditioned Generator (BOOTGEN)
Problem definition We are interested in optimizing a biological sequence  $\pmb{x}$  to maximize a given score function  $f(\pmb{x})$ . We consider an offline setting where, during optimization, we do not have access to the score function  $f(\pmb{x})$ . Instead, we optimize the biological sequences using a static dataset  $\mathcal{D} = \{(x_{n},y_{n})\}_{n=1}^{N}$  consisting of offline queries  $y_{n} = f(x_{n})$  to the score function. Finally, we consider evaluating a set of sequences  $\{x_{m}\}_{m=1}^{M}$  as an output of offline design algorithms.
Overview of BOOTGEN We first provide a high-level description of our bootstrapped training of score-conditioned generator, coined BOOTGEN. Our key idea is to align the score-conditioned generation with a proxy model via bootstrapped training (i.e., we train the generator on sequences labeled using the proxy model) and aggregate the decisions over multiple generators and proxies for reliable and diverse sampling of solutions.
Algorithm 1 Boottrapped Training of Score-conditioned generators
1: Input: Offline dataset  $\mathcal{D} = \{\pmb{x}_n, y_n\}_{n=1}^N$ .  
2: Update  $\phi$  to minimize  $\sum_{(\pmb{x}, y) \in \mathcal{D}} (f_\phi(\pmb{x}) - y)^2$ .  
3: for  $j = 1, \dots, N_{\text{gen}}$  do  
4: Initialize  $\mathcal{D}_{\text{tr}} \gets \mathcal{D}$ .  
5: for  $i = 1, \dots, I$  do  
6: Update  $\theta_j$  to maximize  $\sum_{(\pmb{x}, y) \in \mathcal{D}_{\text{tr}}} w(y, \mathcal{D}_{\text{tr}}) \log p_{\theta_j}(\pmb{x} | y)$ .  
7: Sample  $\pmb{x}_\ell^* \sim p_{\theta_j}(\pmb{x} | y^\dagger)$  for  $\ell = 1, \dots, L$ .  
8: Set  $y_\ell^* \gets f_\phi(x_\ell^*)$  for  $\ell = 1, \dots, L$ .  
9: Set  $\mathcal{D}_{\text{aug}}$  as top- $K$  scoring samples in  $\{\pmb{x}_\ell^*, y_\ell^*\}_{\ell=1}^L$ .  
10: Set  $\mathcal{D}_{\text{tr}} \gets \mathcal{D}_{\text{tr}} \cup \mathcal{D}_{\text{aug}}$ .  
11: end for  
12: end for  
13: Output: trained score-conditioned generators  $p_{\theta_1}(\pmb{x} | y), \dots, p_{\theta_{N_{\text{gen}}}}(\pmb{x} | y)$ .
Before BOOTGEN training, we pre-train proxy score function  $f_{\phi}(\pmb{x}) \approx f(\pmb{x})$  only leveraging offline dataset  $\mathcal{D}$ . After that, our BOOTGEN first initializes a training dataset  $\mathcal{D}_{\mathrm{tr}}$  as the offline dataset  $\mathcal{D}$  and then repeats the following steps:
A. BootGen optimizes the score-conditioned generator  $p_{\theta}(\pmb{x}|\pmb{y})$  using the training dataset  $\mathcal{D}_{\mathrm{tr}}$ . During training, it assigns rank-based weights to each sequence for the generator to focus on high-scoring samples.
B. BOOTGEN bootstraps the training dataset  $\mathcal{D}_{\mathrm{tr}}$  using samples from the generator  $p_{\theta}(\boldsymbol{x}|y^{\dagger})$  conditioned on the desired score  $y^{\dagger}$ . It uses a proxy  $f_{\phi}(\boldsymbol{x})$  of the score function to label the new samples.
After BOOTGEN training for multiple score-conditioned generators  $p_{\theta_1}(\pmb{x}|y), \dots, p_{\theta_n}(\pmb{x}|y)$ , we aggregate samples from the generators with filtering of proxy score function  $f_{\phi}$  to generate diverse and reliable samples. We provide the pseudo-code of the overall procedure in Algorithm 1 for training and Algorithm 2 for generating solutions from the trained model.
3.1 Rank-based Weighted Training
Here, we introduce our framework to train the score-conditioned generator. Our algorithm aims to train the score-conditioned generator with more focus on generating high-scoring designs. Such a goal is helpful for bootstrapping and evaluation of our framework, where we query the generator conditioned on a high score.
Given a training dataset  $\mathcal{D}_{\mathrm{tr}}$ , our BOOTGEN minimizes the following loss function:
$$
\mathcal {L} (\theta) := - \sum_ {(\boldsymbol {x}, y) \in \mathcal {D} _ {\mathrm {t r}}} w (y, \mathcal {D} _ {\mathrm {t r}}) \log p _ {\theta} (\boldsymbol {x} | y), \quad w (y, \mathcal {D} _ {\mathrm {t r}}) = \frac {(k | \mathcal {D} _ {\mathrm {t r}} | + \operatorname {r a n k} (y , \mathcal {D} _ {\mathrm {t r}})) ^ {- 1}}{\sum_ {(\boldsymbol {x} , y) \in \mathcal {D} _ {\mathrm {t r}}} (k | \mathcal {D} _ {\mathrm {t r}} | + \operatorname {r a n k} (y , \mathcal {D} _ {\mathrm {t r}})) ^ {- 1}}.
$$
where  $w(y, \mathcal{D}_{\mathrm{tr}})$  is the score-wise rank-based weight [46]. Here,  $k$  is a weight-shifting factor, and  $\mathrm{rank}(y, \mathcal{D}_{\mathrm{tr}})$  denotes the relative ranking of a score  $y$  with respect to the set of scores in the dataset  $\mathcal{D}_{\mathrm{tr}}$ . We note that a small weight-shifting factor  $k$  assigns high weights to high-scoring samples.
For mini-batch training of the score-conditioned generator, we approximate the loss function  $\mathcal{L}(\theta)$  via sampling with probability  $w(y,\mathcal{D}_{\mathrm{tr}})$  for each sample  $(x,y)$ .
We note that Tripp et al. [46] proposed the rank-based weighting scheme for training unconditional generators to solve online design problems. At a high level, the weighting scheme guides the generator to focus more on generating high-scoring samples. Compared to weights that are proportional to scores [32], using the rank-based weights promotes the training to be more robust against outliers, e.g., samples with abnormally high weights. To be specific, the weighting factor  $w(y,\mathcal{D})$  is less affected by outliers due to its upper bound that is achieved when  $\mathrm{rank}(y,\mathcal{D}) = 1$ .
Algorithm 2 Aggregation Strategy for Sample Generation
1: Input: Trained score-conditioned generators  $p_{\theta_1}(\pmb{x}|y), \dots, p_{\theta_{N_{\mathrm{gen}}}}(\pmb{x}|y)$ , and trained proxy function  $f_{\phi}(\pmb{x})$ .  
2: Initialize  $\mathcal{D}_{\mathrm{samples}} \gets \emptyset$ .  
3: for  $i = 1, \dots, N_{\mathrm{gen}}$  do  
4: Sample  $\pmb{x}_m^* \sim p_{\theta_i}(\pmb{x}|y^\dagger)$  for  $m \in [M]$ .  
5: Set  $y_m^* \gets f_{\phi}(x_m^*)$  for  $m \in [M]$ .  
6: Set  $\mathcal{D}_{\mathrm{sub-samples}}$  as Top-  $K$  scoring samples in  $\{\pmb{x}_m^*, y_m^*\}_{m=1}^M$ .  
7: Set  $\mathcal{D}_{\mathrm{samples}} \gets \mathcal{D}_{\mathrm{samples}} \cup \mathcal{D}_{\mathrm{sub-samples}}$   
8: end for  
9: Output:  $\mathcal{D}_{\mathrm{samples}}$ .
3.2 Bootstrapping
Next, we introduce our bootstrapping strategy to augment a training dataset with high-scoring samples that are collected from the score-conditioned generator and labeled using a proxy model. Our key idea is to enlarge the dataset so that the score-conditioned generation is consistent with predictions of the proxy model, in particular for the high-scoring samples. This enables self-training by utilizing the extrapolation capabilities of the generator and allows the proxy model to transfer its knowledge to the score-conditioned generation process.
We first generate a set of samples  $\pmb{x}_1^*, \dots, \pmb{x}_L^*$  from the generator  $p_{\theta}(\pmb{x}|y^{\dagger})$  conditioned on the desired score  $y^{\dagger 1}$ . Then we compute the corresponding labels  $y_1^*, \dots, y_L^*$  using the proxy model, i.e., we set  $y_{\ell} = f_{\phi}(\pmb{x}_{\ell})$  for  $\ell = 1, \dots, L$ . Finally, we augment the training dataset using the set of top-  $K$  samples  $\mathcal{D}_{\mathrm{aug}}$  with respect to the proxy model, i.e., we set  $\mathcal{D}_{\mathrm{tr}} \cup \mathcal{D}_{\mathrm{aug}}$  as the new training dataset  $\mathcal{D}_{\mathrm{tr}}$ .
3.3 Aggregation Strategy for Sample Generation
Here, we introduce additional post-hoc aggregation strategies that can be used to further boost the quality of samples from our generator. See Algorithm 2 for a detailed process.
Filtering We follow Kumar and Levine [32] to exploit the knowledge of the proxy function for filtering high-scoring samples from the generator. To be specific, when evaluating our model, we sample a set of candidate solutions and select the top samples with respect to the proxy function.
Diverse aggregation To enhance the diversity of candidate samples while maintaining reliable generating performances with low variance, we gather cross-aggregated samples from multiple score-conditioned generators. These generators are independently trained using our proposed bootstrapped training approach. Since each bootstrapped training process introduces high randomness due to varying training datasets, combining the generative spaces of multiple generators yields a more diverse space compared to a single generator.
Moreover, this process helps reduce the variance in generating quality. By creating ensemble candidate samples from multiple generators, we ensure stability and mitigate the risk of potential failure cases caused by adversarial samples. These samples may receive high scores from the proxy function but have low actual scores. This approach resembles the classical ensemble strategy known as "bagging," which aggregates noisy bootstrapped samples from decision trees to reduce variances.
We present experimental results on six representative biological sequence design tasks to verify the effectiveness of the proposed method. We also conduct ablation studies to verify the effectiveness of each component in our method. For training, we use a single GPU of NVIDIA A100, where the training time of one generator is approximately 10 minutes.
$^{1}$ Following Chen et al. [12], we assume that we know the maximum score of the task.
Table 4.1: Experimental results on 100th percentile scores. The mean and standard deviation are reported for 8 independent solution generations.  $\mathcal{D}$  (best) indicate the maximum score of the offline dataset. The best-scored value is marked in bold.
Method	RNA-A	RNA-B	RNA-C	TFBind8	GFP	UTR	Avg.
D (best)	0.120	0.122	0.125	0.439	0.789	0.593	0.365
REINFORCE [45]	0.462 ± 0.080	0.437 ± 0.033	0.463 ± 0.043	0.936 ± 0.041	0.865 ± 0.003	0.685 ± 0.012	0.643
CMA-ES [24]	0.841 ± 0.058	0.822 ± 0.046	0.803 ± 0.039	0.904 ± 0.040	0.055 ± 0.003	0.737 ± 0.013	0.694
BO-qEI [50]	0.724 ± 0.055	0.729 ± 0.038	0.707 ± 0.034	0.798 ± 0.083	0.254 ± 0.352	0.684 ± 0.000	0.649
CbAS [9]	0.541 ± 0.042	0.647 ± 0.057	0.644 ± 0.071	0.913 ± 0.025	0.865 ± 0.004	0.692 ± 0.008	0.717
Auto. CbAS [20]	0.524 ± 0.055	0.562 ± 0.031	0.495 ± 0.048	0.890 ± 0.050	0.865 ± 0.003	0.693 ± 0.009	0.672
MIN [32]	0.376 ± 0.039	0.374 ± 0.041	0.404 ± 0.047	0.892 ± 0.060	0.865 ± 0.001	0.691 ± 0.011	0.600
Grad [45]	0.821 ± 0.048	0.720 ± 0.047	0.688 ± 0.035	0.965 ± 0.030	0.862 ± 0.003	0.682 ± 0.013	0.792
COMs [44]	0.403 ± 0.062	0.393 ± 0.076	0.494 ± 0.098	0.945 ± 0.033	0.861 ± 0.009	0.699 ± 0.011	0.633
AdaLead [42]	0.691 ± 0.059	0.630 ± 0.062	0.605 ± 0.055	0.962 ± 0.024	0.841 ± 0.014	0.631 ± 0.010	0.727
GFN-AL [29]	0.630 ± 0.054	0.677 ± 0.079	0.623 ± 0.045	0.956 ± 0.018	0.059 ± 0.006	0.695 ± 0.021	0.607
BDI [12]	0.700 ± 0.000	0.560 ± 0.000	0.632 ± 0.000	0.973 ± 0.000	0.864 ± 0.000	0.667 ± 0.000	0.733
BOOTGEN	0.902 ± 0.039	0.931 ± 0.055	0.831 ± 0.044	0.979 ± 0.001	0.865 ± 0.000	0.865 ± 0.000	0.895
Table 4.2: Experimental results on 50th percentile scores. The mean and standard deviation are reported for 8 independent solution generations.  $\mathcal{D}$  (best) indicate the maximum score of the offline dataset. The best-scored value is marked in bold.
Method	RNA-A	RNA-B	RNA-C	TFBind8	GFP	UTR	Avg.
D (best)	0.120	0.122	0.125	0.439	0.789	0.593	0.365
REINFORCE [45]	0.159 ± 0.011	0.162 ± 0.007	0.177 ± 0.011	0.450 ± 0.017	0.845 ± 0.003	0.575 ± 0.018	0.395
CMA-ES [24]	0.558 ± 0.012	0.531 ± 0.010	0.535 ± 0.012	0.526 ± 0.017	0.047 ± 0.000	0.497 ± 0.009	0.449
BO-qEI [50]	0.389 ± 0.009	0.397 ± 0.015	0.391 ± 0.012	0.439 ± 0.000	0.246 ± 0.341	0.571 ± 0.000	0.406
CbAS [9]	0.246 ± 0.008	0.267 ± 0.021	0.281 ± 0.015	0.467 ± 0.008	0.852 ± 0.004	0.566 ± 0.018	0.447
Auto. CbAS [20]	0.241 ± 0.022	0.237 ± 0.009	0.193 ± 0.007	0.413 ± 0.012	0.847 ± 0.003	0.563 ± 0.019	0.420
MIN [32]	0.146 ± 0.009	0.143 ± 0.007	0.174 ± 0.007	0.417 ± 0.012	0.830 ± 0.011	0.586 ± 0.000	0.383
Grad [45]	0.473 ± 0.025	0.462 ± 0.016	0.393 ± 0.017	0.513 ± 0.007	0.763 ± 0.181	0.611 ± 0.000	0.531
COMs [44]	0.172 ± 0.026	0.184 ± 0.039	0.228 ± 0.061	0.512 ± 0.051	0.737 ± 0.262	0.608 ± 0.000	0.407
AdaLead [42]	0.407 ± 0.018	0.353 ± 0.029	0.326 ± 0.019	0.485 ± 0.013	0.186 ± 0.216	0.592 ± 0.002	0.392
GFN-AL [29]	0.312 ± 0.013	0.300 ± 0.012	0.324 ± 0.009	0.538 ± 0.045	0.051 ± 0.003	0.597 ± 0.021	0.354
BDI [12]	0.411 ± 0.000	0.308 ± 0.000	0.345 ± 0.000	0.595 ± 0.000	0.837 ± 0.010	0.527 ± 0.000	0.504
BOOTGEN	0.707 ± 0.005	0.717 ± 0.006	0.596 ± 0.006	0.833 ± 0.007	0.853 ± 0.017	0.701 ± 0.004	0.731
4.1 Experimental Setting
Tasks. We evaluate an offline design algorithm by (1) training it on an offline dataset and (2) using it to generate 128 samples for high scores. We measure the 50th percentile and 100th percentile scores of the generated samples. All the results are measured using eight independent random seeds.
We consider six biological sequence design tasks: green fluorescent protein (GFP), DNA optimization for expression level on untranslated region (UTR), DNA optimization tasks for transcription factor binding (TFBind8), and three RNA optimization tasks for transcription factor binding (RNA-Binding-A, RNA-Binding-B, and RNA-Binding-C). The scores of the biological sequences range in [0, 1]. We report the statistics of the offline datasets used for each task in Table A.1. We also provide a detailed description of the tasks in Appendix A.1.
Baselines We compare our BOOTGEN with the following baselines: gradient ascent with respect to a proxy score model [45, Grad.], REINFORCE [49], Bayesian optimization quasi-expected-improvement [50, BO-qEI], covariance matrix adaptation evolution strategy [24, CMA-ES], conditioning by adaptive sampling [9, CbAS], autofocused CbAS [20, Auto. CbAS], model inversion network [32, MIN], where these are in the official design bench [45]. We compare with additional baselines of conservative objective models [44, COMs], generative flow network for active learning [29, GFN-AL] and bidirectional learning [12, BDI].