BioPlanner: Automatic Evaluation of LLMs on Protocol Planning in Biology
Authors: Odhran ODonoghue
Aleksandar Shtedritski
John Ginger
Ralph Abboud
Ali Essam Ghareeb
Samuel G Rodriques
Venue: EMNLP 2023 Main (2023)
Keywords: LLMs
GPT-4
Science
Biology
Evaluation

Abstract: The ability to automatically generate accurate protocols for scientific experiments would represent a major step towards the automation of science. Large Language Models (LLMs) have impressive capabilities on a wide range of tasks, such as question answering and the generation of coherent text and code. However, LLMs can struggle with multi-step problems and long-term planning, which are crucial for designing scientific experiments. Moreover, evaluation of the accuracy of scientific protocols is challenging, because experiments can be described correctly in many different ways, require expert knowledge to evaluate, and cannot usually be executed automatically. Here we present an automatic evaluation framework for the task of planning experimental protocols, and we introduce BioProt: a dataset of biology protocols with corresponding pseudocode representations. To measure performance on generating scientific protocols, we use an LLM to convert a natural language protocol into pseudocode, and then evaluate an LLM's ability to reconstruct the pseudocode from a high-level description and a list of admissible pseudocode functions. We evaluate GPT-3 and GPT-4 on this task and explore their robustness. We externally validate the utility of pseudocode representations of text by generating accurate novel protocols using retrieved pseudocode, and we run a generated protocol successfully in our biological laboratory. Our framework is extensible to the evaluation and improvement of language model

BioPlanner: Automatic Evaluation of LLMs on Protocol Planning in Biology
Odhran O'Donoghue 12,
Aleksandar Shtedritski 1,2,4
John Ginger
Ralph Abboud 1.2
Ali Essa Ghareeb2
Samuel G Rodriques
Align Innovate
Francis Crick Institute
Future House
*University of Oxford
Abstract
Title
Description
Title
Description
Step-by-step Instructions
The ability automatically generate accurate protocols for scientific experiments would rep- resent a major step towards the automation of science. Large Language Models (LLMs) have impressive capabilities on a wide range of tasks, such as question answering and the generation of coherent text and code. However, LLMs can struggle with multi-step problems and long- term planning, which are crucial for designing scientific experiments. Moreover, evaluation of the accuracy of scientific protocols is chal- lenging, because experiments can described correctly in many different ways, require ex- pert knowledge to evaluate, and cannot usually be exccuted automatically. Here present an automatic evaluation framework for the task of planning experimental protocols, and we intro- duce BIOPROT': dataset of biology proto- cols with corresponding pseudocode represen- tations. measure performance on generating scientific protocols, use an LLM to convert natural language protocol into pseudocode, and then evaluate an LLM's ability reconstruct the pseudocode from high-level description and a list admissible pseudocode functions. We evaluate GPT-3 and GPT-4 on this task and explore their robustness. We externally vali- date the utility of pscudocode representations of text by generating accurate novel protocols using retrieved pseudocode, and we run a gen- erated protocol successfully in our biological laboratory. Our framework is extensible to the evaluation and improvement of language model planning abilities in other areas of science or other areas that lack automatic evaluation.
Psaudofunctions
Pseudofunctions
Step-by-step pseudocode
Step-by-step
pseudocode
copy
evailuate
Figure 1: Automatic evaluation of protocol genera- tion. The teacher model is given full information about a scientific experiment protocol - title, description, and step-by-step instructions. It is prompted to generate pseudo functions that allow the execution of the proto- col. The student model given admissible pesudo- functions and is evaluated its ability to generate the step-hy-step pseudocode.
ducibility, and scalability, contributing to more sci- entific breakthroughs and faster transition from research to real-world applications.
One important step towards automation of bi- ology research is the automated generation of a laboratory protocol (Accurate step-by-step instruc- tions on how to complete an experiment to accom- plish a specific goal) which can subsequently be converted into robot code. LLMs have significant latent scientific knowledge and thus may be able formulate accurate scientific protocols, which has been demonstrated for the field of chemistry (Bran ct al., 2023; Boiko et al., 2023). However, to to-date there has not been any clear way to evaluate the ac- curacy of generated scientific protocol, except by manual evaluation. Without established evaluation metrics, progress in the field of automating science remains challenging.
1 Introduction
Traditional manual methods for research in biology are time-consuming, labour-intensive. and highly prone human error. Robotic laboratory automa- tion has the potential to increase accuracy, repro-
'The dataset and code for evaluation are available at https:/ / /ttpttgtttttbbbb com/ htc//booplli hngplaaaerbbbolaaneeee
Evaluating laboratory protocols is difficult for

---

two reasons. Firstly, protocols are very sensi- tive to tiny details, and slight variations in in- structions can lead to significantly different out- comes. When comparing generated protocols against ground truths, metrics that rely on n-gram overlaps such as BLEU (Papineni et al., 2002) or contextual embeddings such as BERTScore (Zhang et al., 2019) might not capture small differences, such the order of actions, relation between substances (Bhandari et al., 2020). Secondly, the same protocol can be described correctly at various levels of granularity. The same technique (e.g. sc- quencing library preparation) can be described by a single line or multiple paragraphs. This variabil- ity in granularity makes it difficult to evaluate the accuracy of LLM-generated protocols.
such as next-step prediction, or full protocol gener- ation. We further show the utility of this dataset by automatically designing and successfully executing a lab experiment using GPT-4 and the action space defined using BIOPROT.
In summary, we make the following contribu- tions: (i) We propose evaluating protocol gener- ation on pseudocode rather than free text instruc- tions; (ii) We introduce the BiOPROT dataset, a manually audited dataset of open-access biology protocols; (iii) We evaluate the ability of GPT-4 to accurately convert natural language protocols into pseudocode; (iv) We define a suite of tasks and metrics for evaluating protocol generation; (v) We evaluate several LLMs on our tasks to provide objective measures of these models' ability to gen- erate biological experiments; (vi) We automatically generate a biology experiment and successfully ex- ecute it in lab.
We here present an automated approach to eval- uating the ability of language model to write biological protocols. Our approach is inspired by robotic planning, in which closed set of ad- missible actions is provided to controller agent (Jiménez et al., 2019; Ahn et al., 2022; Huang et al., 2022). We use GPT-4 to automatically convert a written protocol into pseudocode using a protocol- specific set of pseudofunctions that is generated by the model (see Figure 1). Here, a "teacher" model generates the admissible action set and correct an- swer in terms of step-by-step pseudocode. Having access to this privileged information, we can then evaluate the performance of a "student", that has to solve the task from scratch. In this way, we then evaluate the ability of language models to generate a protocol when presented only with the appropri- ate pseudocode functions and a short description of the protocol. In effect, our approach allows us to automatically convert the process of writing scien- tific protocol into series of multiple-choice ques- tions (i.e., pick a pseudofunction from a provided set), which can be evaluated much more robustly than natural language generation. This paradigm al- lows us to rapidly measure the protocol knowledge of GPT-3.5 and GPT-4 with minimal human inter- vention, and can serve as general approach for evaluating and improving long-horizon planning in open-ended tasks in the future.
Related Works
LLMs for Natural Sciences Using LLM for sci- entific tasks such as entity extraction in biologi- cal documents (Tamari et al., 2021) or retrieval of chemical reaction procedures (Bai et al., 2022) is a natural use case of such models. Work such as SciBERT, BioGPT, Galactica and others have also shown the utility of pretraining an LLM on a corpus of biomedical (Gu et al., 2021: Lewis et al., 2020; Luo et al., 2022; Lee et al., 2020; Shin et al., 2020) or general scientific text (Beltagy et al., 2019; Tay- lor et al., 2022). More recently, pre-trained gener- alist LLMs such as GPT-3 (Brown et al., 2020) and GPT-4 (OpenAT, 2023) have shown be capable of tasks such as searching for chemical compounds similar to given one (OpenAI, 2023) or drug edit- ing (Liu et al., 2023c). Furthermore, a GPT-4 agent augmented with tools has been shown to be capa- ble of synthesis planning and drug discovery (Bran et al., 2023) planning reactions and executing them on a robotic platform (Boiko et al., 2023).
Task Decomposition LLMs trained on next- token prediction can struggle with more complex logical reasoning in naïve setups (Liu et al., 2023b). However, decomposing complex tasks into sub- tasks in frameworks such Chain-of-Thoughh reasoning (Wei et al., 2022: Zhang et al., 2023), and its variants such Least-to-Most (Zhou al., 2022) and Tree of Thought reasoning (Yao et al., 2023) improves performance in multi-step reason- ing problems. In addition to test-time improve-
To this end, also introduce novel dataset, BIOPROT, of publicly available biology laboratory protocols, containing instructions in both free text and protocol-specific pseudocode. The dataset has been reviewed by domain experts and allows evalu- ation of model performance several different tasks,

---

ments, LLMs also improve in performance when trained on step-by-step reasoning data generated by larger LLMs (Mukherjee et al., 2023; Mu et al., 2023). Task decomposition has also been combined with self-verification through deductive reasoning to improve step-by-step reasoning accuracy (Ling et al., 2023). Here, we approach task decomposi- tion from another angle- we first ask the model to define discrete set of actions needed to complete a task, and then how to compose them.
Automatic Evaluation of LLMs While evalua- tion of the performance of an LLM in games (Wang et al., 2023a) or planning in PDDL domains (Silver et al., 2023) can be done automatically, many works rely on self-evaluation, where GPT-4 is used as an evaluator (Bubeck et al., 2023; Bran et al., 2023; Chiang et al., 2023; Peng et al., 2023; Zhou et al.. 2023). However, these have been found to con- tradict human evaluation (Bran al., 2023) be systematically biased (Wang et al., 2023b), where the order of the provided responses affects the pre- dicted ranking. In comparison to these works, we use an LLM to generate sneudo-grounng truth data on an easy task, in which the model consistently performs well at, which we use to evaluate on a more difficult task with real-world implications.
Planning Closely related task decomposition is planning. LLMs have been successful at plan- ning in simulated and real embodied space, both through the use of restricted action space (Ahn et al., 2022; Driess et al.. 2023), function/tool search (Wang et al., 2023a; Schick et al., 2023; Shen et al., 2023; Bran et al., 2023; Boiko et al., 2023) and translation of plans into admissible ac- tion space (Huang et al., 2022). Planning mod- els have been explicitly combined with Chain-of- Thought reasoning for performance improvement (Mu et al., 2023; Shen et al., 2023). LLM plan- ners can also learn to create their own training curriculum and refine their function use (Wang et al., 2023a). LLM-based planning and reasoning can benefit from writing problems in machine- readable language such Planning Domain Defi- nition Language (PDDL) and symbolic logic (Pan al., 2023; Silver et al., 2023). Furthermore, in- teractions with simulators and debuggers can be used to improve both plans (Liu et al., 2023a) and value functions that determine the appropriateness of action calls (Ahn et al., 2022; Driess et al., 2023; Mu et al., 2023). Our work extends recent work in planning through the automated generation of ad- missible action spaces and consequent evaluation without the need for simulation environment.
The BIOPROT dataset
Here we describe the BIOPROT dataset- a collec- tion of publicly available protocols that are used to evaluate the performance of LLMs on protocol generation on large range of topics in biology. We discuss the contents of the dataset (Section 3.1), creating
of admissible actions and translating the protocol steps (Section 3.2), manual verifica- tion of the data (Section 3.3), and the tasks that can be approached with it (Section 4). The dataset can be found in the Supplementary Materials. This ap- proach can be used to generate pseudocode datasets in any domain that has step-by-step instructional data.
3.1 A Dataset of Protocols for Biology
We collect publicly available protocols from Pro- tocols.io (Teytelman et al., 2016), platform for developing and sharing reproducible methods. This database contains over 9,000 public protocols of different scientific areas and complexity. Each pro- tocol consists of (i) a title, (ii) description, and (iii) step-by-step instructions. We automatically and manually filter the protocols, in order to ob- tain set of protocols that are related to biology, can be reproduced, and are of sufficient difficulty. For further details about the filtering, refer the Supplementary Materials. In Table we present summary of the collected protocols.
Evaluating LLM Scientists Evaluating LLMs on scientific tasks is limited QA benchmarks for measuring general science knowledge (Hendrycks et al., 2020), or specialist knowledge such as chem- istry (Guo et al., 2023; Wu et al., 2017), biomed- ical science (Sung et al., 2021) or medicine (Jin et al., 2019, 2021). However, evaluating an LLM''s performance on more open-ended tasks, such as healthcare support (Dash al., 2023) or chemical synthesis planning (Bran et al., 2023) is done man- ually. To the best of our knowledge, we are the first to approach automatic evaluation of LLMs on open-ended problems in science.
3.2 Translating Protocols to Pseudocode
As discussed in Section 1, evaluation of planning problems is difficult natural text, and prior works opt for manual evaluation (Bran et al., 2023; Boiko

---

Protocol
Generated Pseudocode
Pseudofunctions
def transfer_ Masue (tube_ valum))
transfer ttubue volure):
Fitter Hornwort extr
pass
Sescriptions The preetophytic ttasue of hernwrtss is rich in pe belysancharides te et al.. seno; and wisn seers rich polyphosettcs. Both compounds
incubate wwwpleeeaaaaaaeooe (incubat ioncaaattoooopeerreeeeoo por_para
cet incuhate (fncutatin parans):
pass
pasa
def und_and Leant, wis rnthhod) pans
def apin_semple (apiiparosss:
cef spinuseep (emplee(xpnnppareeee
Protscol:
pass
pass
2. Gri 9.3-2 of sissue uning and pustll in the pr ssunce retrrggen... extraction
def
buffer and 289 is PVp-49/5 clasus (Apl. of muse A (160ag/w13).
grtnd tissue vefghtenng 5-2 g", thur
Pseudocode instructions
grine cissue (ttosue weighta"s, E"; aut
3.
transter esssue (tube volurentao ai?)
Ligutd at onttregent)
lsqund istregent))
und usk lon for (buf for, sol_oolllstt ei"; hitfer teeperature-naa '0")
trasster stesue vo volure-ta ni")
Prompt
duufferryoluueell nt", terperaturee Te", pvn pmn.anight wglp tissuet, volungersylf and mnt ( (xollvett ml chlorufore:tad (2421)", mixing nethod=") "ethod""imersttnn" nverston")
excraccccn,
Ground truth
pep pvo_weighes pa/s tissuet,
"sul")
add wrel teclsstteee (oatoveett-- chlorofom: IAA (24113", eixing wwwthood" "iverstto)))))""""
stalogy protozols into python pseutocode.
Pare is an exuppe of
Figure 2: Creation of pseudofunction and pseudocode data The model is prompted generate pseudofunctions and pseudocode based on target protocol. This generated code is automatically debugged using a feedback error loop, and then manually reviewed. Generated pseudofunctions are used to define the admissible action space in downstream evaluation tasks, and pseudocode instructions using the pseudofunction calls used as ground truth to measure the accuracy of generated code in downstream tasks, enabling automatic evaluation.
Statistic
Value
Statistic
Value
Protocols
100
Avg. number of pscudofunctions per protocol
10.3
Average number of steps
12.5
Avg. number pseudofunctions per step
0.82
Average total protocol length in tokens
641.0
Avg. number of lines of pscudocode
17.2
Average tokens per step
52.6
Table 2: Pseudocode Statistics We present aggregate statistics about the automatically generated pseudofunc- tions and pseudocode.
Average tokens per original deseription
83,8
Average tokens per generated description
66.3
Table 1: Dataset Statistics We present aggregate statis- ties for the BIoPROT dataset. The "generated descrip- tions" are generated using GPT-4 from the step-by-step instructions, as discussed in Section 5.4.
3.3 Manual Verification
We manually reviewed the generated pseudofunc- tions and pseudocode for accuracy. Original proto- cols and generated ground-truth pseudocode were assessed line-by-line by competent laboratory sci- entist. They confirmed (i) whether the original nat- ural language protocol made sense, (ii) whether the title and description sufficiently described the pro- tocol so that a competent scientist could attempt to complete without the protocol, and (iii) whether the pseudocode was accurate. Finally, edits were made to the generated pseudocode as necessary. We show a breakdown of the edits made in Table 3.
et al., 2023). To this end, we "translate" the free text protocols into pseudocode using GPT-4 (see Figure 2). We task GPT-4 to (i) define set of pseudofinctions that suffice to execute the protocol, and (ii) convert the protocol steps into pseudocode using only the provided pseudofunctions.
We make use of a one-shot example prompt, and an automatic feedback loop (Liu et al., 2023a) that provides error signals if: the generated code is not valid Python pseudocode; no pseudofunctions are defined; the pseudocode or pseudofunctions do not have arguments; any numerical parameters in the pseudocode do not have units. Finally, GPT- 4 is prompted to check for errors or omissions in the pseudofunctions and pseudocode. Information about our generated pseudocode summarized in Table 2.
Statistic
Value
% generated protocols requiring no edits
59
% generated protocols with 1 5 3 edited lines
24
% generated protocols with > edited lines average number of line edits in edited files
11.8
Table 3: Manual Verification We provide breakdown of the protocols that required manual edits.

---

Overall, 59 of the 100 protocols were found to be completely accurate requiring no edits. How- ever, many protocols that did require edits only required minor edits. The most common errors found were missing units for numbers, which in most cases would not prevent a competent scientist from completing a protocol. The more impactful er- rors found were most commonly (1) missing details to successfully complete
where fried and fer are the predicted and groundtruth functions, respectively, and N is the number of steps in the protocol.
During generation, the model is prompted name each function argument and provide the ar- gument parameters. To evaluate accuracy of the arguments, we first check whether the function ar- gument names is correct. For that purpose, we com- pute precision and recall of the arguments' names. For correct function arguments, we consider the ac- curacy of the argument value using the BLEU met- ric (Papineni et al., 2002). Additionally, we encode the predicted and ground truth argument values, af apred and a. respectively, with SciBERT (Belt- agy et al., 2019) sentence encoder & to get the ScoBERTscore:
which would allow a step of the protocol (these were usually highly verbose steps which explained a detailed technical method for manipulating a sample) and (2) not ex- plaining the composition of a material used in the protocol (e.g. buffer).
The corrected protocols are made available as the BIOPROT dataset. Even without human editing, LLMs with error-checking loops can be used to cre- ate largely accurate dataset for biology protocol pseudocode, thus enabling self-evaluation.
N (E(a) ) E(aTT)) N (a )T
SciBERTscore
3.4 Machine-generated Descriptions
which is the average cosine similarity between predicted and ground truth argument values for all N steps. This metric is inspired by BERTScore (Zhang et al., 2019), but we use a SciB- ERT encoder as it is better suited to the scientific domain. We only compute argument-level metrics for correctly predicted functions, as not to penalize the model twice for wrong function predictions.
For some of our downstream tasks, it is necessary to have high-quality descriptions of protocols that give sense of what the protocol steps should in- clude. However, protocol descriptions in Proto- cols.io are not always suitable for this purpose. To this end, we also generated descriptions of pro- tocols that provided a high-level overview of the protocols' objective (the prompt for this is seen in the Supplementary Materials). We include both our machine-generate descriptions and the original descriptions in our dataset.
Protocol Generation Given protocol title, de- scription, and admissible set of pseudofunctions, the model is tasked to generate corresponding pseu- docode. We again evaluate the correctness of pre- dicted functions and their corresponding arguments. This is a more difficult task than the previous one, as the model needs to plan the entire execution of the protocol. For function-level evaluation, we need to measure (i) if the correct functions called, and (ii) if they were used in the correct order, For the former, we report precision and recall of function calls, where we take into account repeated calls of the same function. For evaluating whether the functions are used in the correct order, we use the Levenshtein distance La between the predicted and ground- sequence of functions. The Lev- enshtein distance is originally string edit distance that measures the number of insertions, deletions, or substitutions make one word into another. We consider each function call as a separate symbol, which incurs cost of I for being added, deleted, or substituted. We report a normalized Levenshtein
4 Metrics and evaluation
Using the BIOPROT dataset, evaluate an LLM's capabilities to reason about and generate scientific protocols on several different tasks.
Next Step Prediction Given protocol title, de- scription, an admissible set of pseudofunctions, and partially completed pseudocode, we evaluate the model's ability to correctly identify the pseudofunc- tion corresponding to the next step in the protocol. We evaluate the correctness of both the predicted function and the function arguments.
For leveti accuracy, we report the per- centage of the number of correct function assign- ments
p = (.
accuracy
N

---

Functions Accuracy
Arguments SciBERTScore
Model
Shuffle
Precision
Recall
BLEU
GPT-3.5
X
65, + 1.3
97.7 0,5
94.7 + 0.5
88.5 0.5
0.363 + 0.012
GPT-3.5
V
36.1 1.6
97.1 1.2
95.1 1: 1.0
88.6 0.5
0.384 0.028
GPT-4
X
70.6 0.4
97.1 + 0.5
94.9 + 0.6
87.9 + 0.5
0,351 + 0.017
GPT-4
/
0.
97.1 0.4
94.7 +:
88.5
0.363 0.025
Table Next Step Prediction Evaluation Given a protocol title and description, the admissible pseudofunctions and partially completed pseudocode, evaluate the model'' ability to correctly predict the next step. For all metrics, higher is better. We report mean and standard deviation over 5 runs.
distance dnn
generated, randomly shuffled. The func- tions tend be defined in the order they ap- pear in the original protocol, and that serves as a signal to the model we evaluate. By ran- domly shuffling the input functions, we make the task more difficult.
Cd N
d
where is the number of functions the ground- truth pscudocode.
In addition, we evaluate the predicted function
arguments. We use the same metries as described under "Next Step Prediction".
The model has access to ror loop that can detect undefined functions and Python syntax errors. Such feedback loops have been found to beneficial PDDL planning (Silver et al., 2023) and rea- soning (Madaan et al., 2023).
Feedback:
Function Retrieval Our approach has the poten- tial to allow novel protocols to be assembled from steps provided existing protocols the dataset, if the model is able to correctly identify which steps are needed for any given protocol. Thus, given protocol title and description, and a set of pseud- ofunctions, evaluate the models' ability cor- rectly identify which of the provided functions are needed execute the protocol. this lask, we pro- vide the model with a set of pseudofunctions con- sisting of the ground-truth pseudofunctions for the given protocol, and pseudofunctions drawn from several (i) random or (ii) nearest neighbour proto- cols. Providing functions from nearest neighbour protocols is more difficult, they are likely to be more similar to the correct functions. We measure the precision and recall of retrieved functions.
5.2 Results
Next step prediction We show results on next step prediction in Table 4. We see that GPT-4 consistently outperforms GPT-3.5 in both the pre- diction of the correct next step, whereas GPT-3.5 performs better at predicting function arguments. We note there is drop in performance when the input functions are shuffled, likely because if not shuffled, the functions appear roughly in the order as they should be called as they were sequentially generated by the LLM.
Protocol generation We show results on full pro- tocol generation Table 5. We observe the biggest gap in the Levenshtein distance score metric, where GPT-4 significantly outperforms GPT-3.5, Mean- while, GPT-4 and GPT-3.5 show similar precision and recall of used functions. This suggests that while both have similar ability use the correct functions, GPT-4 performs better at using the right order. We also observe that shuffling the input func- tions consistently leads to drop in performance.
5 Experiments
5.1 Implementation details
We explore the performance of GPT-3.5 and GPT-4 from the OpenAl API. Where we find nearest neigh- bors, use embedding index of all protocols' descriptions using text-embedding- -ateeedddnn--d---0- em- beddings, unless stated otherwise. We show the prompts we use in the Supplementary Material.
For each of the tasks listed in Section 4, we evaluate the models in several settings:
Function retrieval We show retrieval results in Table 6. We see that GPT-4 outperforms GPT-3.5 on this task. However, the results on this task ap- pear generally poor. One possible reason for the
Shuffled: the model can be provided either with functions in the order which they are

---

Functions Recull
Arguments
Model
Shuffle
Feedback
Precision
Cán
Precision
Recall
SciBERTScore
BLEU
GPT-3.5
93.4
0.9
89.9 +
0.498
0.06
72.7 # 0.
91.4 + 1.5
82.7 # 0.6
0.121 0.005
GPT-3.5
93.3
1.0
91.1 + 1.1
0.505 + 0.19
73.1 + 1.6
88.1 + 1.9
82.8 + 0.6
0.117 + 0.006
GPT-3.5
91.8 + 0.8
85.9 + 28
0,945 a 0055
72.9 = 144
89.1 2.2
81.8 0.2
0.102 = 0.003
GPT-3.5
92.5 1 0.3
86.1 1 L6
0.884 a 0045
73.2
4 1.3
87.3 3.5
82.3 a 0.4
0.102 1: 0.009
GPT44
0.9
90.8
0.396 0046
72.2 + 0.8
94.7 +
82.6
0.124 0.006
GPT44
92.5
90.1
0.438
72.0
9
82.7 =
0.112
GPT-4
92.6
87.7
0.722
72.2
94.6
82.7
0.113
GPT-4
92.8
86.6
0.685
0.198
73.7
82.5
0.108
Table 5: Protocol Gemeration Evaluation Given protocol title and description, and a set of admissible pseudo- functions, we evaluate the model performance on full protocol generation. For all metrics higher values are better, except for the normalized Levenshtein distance L.m, where lower values are better. Best performance is bolded and second best is underlined. We report mean and standard deviation over 5 runs.
Model
Neighbourhood
Precision
Recall
5.4
Using GPT-4-Generated Descriptions
GPT-3.5
Nearest
24.2
35.7
For some protocols, we observe that the detail present in the protocol description does not suffice to enable protocol reconstruction. To this end, we use GPT-4 to generate a short pseudo description given the protocol steps in natural text. We present results on next step generation and full protocol generation in Figure 8. We see a small increase in performance, which is expected, the summary- generating model can include more detail (however, the pseudo descriptions are shorter see Table 2).
GPT-3.5
Random
36.7
45.2
GPT-4
Nearest
32.5
39.2
GPT-4
Random
48.8
49.4
Table 6: Function retrieval. Performance function retrieval of pseudofunctions from the query protocol, as well as (i) random or (ii) nearest neighbors protocols.
poor performance is that the correct answer may sometimes be ambiguous. For example, Mix and MixSubstance semantically identical, but have different syntax, and the model would be penalized for selecting function from the query proto- col. This effect would explain why performance using nearest" neighbours is worse than per- formance when using "random" protocols.
5.5 Real-World Validation
Finally, to validate that BIOPROT can be used to generate accurate novel protocols, we devised a setup for end-to-end protocol creation. To do this opted build an LLM agent with access tools, such that it can retrieve protocols that con- tain relevant pscudofunctions, and use their pscud- ofunctions to generate new pseudocode. Note that for good performance in this real-world validation task, the LLM needs to be able to (1) find rele- vant psueodofunctions from other protocols, and (2) generate correct pseudocode, both of which are tasks we build metrics for. Details are as follows: we created Toolformerllike (Schick al., 2023) chain-of-thought LLM agent (Wei et al., 2022) with access to a tool for searching for protocols the BIOPROT database. This agent used the GPT-4 LLM. We prompted the agent to retrieve protocols relevant to generating a new target protocol. We extracted the pscudofunctions from the retrieved protocols and then prompted the agent generate new protocol using only the retrieved pseudofunc- tions. We used this setup to create two experiments using GPT-4: (1) culturing single colony of E.coli bacteria overnight and making a glycerol stock with
5.3 Using GPT-4 as an evaluator
We use GPT-4 as an evaluator, where given (i) protocol description, (ii) admissible pseudofunc- tions, (iii) ground-truth pseudocode (generated as described in Section 3.2), and (iv) predicted pseu- docode, the model prompted predict which one of (iii) or (iv) better matches the protocol descrip- tion (i). We report the rate at which the predicted pseudocode was preferred in Table 8. In general, GPT-4 only performs slightly above chance in iden- tifying the ground truth protocol, versus LLM gen- erations, although it is unclear whether this is be- cause the machine-genen generateddredd protocols largely correct, because GPT-4 is unable distinguish correct from incorrect protocols. Note that prior works (Bran et al., 2023) found that a GPT evalu- ator tends to prefer longer and more coherent, but not necessarily more correct generations.

---

Description generated
Functions
Arguments
Model
Accuracy
Precision
Recall
Lan 4
Precision
Recall
SciBERTScore
BLEU
GPT-4
46.1
98.1
95.6
88.9
0.334
GPT-4
48.4
98.4
95.1
90.0
0.393
GPT-4
91.1
90.1
0.49
71.8
95.5
84.1
0.126
GPT-4
92.2
90.3
0.45
73.3
95.8
0.122
Table 7: Using GPT-4 generated deseription We compare performance on next step prediction (top) and protocol generation (bottom) when using protocol description generated by (i) scientists, or (ii) GPT-4. We that using GPT-4 generated description consistently outperforms the original one. The input pseudofunctions to the model are shuffled and we use feedback loop.
Model
Shuffle
Feedback
GPT-4 score t
GPT-3.5
35.6
GPT-3.5
x
/
40.2
GPT-3.5
40.9
GPT-3.5
V
V
39.3
GPT-4
x
43.9
GPT-4
X
42.4
GPT-4
40.9
GPT-4
42.4
Table 8: GPT-4 as an evaluator. The GPT-4 score shows the rate at which GPT-4 predicted the model's output to be better than the ground truth.
the suspension (a form of cryopreservation for long- term storage), and (2) culturing Symbiodinum (a large genus of dinoflagellates endosymbiontic to cnidarians that may help corals survive in warming oceans), extracting its DNA, and then running the DNA on an agarose gel.
Figure 3: E.coli growing nutrient agar plates. We carried out protocol for overnight culture and cryop- reservation of E.coli glycerol for long-term storage. One hour after completion of the protocol, the cells were thawed and spread onto the surface of nutrient agar. Af- 10 hours they be seen growing the surface of the agar plate (top) plate, while there is no growth on control (no E.coli) plate (bottom). This shows the ALM-generaad protocol was correct.
5.6 Real-World Validation Results
The model generated two new protocols using pseudofunctions from our database. Both of these protocols were reviewed by scientist and were determined to be accurate and sufficient for com- petent lab scientist follow. We opted complete the first protocol using E.coli as we did not have Symbiodinium available the laboratory. We val- idated the first protocol by implementing it in the lab with the instructions and parameter values pro- vided by the model. The protocol ran successfully: the cells remained viable after storage -80 OC, as evidenced by subsequent culture nutrient agar (see Figure 3). The methods and prompts used to generate these experiments, as well as the agent thouugh reasoning, can be found in the Appendix.
Conclusion
We have introduced method for automatic evalu- ation of LLMs on open- planning problems, such as those found in experimental sciences, and a dataset of such planning problems biology lab- oratory protocols. We then defined a suite of tasks and evaluation metrics that can be used to measure performance and help drive progress in the field. We evaluate GPT-3.5 and GPT-4 on these tasks and find that there is more to be desired in terms of performance. Finally, we show an application of our dataset and framework, where LLM gener- ates a protocol that is successfully executed in a laboratory.

---

7 Limitations
Daniil A Boiko, Robert MacKnight, and Gabe Gomes. 2023. Emergent autonomous scientific research ca- pabilities of large language models. arXiv preprint arXiv:2304.05332.
Use of paid API The GPT-4 and GPT-3.5 models we use are not open-sourced and can have signif- icant costs for large-scale experiments. In total, we used approximatcly $1000 for API calls. Fur- ther work should explore the performance of open- sourced LLMs.
Andres M Bran, Sam Cox, Andrew D White, and Philippe Schwaller. 2023. Chemerow: Augmenting lange-lnggggg models with chemistry tools. arXiv preprint arXiv:2304.05376.
Additional scientific fields Our work is focused on biology, but could be extended to other fields such as chemistry and materials science. Future works should explore extending the dataset and framework.
Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020. Language models are few-shot learners. Advances in neural information processing systems, 1377197-1901.
Misuse There is a risk of misuse, where adver- saries could use our framework or dataset to inform the synthesis of harmful compounds. We have taken care ensure the protocols in BIOPROT con- tain no protocols that can easily be used for such purposes. Continued research on aligning LLMS and restriction of dangerous outputs important to minimize risk. We hope that our approach of using pseudofunctions may in the future allow for easier programmatic evaluation of outputs, and easier de- tection of the generation of hazardous substances.
Sébastien Bubeck, Varun Chandrasekaran, Ronen EI- dan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott Lund- berg, et al. 2023. Sparks of artificial general intelli- gence: Early experiments with gpt-4, arXiv preprint 1rXiv:2303.12712
Wei-Lin Chiang. Zhuohan Li, Zi Lin, Ying Sheng, Zhanghao Wu, Hao Zhang, Lianmin Zheng, Siyuan Zhuang, Yonghao Zhuang. Joseph E. Gonzalez, lon Stoica, and Eric P. Xing. 2023. Vicuna: An open- source chatbot impressing gpt-4 with 90%* chatgpt quality.
Debadutta Dash, Rahul Thapa, Juan M Banda, Akshay Swaminathan, Morgan Cheatham, Mehr Kashyap. Nikesh Kotecha, Jonathan H Chen, Saurabh Gom- bar, Lance Downing, al. 2023. Evaluation of gpt-3,5 and gpt-4 for supporting real-world infor- mation needs in healthcare delivery. arXiv preprint arXiv:2304.1 13714.
References
Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Keerthana Gopalakrishnan, Karol Hausman, Alex Herzog, et al. 2022. Do as can, not as i say: Ground- ing language in robotic affordances. arXiv preprint arXiv:2204.01691.
Danny Driess, Fei Xia, Mehdi SM Sajjadi, Corey Lynch, Aakanksha Chowdhery, Brian Ichter, Ayzaan Wahid, Jonathan Tompson, Quan Vuong, Tianhe Yu, et al. 2023. Palm-e: An embodied multimodal language model. arXiv preprint arXiv:2303.03378.
Fan Bai. Alan Ritter, Peter Madrid, Dayne Freitag. and John Nickrasz. 2022. SynKB: Semantic search for synthetic procedures. In Proceedings of the 2022 Conference on Empirical Methods Natural Lan- guage Processing: System Demonstrations, pages 311-318, Abu Dhabi, UAE Association for Compu- tational Linguistics.
Yu Gu, Robert Tinn. Hao Cheng. Michael Lucas, Naoto Usuyama, Xiaodong Liu, Tristan Naumann, Jianfeng Gao, and Hoifung Poon. 2021. Domain-specific lan- guage model pretraining for biomedical natural lan- guage processing. ACM Transactions Computing for Heealtharee (HEAL.HH) 3(1):1-23.
Iz Beltagy, Kyle Lo, and Arman Cohan. 2019. SciBERT:
A pretrained language model for scientific text. In Proceedings of the 2019 Conference Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP)) Hong Kong, Chima. Association for Computational Linguistics.
Taicheng Guo, Kehan Guo, Bozhao Nan, Zhenwen Liang. Zhichun Guo, Nitesh Chawla, Olaf Wiest, and Xiangliang Zhang. 2023. What indeed can gpt models do in chemistry? comprehensive benchmark on eight tasks.
Manik Bhandari, Pranav Narayan Gour, Atabak Ash- faq. Pengfei Liu, and Graham Neubig. 2020. Re- evaluating evaluation in text summarization. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 9347-9359 Online, Association for Computa- tional Linguistics.
Stefan Hegselmann, Alejandro Buendia, Hunter Lang. Monica Agrawal, Xiaoyi Jiang. and David Sontag. 2023. Tabllm: Few-shot classification of tabular data with large language models. In International Conference on Artificial Intelligence and Statistics. pages 5549-5581. PML.R.

---

Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. 2020. Measuring massive multitask language under- standing. arXiv preprint arXiv:2009. 03300.
Rengian Luo, Liai Sun, Yingce Xia, Tao Qin, Sheng Zhang, Hoifung Poon, and Tin Liu. 2022. Biogpt: generative pre-trained transformer for biomedical text generation and mining. Briefings in Bioinformatics, 23(6).
Wenlong Huang, Pieter Abbeel, Deepak Pathak, and Igor Mordatch. 2022. Language models as zero-shot planners: Extracting actionable knowledge for em- bodied agents. In International Conference on Ma- chine Learning. pages 91 9118-9147. PMLR.
Aman Madaan, Niket Tandon, Prakhar Gupta. Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye. Yiming Yang. et al. 2023. Self-refine: Iterative refinement with self-feedback. arXiv preprint arXiv:2303.17651.
Sergio Jiménez, Javier Segovia-Aguu and Anders Jon- sson. 2019. A review of generalized planning. The Knowledge Engineering Review, 34:c5.
Yao Mu, Qinglong Zhang, Mengkang Hu, Wenhai Wang. Mingyu Ding, Jun Jin, Bin Wang, Jifeng Dai. Yu Qiao, and Ping Luo. 2023. Embodiedgpt: Vision- language pre-training via embodied chain of thought. arXiv preprint arXiv:2305. 15021.
Di Jin, Eileen Pan, Nassim Oufattoee. Wei-Hung Weng. Hanyi Fang, and Peter Szolovits. 2021. What disease does this patient have? a large-scale open domain question answering dataset from medical exams. Ap- plied Sciences, 1 (1)441.4.
Subhabrata Mukherjee, Arindam Mitra, Ganesh Jawa- har, Sahaj Agarwal, Hamid Palangi. and Ahmed Awadallah. 2023, Orca: Progressive learning from complex explanation traces of gpt-4, arXiv preprint 2.X.:23006.02077.
Qiao Jin, Bhuwan Dhingra, Zhengping Liu, William Cohen, and Xinghua Lu. 2019. PubMedQA: dataset for biomedical research question answering. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Lan- guage Processing (EMNLP-IJCNLP), pages 2567- 2577, Hong Kong, China. Association for Computa- tional Linguistics.
OpenAL. 2023. Gpt-4 technical report.
Liangming Pan, Alon Albalak, Xinyi Wang, and William Yang Wang. 2023. Logic-Im: Empower- ing large language models with symbolic solvers for faithful logical reasoning.
Kishore Papineni, Salim Roukos, Todd Ward, and Wei- Jing Zhu. 2002. Bleu: a method for automatic evalu- ation of machine translation. In Proceedings of the 40th Annual Meeting of the Association for Compu- tational Linguistics, pages 311-318, Philadelphia. Pennsylvania, USA. Association for Computational Linguistics.
Jinhyuk Lee, Wonjin Yoon, Sungdong Kim, Donghyeon Kim, Sunkyu Kim, Chan Ho So, and Jaewoo Kang. 2020. Biobert: pre-trained biomedical language representation model for biomedical text mining. Bioinformatiic,,
134--1240.
Patrick Lewis, Myle Ott, Jingfei Du, and Veselin Stoy- anov. 2020. Pretrained language models for biomedi- cal and clinical tasks: Understanding and extending the state-of-the-art. In Proceedings of the 3rd Clini- cal Natural Language Processing Workshop. Online. Association for Computational Linguistics.
Baolin Peng, Chunyuan Li, Pengcheng He, Michel Gal- ley, and Jianfeng Gao. 2023. Instruction tuning with gpt-4, arXiv preprint arXiv:2304.0322
Timo Schick, Jane Dwivedi- Yu, Roberto Dessi, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language models can teach themselves to use tools. arXiv preprint arXiv:2302.0477
Zhan Ling, Yunhao Fang, Xuanlin Li, Zhiao Huang. Mingu Lee, Roland Memisevic, and Hao Su. 2023. Deductive verification of chain-of-thought reasoning. arXiv preprint arXiv:2306.03872.
Yongliang Shen, Kaitao Song, Xu Tan, Dongsheng Li, Weiming Lu, and Yueting Zhuang. 2023. Hugging- gpt: Solving ai tasks with chatgpt and its friends in huggingface. arXiv preprint arXiv:2303. 1.200.17540 17580.
Bo Liu, Yuqian Jiang, Xiaohan Zhang, Qiang Liu, Shiqi Zhang, Joydeep Biswas, and Peter Stone. 2023a. Lim+ p: Empowering large language models with optimal planning proficiency. arXiv preprint S.Xiv:2004.11477.
Hoo-Chang Shin, Yang Zhang, Evelina Bakhturina, Raul Puri. Mostofa Patwary, Mohammad Shocybi, and Raghav Mani. 2020. Biomegatron: Larger biomedical domain language model. arXiv preprint 2ki:2000000606)
Hanmeng Liu, Ruoxi Ning, Zhiyang Teng. Jian Liu, Qiji Zhou, and Yue Zhang. 2023b. Evaluating the logical reasoning ability of chatgpt and gpt-4.
Shengehao Liu, Jiongxiao Wang, Yijin Yang. Cheng- peng Wang. Ling Liu, Hongyu Guo, and Chaowei Xiao. 2023c. Chatgpt-powered conversational drug editing using retrieval and domain feedback. arXiv preprint arX5v 18090.
Tom Silver, Soham Dan, Kavitha Srinivas, Joshua B Tenenbaum, Leslie Pack Kaelbling, and Michael Katz, 2023. Generalized planning in pddl do- mains with pretrained large language models. arXiv preprint arXiv:2305.11 1001..

---

Mujeen Sung, Jinhyuk Lee, Sean Yi, Minji Jeon, Sung- dong Kim, and Jaewoo Kang. 2021. Can language models be biomedical knowledge bases? arXiv
Chunting Zhou, Pengfei Liu, Puxin Xu, Srini lyer, Jiao Sun, Yuning Mao, Xuezhe Ma, Avia Efrat. Ping Yu, Lili Yu, al. 2023. Lima: Less is more for alignment. arXiv preprint arXiv:2305. //206.
preprint arXiv:2 2tt::2099001544
Ronen Tamari, Fan Bai, Alan Ritter, and Gabriel Stanovsky. 2021. Process-level representation of scientific protocols with interactive annotation. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Lin- guisticy: Main Volume, pages 2190-2202, Online. Association for Computational Linguistics.
Denny Zhou, Nathanacl Schärli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Olivier Bousquet, Quoe Le, and Edd Chi. 2022. Least-to-movt prompting enables complex reason- ing in large language models. arXiv preprint arXi::220..10625.
Ross Taylor, Marcin Kardas, Guillem Cucurull, Thomas Scialom, Anthony Hartshom, Elvis Saravia, Andrew Poulton, Viktor Kerkez, and Robert Stojnic. 2022. Galactica: A large language model for science. arXiv preprint 0ate:2211.0905.
Leonid Teytelman, Alexei Stoliartchouk, Lori Kindler, and Bonnie L Hurwitz. 2016. Protocols. io: virtual communities for protocol development and discus- sion. PLoS Biology, 14(8)c 1002538.
Hugo Touvron, Louis Martin, Kevin Stone, Peter Al- hert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. 2023. Llama Open founda- tion and fine-tuned chat models. arXiv preprint arXiv:2307.09228.
Guanzhi Wang. Yuqi Xie, Yunfan Jiang, Ajay Man- dlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and An- ima Anandkumar, 2023a. Voyager: An open-ended embodied agent with large language models. arXiv preprint arXiv:2305.162
Peiyi Wang. Lei Li, Liang Chen, Dawei Zhu, Binghuai Lin, Yunho Cao, Qi Liu, Tianyu Liu, and Zhifang Sui. 2023b. Large language models are not fair evaluators. arXiv preprint arXiv: 17926.
Jason Wei, Xuezhi Wang. Dale Schuurmans, Maarten Bosma, Ed Chi, Quoc Le, and Denny Zhou. 2022. Chain of thought prompting elicits reasoning large language models. arXiv preprint arXiv:2201. 1903..
Zhenqin Wu, Bharath Ramsundar, Evan Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S. Pappu, Karl Leswing, and Vijay Pande. 2017. Moleculenet: A benchmark for molecular machine learning.
Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas Griffiths. Yuan Cao. and Karthik Narasimhan. 2023. Tree of thoughts: Deliberate problem solving with large language models. arXiv preprint a305 10601.
Tianyi Zhang, Varsha Kishore, Felix Wu, Kilian Q Weinberger, and Yoav Artzi. 2019. Bertscore: Eval- uating text generation with bert. arXiv preprint arXiv:1904.09675.
Zhuosheng Zhang, Aston Zhang, Mu Li, Hai Zhao, George Karypis, and Alex Smola. 2023. Multi- modal chain-of-thoughh reasoning language mod- els. arXiv preprint arXiv:2302.00923.

---

BioPlanner: Automatic Evaluation of LLMs on Protocol Planning in Biology
Appendix
A Dataset Filtering
C Qualitative Evaluation
We filter Protocols.io io protocols such that (i) they be parsed and provided they are sufficiently challenging serve as an eval- uation set. We performed the following automatic and mamual filtering:
We show qualitative results for protocol id 145 from BIOPROT. For further qualitative examples, please refer to the BIOPROT dataset.
LLM, and (ii)
Title Ethanol precipitation of nucleic acids (Ep- pendorf tubes)
Automatic filtering Protocols were automati- cally removed if they:
Description Nucleic acid precipitation is used to concentrate and/or purify nucleic acids. The be- low protocol is based on the fact that nucleic acids are less soluble in alcohol than in more polar wa- Addition of salt further decreases solubility by competing for water dipoles; as does low temper- ature. Please see the Open WetWare website for more details.
Do not contain a description
Contain linked files that could not be parsed
Contain images that could not be parsed by text-only models
Contain tables (standard LLMs can sometimes struggle with table-based data representations without few-shot examples (Hegselmann et al., 2023))
Steps
1. Add 1/10 volume of 3M sodium acetate, pH 5.2 1/2 volume of 5M ammonium acetate. reagents
Consist of fewer than three steps (such pro- tocols were insufficiently complex demon- strate multi-step planning)
2. Add 2-3 volumes of 100% Ethanol.
Following automatic filtering, protocols were manually removed if they:
Manual filtering
Mix and freeze overnight in -20. NOTES In general, the time you need to incubate the freezer depends on how much nucleic acid you have, how big is and the volume is in. My general protocol is to freeze for 20 min to hr at -80C. This seems work well for most things, but you may want to freeze longer if you have only small concentration of nucleic acid if it small in size(<15 nucleotides). (Kathleen) NOTES you are a hurry, you can also dip you epi shortly into liquid nitrogen. If you added enough ethanol, the mix won't freeze. Careful with isopropanol freezes more quickly. This works well for me and saves me lengthy incubation in the fridge. (Jasu)
Were not relevant to biology
Were considered poorly written to the extent that a human could not accurately replicate the protocol
B Prompts
B.1
Main experiments
We show the prompts we use for generating pseud- ofunctions and pseudocode in Figure 6, predict- ing pseudocode in Figure summarising protocol steps in Figure 8. We show the error messages we use in the feedback loops in Figure 9. Figure 12, and the resulting generated protocol used in our real-world experiment is found in Figure 13
B.2
Lab experiments
4. Spin at full speed in standard microcen- trifuge at 4 degrees for 30 minutes. 1800s
Here we show the prompts we use in Section 5 of the paper. Figure 10 is the prompt provided to the CoT agent. Figure 11 shows the Langchain out- put form the agent. Figure 12 shows the prompt that contains the retrieved pseudofunctions. Fi- nally, Figure 13 shows the pscudocode that was given to a biologist to execute in a laboratory.
5. Decant (or carefully pipet off) the supernatant.
6. Dry the pellet. NOTES For this you can air dry (tubes open, 15 min) or dry in a speedvac. DNA and RNA (if you don't have RNases in your sample) are typically hearty

---

Functions Recall
Arguments
Model
Shuffle
Feedback
Precision
Las +
Precision
Recall
SciBERTScore
BLEU
Llama2-7B
x
x
83.6
49.8
0.74
76.2
41.4
79.8
0.048
Llama2-7B
x
v
81.0
45.9
0.82
70.4
42.9
80.4
0.050
Llamma-7B
X
82.2
45.1
0.63
70.7
43.8
81.3
0.051
Llama2-7B
78.5
30.4
0,56
73.0
51.4
81.1
0.047
Table 9; Evaluating Llama on Protocol Generation Evaluation Given protocol title and description, and a set of admissible pseudofunctions, we evaluate model performance on full protocol generation. For metries higher values are better, except for the normalized Levenshtein distance L.m, where lower values are better.
Model
Neighbourhood
Precision
Recall
evaluation tasks on Llama-2 (Touvron et al., 2023).
We evaluate the 7B model and report performance on protocol generation and function retrieval in Ta- ble 9 and Table 10, respectively. We found that Llama-2 significantly underperforms GPT-3.5 and GPT-4 models in function selection. As part of our evaluation Llama-2 observe that, when using feedback, the model is distracted and does not tempt to re-write code. Iterative feedback appears to be a process that is effective for GPT models and not Llama models, and this observation is consis- tent with prior work (Madaan et al., 2023). We also ran Llama-2 on the next step prediction task, but we found that the model was unable to complete this task. The model would typically produce text that states an intent complete the pseudocode rather than writing the actual next pseudocode line. This difference in behaviour likely due to a dif- ference training regimes between GPT models and Lllama-2, but given the lack of documentation around the training of GPT models, the precise nature of this difference is unknown.
LLamm2-7B
Ncarest
26.1
57.5
LLama2-7B
Random
28.1
56.3
Table 10: Evaluating Llama on Function retrieval. Performance on function retrieval of pseudofunctions from the query protocol, as well as (i) random (ii) nearest neighbors protocols.
enough for you to air dry at 37C, desired. NOTES Overdrying can make DNA hard to re- dissolve. Especially for longer DNA, I avoid vacuum drying and airdry only briefly before re-dissolving. (Jasu)
7. Add your desired quantity of water. Vortex and spin down to resuspend. NOTES Beware of using water unless you are sure of what you are getting in to. The "pH" of water widely (I've seen from pH 5 to pH 8.5), and depurination of DNA at low pH or degradation of RNA at high pH are possibilities. Water also typically contains trace metals, which can accelerate these reactions. typicallly recom- mend resuspension in TE (10 mM Tris-HCI, pH 7.5, mM EDTA). This makes sure your nucleic acid is at neutral pH and the EDTA will chelate any trace metals. Since they are in such small amounts, neither the buffer the EDTA will affect most downstream reactions. (Kathleen)
vary
E Dataset and Evaluation
The BIOPROT dataset and evaluation met- rics from this paper be found
F Human Benchmarking
While we believe our metric is internally useful for comparing the performance of LLM models and approaches, we wanted to assess how our tasks used relate to human performance. To this end, we performed a human evaluation of next-step predic- tion tasks and function selection tasks. We worked with undergraduate biomedical sciences student and asked them to complete the next step predic- tion task and the function selection task. The stu- dent had access internet search and an unlim- ited amount of time to answer questions. With the next step prediction task we provided shuffled
Generated Pseudocode and Pseudofunctions We show the generated pseudocode and pseudo- functions, which we use as ground truth, in Fig- ure 4
Predicted Protocol We show the predicted pro-
tocol in Figure 5
D LLama evaluation
To benchmark performance on open-source mod- els, we also conducted run of our experimental

---

functions, and with the function selection task, used random distractor functions. For the func- tion selection task, Human Precision was 87.5%, and human Recall was 0.84%, (n=20), indicating a significant increase performance over GPT-4. GPT-4 performance is potentially weaker than hu- man performance in the function selection task due to the large number of nearest-neighhour functions in the context window acting distractors from the task instructions. For the next step prediction task human accuracy was 54.8% (n=32), with Pre- cision and Recall or arguments being 97% and 95% respectively. This performance roughly compa- rable to GPT-4 in the shuffled function setting.

---

Functions def add_satt(solution, salt, volume_ratio): pass
add_ (solutio,, volunes_ethanoU;;
pass
def mix_solurtinnlsolutiin::
def fncubbte_.reeeeesslluciio temperature, time):
pass
def spin_tube(solution,, spin_parans):
pass
def renove renove_supernatane (sgeuraattttttttssltttooooo
pass
try_pelletpeellt, method, time): pass
def resuspend_pelletipeeee solvent, volune): pass
Protocol. steps
salt-"3M sodiun acetate, pH 5.2", volunc_ratio-1/10) volumes_ethanot-2) mix sow.uuuoonlsluutiooomuttiaiiiiaa soluttooloio""
add_ethanol(ss
temperature- 20, time-"overnighht)
spin_parans-"full speed, degrees, 39 minutes") "ccistiioccidssstttoon"""
renave
mry_pellletpeellet===eeele""" nethod="air_dry"!
time=">15 nin")
solvent="TE_buffer,, velume="desired volune")
end protecol
Figure 4: Generated pseudofunctions and pseudocode. Given the protocol title, description, and free text step-by-step instructions, we generate pseudocode and pseudofunctions.
raM protocol
add_ ook_sattiseluriioo/nnneeeees secp salt="0.3 Sodiun Acetate 6.2 NoCL", vo velune_ration"118 of 'the solution vo volune")
volumes_ethenol=2.5)
incubste_ wwwp://tooooonccilceeeeiiiiiiiia solduttttoo,, temperature=/-za9rh, time="30 minutes to ovemightt))
lution", parappaaans 4TC, vinutes")
renove_super (orprrattttttttttoonnninttaa sottttli
add, ethanohaallee ltwlaaatainn"""pelll"""""" [esuumes_ehhaaatll
nix, www.coluuioonsslutiooo.oo sttaio/ossottttooppeptttt"t
renove, supernatarttsluutinnnptttt paraas-"12,
tubel subeessauriionnpppllii
ninutes")
dry. pelppelettppeleet"ppptttec. nethod="air dry centrifuge", tine="soproxinntely (nnutee")
solvent=/vater or TE buffer", appropitae for downstrean applications")
Figure 5: Predicted pseudocode. Given protocol title, description, and an admissible set pscudofunctions, a model predicts pseudocode. This coresponds the pseudofunctions in Figure 4.

---

groouddrruthpprooa
Your goal is to convert nolecular biology protocols into python pseudocade.
EXAMPLE
Here is example how convert protocol for (example dedscrptiiosiii
example protocol:
(example protacal steps)
ex python pseudocode:
eexemple_sseuoofunctiiosss
# Protocol steps
YOUR
Here is a molecular biology protocol entitled '(tite))' The protocol steps are as follows:
(protocol)
Please convert this protocol into python pseudocode. Please define the python functions will the start of the pscudocode, and that these functions have parameters where appropriate.
python pseudocode:
Figure 6: Prompt for generating pseudofunctions and pseudocode.
pseudocode_prompt
Your goal is generate python pseudocode for molecular biology psotocols. This pseudocode must accurately describe a complete scientific protocol to obtain result, and must only use pre-defined list of pseudocode functions.
Here is an example of how to generate pseudocode for molecular biology protocol.
EXAMPLE:
(example title)
Here are some extra details about the protocol:
(example details}
example pseudocode:
(example pseudacade)
YOUR TASK:
Generate pseudocode for protocal for (title).
Here are some extra details about the protocol:
{details)
You may only make of the following python pseudocode functions:
{psuedofunctions)
your tMeudocode:
Figure Prompt for predicting pseudocode.

---

summary_prompe
Here is molecular biology protocol entitled '(title)',
Here is the protocol abstract:
(description)
The protocol steps are as follows:
{protocol_steps
Please provide 2 sentence sunmary of the objective of this scientific protocol."" -..
Figure Prompt for summarizing a protocol.
error_ error_messages
"IndentationError": "IndentationError: There are indentation errors in one or \ more of your function definitions. Functions should have at least one indented This can simply be return or pass
that has code and not comments statement.",
"SyntaxError": "SyntaxError: There are syntax errors in one or more of your function definitions in your main code.",
MooParamttersWarninng "NoParaneteersaarning One or more of your functions does not \ have any parameters. Functions typically have parameters to better describe the \ experiment.",,
"ComnentError"; "CommentError: Your function includes comment docstring. Functions should be named to sufficiently describe their purpose without the need for comments. A Please remove the comment docstring and try again. Consider renaming function A better describe its purpose.",
"Missingunitslarnnnng: "WissingUnnttswernnn::: One or more of your function parameter \ calls include numbers but do not include the units for said numbers. You may be missing units that important for describing the experiment.", "NofunctionsErroo": "NoFunctionsError: There do not appear to any functions in your \ code. Please define functions",
"NewFunctionError": "NewFunctionError: You have defined new function. Please only the pseudofunction provided.",
"NottainCodeErro"" "NoMaanCooeEEroo: You have not written any pseudocode in the main code section.", inndeciineFunntionnnn "undefineduncctionErro:: You have used function that is defined fseudofunctions provided.",
"wissingunitswarrinn""" "MissingUnitswarninng One or more of your function parameter \ calls include numbers but do not include the units for said numbers. You may be \ missing units that important for describing the experinent.",
Figure 9: Error messages for feedback loops.
query mmB
would Like to make protocol culturing single colony of E.coli overnight and then make a glycerol stock with the suspension. Could you rind me protocols for both parts of this experinent?
Figure 10: LLM query for protocol retrieval.

---

Entering new AgentExecutor chain...
need search for protocols for culturing single colony cololi overnight and making gl ycerol stock with the suspension.
Action: search_ lrarcchfor_prooooe
Action Input: culturing a single colony of c.loli overnight
Observation: Here the titles for the top results:
Overnight Bacterial Batch Culture
High Efficiency Trans Protocol using NEB 10-beta Competent E. coli (C3019H) Heat Shock Transformation
Thought:I found relevant protocol for culturing single colony of c.coli overnight. Now, ed to search for protocol on making glycerol stock with the suspension.
Action: search_ search_for_pree for_protocol
Action Input: making glycerol stock with coli suspension
Observation: Here
the titles
top results:
Glycerol Stock
Overnight Bacterial Batch Culture
Mounting Media for Immunohistochenistryy - Drosophila
Thought:I now know
final answer
Final Answer: I found two relevant protocols for your experiment. For culturing single colony of colo overnight, use the "Overnight Bacterial Batch culture" protocol. For making glycerol stock with the suspension, use the "Glycerol Stock" protocol.
Figure 11: Langchain output for protocol retrieval.
prompt
Your job is to write python pseudocode to describe scientific protocols for molecular you write protocol for culturing single colony of c.coli overnight and then make a glycerol stock with the suspension. Your pseudocode may only make use of the following functions:
biology. would
def create_screw_top_ top_ttbe()t:
pass def tettto_uueetuuue volume, substance): pass def Lix_by_iinversionntubee) pass def corre_in_frezeerttute temperature): pass def aonpare_nedda__oolueeeeeeeee vo volume, tube):
pass def hbl._atttbbbarrieeeeeeeeeeaaaaar concentration, media): pass def bboclatc..uuuuusstttttteceeerree media):
pass def incubate_cuuueeeeeeeeeeeeeeeeeee httpr//eouuuttttttttototttttttee time, shaking):
pass
Figure 12: Prompt to generate protocol from retrieved functions.

---

def celtuure_and_aaaee laoke_glycerol_tee ssoool()sc;:::
# Step 1: Prepare media with antibiotics
ccrre__op_ttue__eede cubbe_eedia crrate_screw_top__11
add wttptt/essceettttttteeeeeeeeeeee cog_antibiotiic_t__eediiie
"LB") mL of LB media
"ampicillin", 100, screw_top_tubeemeee
# Add ampicillin at 100 ug/nL concentration
Step Inoculate culture with single colony E.coli
screw_top_tube_meet
Step 3: Incubate culture overnight ciccubtt_cctturr_a__cooditteee
"overnight", True) 37"C, overnight, shaking
# Step 4: Prepare glycerol stock
wttp:/oobeeggyeeerolooooo... add to_ (o_t
seaate_srrew_top.. tube()
screw_top ttrew_top_ttbe___ee Lube_glyccroo_stock 6.5, "glycerol"
# 0.5 nL of 50% glycerol
Add mL of overnight culture to glycerol stock
add_ Luubbeesrre..opptteeeellleeee
0.5, "overnight_cuuturre))
Step 6: Mix the glycerol stock by inversion mix htrprrssonnsssottootooouuueeeeer
Step 7: Store the glycerol stock in the -80"C freezer
-B8)
Execute the protocol
culture_and _aaereaanddaad______e haa__naakkeg_eggge glycerol_stockk
Figure 13: The LLM generated protocol used in our lab experiment.


Reviews:
[{"review_id": "mt8OYi2A25", "reviewer": "Reviewer_Lo15", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": 2, "soundness": 3, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank the reviewer for their thoughtful review and useful feedback. \n- **Additional models**\n  - We agree that not evaluating open-source models is a limitation. We thus evaluate Llama-2 7B on BioProt. Please see the results below for LLama-2 7B on the protocol generation and function selection tasks. We will replicate all other experiments on Llama for the camera ready version of the paper.\n\n  Protocol Generation:\n\n  | Model     | Shuffle | Feedback | Precision | Recall | $\\mathcal{L}_{dn}$ $\\downarrow$ | Arg Precision | Arg Recall | SciBERTScore | BLEU   |\n  |-----------|---------|----------|-----------|--------|---------------------------------|---------------|------------|--------------|--------|\n  | Llama2-7B |  x      |   x      |  83.6     |  49.8  | 0.74                            |  76.2         |  41.4      | 79.8         | 0.048  |\n  | Llama2-7B |  x      |   v      |  81.0     |  45.9  | 0.82                            |  70.4         |  42.9      | 80.4         | 0.050  |\n  | Llama2-7B |  v      |   x      |  82.2     |  45.1  | 0.63                            |  70.7         |  43.8      | 81.3         | 0.051  |\n  | Llama2-7B |  v      |   v      |  78.5     |  30.4  | 0.56                            |  73.0         |  51.4      | 81.1         | 0.047  |\n\n  Function Selection\n\n  | Model     | Neighbourhood| Precision | Recall |\n  |-----------|--------------|-----------|--------|\n  | Llama2-7B |  Nearest     | 26.1      |  57.5  | \n  | Llama2-7B |  Random      | 28.1      |  56.3  | \n\n- **Artificially boosted GPT-4 results**\n  - The aim of our work is not to show that one model is superior to another when it comes to scientific protocol generation. The aim is instead to propose a framework for evaluating LLMs on planning tasks, where there is no automatic way of evaluating the response. We will make sure this is more explicit in the abstract of the paper. Furthermore, the concern that GPT-4 results are artificially boosted is mostly valid for prior works that use GPT-4 as an evaluator of GPT-4 responses. We however, improve on this by automatically creating pseudo-ground-truth responses on an easy task, with additional context, and then evaluating the LLM’s responses using closed-form evaluation metrics. While we agree there is a possibility of leakage because of the use of pseudo-ground-truths generated by GPT-4, we mitigate this by having scientists manually inspect the generated pseudofuctions and pseudocode to make sure it is correct. We find that 59% of the responses are entirely correct (now that we have increased the dataset size to 100 protocols), and the ones that are incorrect are manually fixed. We will add a discussion of how the ground truth responses might be biased to GPT-4. However, these ground-truth responses can be generated by any LLM, as long as they are found to be correct. \n- **Reproducibility**\n  - With evaluations of open-source models, full documentation of our metrics, and all prompts and data released in the supplementary material, we believe our work is reproducible.", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "The authors present a new dataset and task-type that will be useful to evaluate models on. The data creation procedure is well-described and thought out, with a range of metrics to evaluate on. The authors also include an actual biology experiment conducted based on model outputs.", "reasons_to_reject": "The paper currently only evaluate on GPT-3.5 and GPT-4, which is a fairly limited slice of model, and moreover there is a clear overlap with GPT-4 also being used to construct parts of the dataset. (The authors do highlight that prior work has noted this). This may artificially boost the GPT-4 results. Ideally the models should also evaluate on models outside the OpenAI family, particularly open-access models.", "questions_to_authors": "", "paper_topic_and_main_contributions": "This work proposes a new task involving language models generating biology experiment/process protocols based on steps expressed in pseudocode. The data is taken from the Protocols.io website, the data creation is performed with the help of GPT-4, and the authors evaluate GPT-3.5 and GPT-4 on it.", "excitement": 3, "reproducibility": 3, "ethical_concerns": "No", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"Typos_Grammar_Style_and_Presentation_Improvements": "Broken reference in L449."}, "extra_text": {}}, {"review_id": "n3Nku6BdWo", "reviewer": "Reviewer_9Mgr", "summary": "", "questions": "- Which LLM was used in the Real-world validation?", "limitations": "", "rating": 5, "confidence": 3, "soundness": 5, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank you for the encouraging feedback. We are glad you believe that there is utility in using our framework for self-evaluation beyond this task, and that it can be of interest in different fields.\n\n- **Additional models**\n  - We evaluate an additional, open-sourced model -– Llama-2 7B. We hope this improves the reproducibility of our work. Please find the results in the response to reviewer Lo15\n- **Real-world validation**\n  - We use real-world validation as a case study and to measure to what extent the proposed dataset and framework can be used beyond model evaluation. We opt for an agent with access to tools, such that it can retrieve protocols that are found useful, and use their pseudofunctions – as opposed to generating psueodofunctions from scratch. This ensures the used pseudofunctions are actual atomic actions that are executable in a lab, as opposed to generating them from scratch. Note that for good performance in this real-world validation, the LLM needs to be able to (1) find relevant psueodofunctions from other protocols, and (2) generate correct pseudocode, both of which are tasks we propose and evaluate on. We used GPT-4 throughout this evaluation. We will make both the purpose of real-world validation and the model architecture clear in the paper.", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "- The paper tackles the important task of supporting experimental scientists by assisting with protocol generation, which can be cumbersome and error-prone. \n- The idea of using an easy task with full information first and then evaluating in a scenario with restricted information is a creative solution for reliable self-evaluation. This might be of interest in completely different tasks than science automation/assistance.\n- The authors release a new dataset with three novel tasks for protocol generation.\n- The real-world validation impressively showcases that LLMs are ready to assist experimental scientists in protocol generation.\n- The paper is well-written and easy to follow", "reasons_to_reject": "- The real-world validation seems to be a bit methodologically disconnected from other experiments. Why did the authors opt to use the toolformer component only in this experiment and not in the other evaluation experiments?\n- The authors evaluate only closed-source LLMs which might lead to severe problems regarding replicability.", "questions_to_authors": "- Which LLM was used in the Real-world validation?", "paper_topic_and_main_contributions": "The paper \"BioPlanner: Automatic Evaluation of LLMs on Protocol Planning in Biology\" propose a novel method for self-evaluation of LLMs on the task of automated experimental protocol generation. For this, the authors introduce a new dataset, BioProt, which maps natural language protocols to a pseudocode-based protocol representation. They create this dataset by a series of GPT-4 prompts that transform a gold-standard protocol and a subsequent manual verification and correction step.  The pseudocode-based representation can then be used as a generation target. This makes evaluation easier because the output space is much more constrained than for natural language. The authors propose three different downstream tasks on BioProt: Predicting the next step in a protocol, generating a protocol from scratch, and retrieving the set of needed steps from a pool of pseudo-functions. The authors evaluate GPT-3.5 and GPT-4 on these three downstream tasks and find that GPT-4 generally outperforms GPT-3.5. As a further contribution, the authors extend an LLM with search capabilities and let it design two experimental protocols. They validate the protocol by executing it in the wetlab and find that it leads to the desired outcome.", "excitement": 5, "reproducibility": 4, "ethical_concerns": "No", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "231AH3S588", "reviewer": "Reviewer_3v5p", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": 4, "soundness": 3, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "We thank the reviewer for their thoughtful review and useful feedback. \n- **Writing and organization**\n  - We thank you for the remark and will correct the typos and the missing reference. We will improve the structure by better separating the dataset and evaluation sections. We will also better integrate the real-world validation with the main method section to make the paper more cohesive. \n- **Dataset scope limited to GPT-4**\n  - We believe the dataset scope to be limited not to GPT-4’s capabilities, but to the breadth of open-source scientific protocols on protocols.io. The scientists that manually review the generated pseudocode and pseudofunctions were instructed to check if the pseudocode accurately matches the step-by-step instructions in the original protocols (as in Figure 2), making the capabilities on GPT-4 mostly irrelevant when it comes to the ground truth pesudofunctions and pseudocode. \n- **Evaluating on machine-generated data**\n  - While it is true we evaluate on machine-generated data, we (i) generate the pseudo ground truth on an easier task, and (ii) manually ensure it correctly reflects the original protocol. Although we agree the generated pseudocode might contain a bias towards the generations of GPT-4, we present a framework that can be applied to any LLM, and is the first, to our knowledge, automatic evaluation method of planning tasks described in plain text that does not require a simulator. Furthermore, this is a significant step forward from prior works (Wang et al., 2023) that evaluate GPT-4 responses using GPT-4, by simply asking it to evaluate a response given a ground-truth.\n- **Dataset size**\n  -  We have increased the number of manually verified protocols to 100 and we are committed to continue increasing the size of the dataset. Furthermore, to improve the robustness of the findings, we report mean and standard deviations over 5 generation runs for the tasks of protocol generation and next step prediction below. We will report these in the camera ready version of the paper.\n\n  Protocol Generation\n\n  | Model   | Shuffle | Feedback | Precision       | Recall        | $\\mathcal{L}_{dn}$ $\\downarrow$ | Args Precision | Args Recall   | SciBERTScore | BLEU            |\n  |---------|---------|----------|-----------------|---------------|---------------------------------|----------------|---------------|--------------|-----------------|\n  | GPT-3.5 |  x      |   x      |  93.4&pm;0.9    |  89.9&pm;0.6  | 0.498&pm;0.036                  |  72.7&pm;0.8   |  91.4&pm;1.5  | 82.7&pm;0.6  | 0.121&pm;0.005  |\n  | GPT-3.5 |  x      |   v      |  93.3&pm;1.0    |  91.1&pm;1.1  | 0.505&pm;0.159                  |  73.1&pm;1.6   |  88.1&pm;1.9  | 82.8&pm;0.6  | 0.117&pm;0.006  |\n  | GPT-3.5 |  v      |   x      |  91.8&pm;0.8    |  85.9&pm;2.8  | 0.945&pm;0.055                  |  72.9&pm;1.4   |  89.1&pm;2.2  | 81.8&pm;0.2  | 0.102&pm;0.003  |\n  | GPT-3.5 |  v      |   v      |  92.5&pm;0.3    |  86.1&pm;1.6  | 0.884&pm;0.045                  |  73.2&pm;1.3   |  87.3&pm;3.5  | 82.3&pm;0.4  | 0.102&pm;0.009  |\n  | GPT-4   |  x      |   x      |  91.9&pm;0.9    |  90.8&pm;0.9  | 0.396&pm;0.046                  |  72.2&pm;0.8   |  94.7&pm;1.4  | 82.6&pm;0.2  | 0.124&pm;0.006  |\n  | GPT-4   |  x      |   v      |  92.5&pm;0.3    |  90.1&pm;0.3  | 0.438&pm;0.412                  |  72.0&pm;0.3   |  93.3&pm;1.0  | 82.7&pm;0.3  | 0.112&pm;0.005  |\n  | GPT-4   |  v      |   x      |  92.6&pm;0.9    |  87.7&pm;0.9  | 0.722&pm;0.311                  |  72.2&pm;0.3   |  94.6&pm;1.8  | 82.7&pm;0.4  | 0.113&pm;0.004  |\n  | GPT-4   |  v      |   v      |  92.8&pm;1.0    |  86.6&pm;0.3  | 0.685&pm;0.178                  |  73.7&pm;0.7   |  93.4&pm;2.0  | 82.5&pm;0.7  | 0.108&pm;0.004  |\n\n  Next Step Prediction\n\n  | Model   | Shuffle |  Func Accuracy  | Args Precision | Args Recall   | SciBERTScore | BLEU            |\n  |---------|---------|-----------------|----------------|---------------|--------------|-----------------|\n  | GPT-3.5 |  x      |  65.8&pm;1.3    |  97.7&pm;0.5   |  94.7&pm;0.5  | 88.5&pm;0.5  | 0.363&pm;0.012  |\n  | GPT-3.5 |  v      |  36.1&pm;1.6    |  97.1&pm;1.2   |  95.1&pm;1.0  | 88.6&pm;0.5  | 0.384&pm;0.028  |\n  | GPT-4   |  x      |  70.6&pm;0.4    |  97.1&pm;0.5   |  94.9&pm;0.6  | 87.9&pm;0.5  | 0.351&pm;0.017  |\n  | GPT-4   |  v      |  57.0&pm;0.8    |  97.1&pm;0.4   |  94.7&pm;0.8  | 88.5&pm;0.6  | 0.363&pm;0.025  |", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "1. This paper explores an interesting application of utilizing LLMs for biology experiments, showcasing the potential of NLP techniques to drive scientific discovery.\n2. The authors construct a novel dataset comprising natural language descriptions and step-by-step pseudocode.\n3. The introduction of three quantitative tasks allows for automatic evaluation of LLM's performance in protocol planning.\n4. The machine-generated protocols have been validated in a real-world laboratory experiment.", "reasons_to_reject": "1. The writing and organization of the paper could benefit from improvement. Typos and missing table references need to be addressed, and the content should be better structured. While the paper contributes to dataset, evaluation, method, and experimental validation, they appear to be somewhat intertwined.\n2. Concerns arise regarding the evaluation conducted on machine-generated data, which may limit the dataset's coverage. As the pseudocode is generated by GPT-4 (though manually verified), the dataset's scope may be bound by GPT-4's capabilities.\n3. Evaluating GPT-4 on a dataset generated by GPT-4 may not provide the most meaningful insights and might lead to potential overestimation of the model's performance.\n4. The dataset's size is relatively small, consisting of only 70 protocols, which might impact the generalizability and robustness of the findings.", "questions_to_authors": "", "paper_topic_and_main_contributions": "This paper explores the application of LLMs in biology protocol planning, with a primary emphasis on devising an automated evaluation method. To facilitate this research, the authors curated a dataset called BioPort, comprising published biology protocols alongside machine-generated pseudocode, which was verified by human experts. In addition, they propose various quantitative tasks and metrics to assess the performance of LLMs in protocol planning. The evaluation results for GPT-3 and GPT-4 are presented, and the model-generated protocols are validated in a real-world laboratory experiment. ", "excitement": 3, "reproducibility": 4, "ethical_concerns": "No", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Meta-review: This work investigates a unique and interesting application (supporting experimental scientists by assisting with protocol generation) and presents a new evaluation set and method for self-evaluation. Though there are valid concerns among reviewers that evaluating GPT-4 with GPT-4 will have misleading biases (and also questions about training set representation), these experiments and resources are likely to prove insightful to practitioners.
Decision: Accept-Main