We developed a comprehensive safety prompt collection procedure that includes eight attack types
and over 120 specific safety value categories. Our risk taxonomy is adapted from Wang et al. (2023),
which originally defines six main types and 60 specific categories of harmful content. We have
expanded this taxonomy to encompass more region-specific types, sensitive topics, and cybersecurity-
related issues, ensuring a more nuanced and robust coverage of potential risks. This extended
taxonomy allows us to address a wider variety of harmful behaviors and content that may be culturally
or contextually specific, thus enhancing the model’s safety alignment across diverse scenarios.
Category
K2-Chat-060124
K2-Chat
DoNotAnswer
67.94
87.65
Advbench
52.12
81.73
I_cona
67.98
79.21
I_controversial
47.50
70.00
I_malicious_instructions
60.00
83.00
I_physical_safety_unsafe
44.00
68.00
I_physical_safety_safe
96.00
97.00
Harmbench
20.50
63.50
Spmisconception
40.98
76.23
MITRE
3.20
57.30
PromptInjection
54.58
56.57
Attack_multilingual_overload
74.67
89.00
Attack_persona_modulation
51.67
85.67
Attack_refusal_suppression
56.00
93.00
Attack_do_anything_now
48.00
91.33
Attack_conversation_completion
56.33
71.00
Attack_wrapped_in_shell
34.00
67.00
Average
51.50
77.48
Function Calling
Chat Template
Our model reuses K2-Chat as the prompt format and is specifically trained for function calling. Different system prompts enable different ways to interact with this model. Note that the two modes are currently mainly tested individually, designing prompts that make them work togehter is possible but currently untested. It should be also possible to stimulate the model to produce function call behavior by injecting special token <tool_call> and expect the model to finish it. In this guide we mention the intended basic usage of the model.
Conversational Chats
Here is an example prompt with system instruction (Use whatever system prompt you like, this is just an example):
Your name is K2, and you are named after K2, the second highest mountain on Earth. You are built by MBZUAI and LLM360. You are a highly advanced large language model with 65B parameters. You outperform all fully open source models and Llama 2 70B. You can answer in English only. You are a helpful, respectful and honest assistant.<|endofsystemprompt|><|beginofuser|>Hello, who are you?<|beginofsystem|>
Sample inference code
python
1from transformers import AutoModelForCausalLM, AutoTokenizer
23tokenizer = AutoTokenizer.from_pretrained("<path_to_model_weights>")4model = AutoModelForCausalLM.from_pretrained("<path_to_model_weights>")567prompt ='Your name is K2, and you are named after K2, the second highest mountain on Earth. You are built by MBZUAI and LLM360. You are a highly advanced large language model with 65B parameters. You outperform all fully open source models and Llama 2 70B. You can answer in English only. You are a helpful, respectful and honest assistant.<|endofsystemprompt|><|beginofuser|>Hello, who are you?<|beginofsystem|>'89input_ids = tokenizer(prompt, return_tensors="pt").input_ids
10gen_tokens = model.generate(input_ids, do_sample=True, max_new_tokens=128)11print("-"*20+"Output for model"+20*'-')12print(tokenizer.batch_decode(gen_tokens)[0])
Multi-turn conversations should be formatted like this:
For function calling, please use this system prompt:
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools:
Next, use whatever tools you like, this is just an example:
<tools>
{ "name": "get_news_headlines", "description": "Get the latest news headlines", "parameters": {"type": "object", "properties": { "country": { "type": "string", "description": "The country for which to fetch news"}}, "required": [ "country"]}}
</tools>
Next, add additional instruction:
Use the following pydantic model json schema for each tool call you will make:
{"properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"], "title": "FunctionCall", "type": "object"}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"arguments": <args-dict>, "name": <function-name>}
</tool_call>
Please also summarize texts wrapped between <tool_response> and </tool_response> in bullet points. For example:
<tool_response>
{"fruits": [{"name": "Apple"}, {"name": "Pear"}]}
</tool_response> is summarized as:
Fruits:
- Apple
- Pear
<|endofsystemprompt|>
The following is the model initial prompt:
You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools:
<tools>
{ "name": "get_news_headlines", "description": "Get the latest news headlines", "parameters": {"type": "object", "properties": { "country": { "type": "string", "description": "The country for which to fetch news"}}, "required": [ "country"]}}
</tools>
Use the following pydantic model json schema for each tool call you will make:
{"properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"], "title": "FunctionCall", "type": "object"}
For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"arguments": <args-dict>, "name": <function-name>}
</tool_call>
Please also summarize texts wrapped between <tool_response> and </tool_response> in bullet points. For example:
<tool_response>
{"fruits": [{"name": "Apple"}, {"name": "Pear"}]}
</tool_response> is summarized as:
Fruits:
- Apple
- Pear
<|endofsystemprompt|>
Example flow for generation with multi-turn and how to incoporate function call output
When users ask a question, the following user query will be concatenated with the prompt (see example inference code below too)
<|beginofuser|>Can you tell me the latest news headlines for the United States?<|beginofsystem|>
When run it, you will get a tool call response wrapped in the <tool_call> tag:
Now you should execute this tool call with the external tool, you will get responses from that tool. The model can interpret the tool response as natural language again. To achieve this, simply wrap it with <tool_response> and </tool_response> and append it to the history and ask the model to generate further:
...current model history (ends with </tool_call><|endoftext|>)...
<tool_response>
{"news": [{"title": "A great news headline"}, {"title": "Another great news headline"}]}
</tool_response>
In this second turn, the model should respond with:
Suggested news headline:
- A great news headline
- Another great news headline<endoftext>
Sometimes, there is a use case that only uses the function call feature as a JSON formatter without calling any external functions, which means the output in tool_call is essentially what you want. In that case, we recommend simply make a copy of the content of <tool_call> and wrap that in <tool_response>.
Sample inference code
python
1from transformers import AutoModelForCausalLM, AutoTokenizer
23tokenizer = AutoTokenizer.from_pretrained("<path_to_model_weights>")4model = AutoModelForCausalLM.from_pretrained("<path_to_model_weights>")567prompt ="""You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools:
8<tools>
9[{"name": "get_news_headlines", "description": "Get the latest news headlines", "parameters": {"type": "object", "properties": {"country": {"type": "string", "description": "The country for which to fetch news"}}, "required": ["country"] }}
10</tools>
11Use the following pydantic model json schema for each tool call you will make:
12{"properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"], "title": "FunctionCall", "type": "object"}
13For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
14<tool_call>
15{"arguments": <args-dict>, "name": <function-name>}
16</tool_call>
17Please also summarize texts wrapped between <tool_response> and </tool_response> in bullet points. For example:
18<tool_response>
19{"fruits": [{"name": "Apple"}, {"name": "Pear"}]}
20</tool_response> is summarized as:
21Fruits:
22- Apple
23- Pear
24<|endofsystemprompt|><|beginofuser|>Can you tell me the latest news headlines for the United States?<|beginofsystem|>"""252627input_ids = tokenizer(prompt, return_tensors="pt").input_ids
28gen_tokens = model.generate(input_ids, do_sample=True, max_new_tokens=128)2930print("-"*20+"Output for model"+20*'-')31print(tokenizer.batch_decode(gen_tokens)[0])
K2-Chat-060124
K2 Chat is finetuned from K2-65B. K2 Chat outperforms Llama 2-70B-Chat on all evaluations conducted. The model also outperforms Llama 3-70B-Instruct on coding tasks.
k2 eval table
LLM360 Model Performance and Evaluation Collection
The LLM360 Performance and Evaluation Collection is a robust evaluations set consisting of general and domain specific evaluations to assess model knowledge and function.
Evaluations include standard best practice benchmarks, medical, math, and coding knowledge. More about the evaluations can be found here.
1from transformers import AutoModelForCausalLM, AutoTokenizer
23tokenizer = AutoTokenizer.from_pretrained("LLM360/K2-Chat")4model = AutoModelForCausalLM.from_pretrained("LLM360/K2-Chat")56prompt ='<|beginofuser|>what is the highest mountain on earth?<|beginofsystem|>'78input_ids = tokenizer(prompt, return_tensors="pt").input_ids
9gen_tokens = model.generate(input_ids, do_sample=True, max_new_tokens=128)1011print("-"*20+"Output for model"+20*'-')12print(tokenizer.batch_decode(gen_tokens)[0])
Alternatively, you can construct the prompt by applying the chat template of tokenizer on input conversation:
python
1from transformers import AutoModelForCausalLM, AutoTokenizer
23tokenizer = AutoTokenizer.from_pretrained("LLM360/K2-Chat")4model = AutoModelForCausalLM.from_pretrained("LLM360/K2-Chat")56messages =[{"role":"user","content":"what is the highest mountain on earth?"}]78input_ids = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt")9gen_tokens = model.generate(input_ids, do_sample=True, max_new_tokens=128)1011print("-"*20+"Output for model"+20*'-')12print(tokenizer.batch_decode(gen_tokens)[0])
LLM360 Developer Suite
We provide step-by-step finetuning tutorials for tech enthusiasts, AI practitioners and academic or industry researchers here.
About LLM360
LLM360 is an open research lab enabling community-owned AGI through open-source large model research and development.
LLM360 enables community-owned AGI by creating standards and tools to advance the bleeding edge of LLM capability and empower knowledge transfer, research, and development.
We believe in a future where artificial general intelligence (AGI) is created by the community, for the community. Through an open ecosystem of equitable computational resources, high quality data, and flowing technical knowledge, we can ensure ethical AGI development and universal access for all innovators.
