We started with a zero-shot baseline run after which repeated the experiment a couple of extra occasions constructing the complexity of the immediate by including methods like few-shot in-context studying. We prompted the LLM to establish weak code with no point out of which CWE it is likely to be in search of (i.e. with out labels).

In a zero-shot immediate, you ask the mannequin to make a prediction with no instance or data apart from directions. Our zero-shot template was impressed by this paper⁴ and features a position, code delimiter, and the request to output json format solely. It additionally contains an instruction to “suppose step-by-step”. The code snippet beneath check is inserted into {code}.

Immediate

You're a sensible software program safety knowledgeable. 
You may be supplied with a python code delimited by triple backticks. 
If it accommodates any CWE safety vulnerabilities, write Weak. 
If the code doesn't include any vulnerabilities, write Not Weak. 
Format your response as a JSON object with "label" as the important thing 
for vulnerability standing and "cwe" because the vulnerability quantity discovered. 
Take into consideration the reply step-by-step, and solely reply with JSON.
Python code: ```{code}``` 
Reply:

Outcomes

Accuracy: 0.67
Precision: 0.60
Recall: 0.86
F1 Rating: 0.71

Within the subsequent experiment, we add the idea of in-context or “few-shot” studying and embrace a couple of profitable code-answer examples earlier than asking the LLM to carry out the identical operation on the unseen code. These examples had been constructed from the rest of the dataset and care was taken to:

• Draw from totally different eventualities than the code snippet beneath check, to keep away from contamination
• Draw precisely two weak examples and one non-vulnerable instance

Immediate

You're a sensible software program safety knowledgeable. 
You may be supplied with a python code delimited by triple backticks. 
If it accommodates any CWE safety vulnerabilities, write Weak. 
If the code doesn't include any vulnerabilities, write Not Weak. 
Format your response as a JSON object with "label" as the important thing 
for vulnerability standing and "cwe" because the vulnerability quantity discovered. 
Take into consideration the reply step-by-step, and solely reply with JSON.
Python code: ```{example_0}```
Reply: {answer_0}
Python code: ```{example_1}```
Reply: {answer_1}
Python code: ```{example_2}```
Reply: {answer_2}
Python code: ```{code}```
Reply: 

Outcomes

Accuracy: 0.76
Precision: 0.71
Recall: 0.81
F1 Rating: 0.76

This Microsoft weblog submit describes an fascinating method referred to as KNN-based few-shot instance choice that may increase LLM response high quality when utilizing in-context examples. For this subsequent experiment, as a substitute of sampling photographs at random, we calculate a similarity rating between the enter code and every candidate instance and assemble photographs from essentially the most related candidates (nonetheless conserving the eventualities distinct). We use the ROUGE-L metric, however different metrics could possibly be used too. The immediate template didn’t change from the second experiment.

Outcomes

Accuracy: 0.73
Precision: 0.70
Recall: 0.76
F1 Rating: 0.73

On this variation of the immediate, we embrace a request for a set model of the code if a CWE is discovered. This method was impressed by Noever, who proposed that prompting for CWE detection and a repair collectively may deliver a couple of “virtuous cycle” and power the LLM to “self-audit” or suppose extra deeply in regards to the steps wanted to precisely establish vulnerabilities, just like chain-of-thought prompting. We did this by establishing weak code in-context examples with code repair options drawn from the non-vulnerable code samples for a similar eventualities.

Immediate

You're a sensible software program safety knowledgeable. 
You may be supplied with a python code delimited by triple backticks. 
If it accommodates any CWE safety vulnerabilities, write Weak. 
If the code doesn't include any vulnerabilities, write Not Weak. 
If the code has the vulnerability, write a repaired safe model of the
code that preserves its actual performance. 
Format your response as a JSON object with "label" as the important thing 
for vulnerability standing, "cwe" because the vulnerability discovered,
and "repair" for the fastened code snippet. 
Take into consideration the reply step-by-step, and solely reply with JSON.
Python code: ```{example_0}```
Reply: {answer_0}
Python code: ```{example_1}```
Reply: {answer_1}
Python code: ```{example_2}```
Reply: {answer_2}
Python code: ```{code}```
Reply:

Outcomes

Accuracy: 0.80
Precision: 0.73
Recall: 0.90
F1 Rating: 0.81

Along with CWE detection, this experiment has the good thing about producing steered fixes. We now have not evaluated them for high quality but, so that’s an space for future work.

On our small knowledge pattern, GPT4’s accuracy was 67% and its F1 rating was 71% with none advanced immediate variations. Small enhancements had been provided by a number of the prompting strategies we examined, with few-shot and requesting a code repair standing out. The mixture of strategies bumped accuracy and F1 rating by about ten share factors every from baseline, each metrics reaching or exceeding 80%.

Outcomes could be fairly totally different between fashions, datasets, and prompts, so extra investigation is required. For instance, it could be fascinating to:

• Check smaller fashions
• Check a immediate template that features the CWE label, to research the potential for combining LLMs with static evaluation
• Check bigger and extra numerous datasets
• Consider the safety and performance of LLM-proposed code fixes
• Examine extra superior prompting strategies comparable to in-context instance chains-of-thought, Self-Consistency, and Self-Uncover

If you want to see the code that produced these outcomes, run it by yourself code, or adapt it in your personal wants, try the pull request in OpenAI Cookbook (at the moment beneath assessment).