Model Runtime (#1858)

Co-authored-by: StyleZhang <jasonapring2015@outlook.com>
Co-authored-by: Garfield Dai <dai.hai@foxmail.com>
Co-authored-by: chenhe <guchenhe@gmail.com>
Co-authored-by: jyong <jyong@dify.ai>
Co-authored-by: Joel <iamjoel007@gmail.com>
Co-authored-by: Yeuoly <admin@srmxy.cn>
This commit is contained in:
takatost
2024-01-02 23:42:00 +08:00
committed by GitHub
parent e91dd28a76
commit d069c668f8
807 changed files with 171310 additions and 23806 deletions

View File

@@ -2,131 +2,199 @@ import json
import os
import re
import enum
from typing import List, Optional, Tuple
from typing import List, Optional, Tuple, cast
from langchain.memory.chat_memory import BaseChatMemory
from langchain.schema import BaseMessage
from core.model_providers.models.entity.model_params import ModelMode
from core.model_providers.models.entity.message import PromptMessage, MessageType, to_prompt_messages, PromptMessageFile
from core.model_providers.models.llm.base import BaseLLM
from core.model_providers.models.llm.baichuan_model import BaichuanModel
from core.model_providers.models.llm.huggingface_hub_model import HuggingfaceHubModel
from core.model_providers.models.llm.openllm_model import OpenLLMModel
from core.model_providers.models.llm.xinference_model import XinferenceModel
from core.entities.application_entities import ModelConfigEntity, PromptTemplateEntity, \
AdvancedCompletionPromptTemplateEntity
from core.file.file_obj import FileObj
from core.memory.token_buffer_memory import TokenBufferMemory
from core.model_runtime.entities.message_entities import PromptMessage, SystemPromptMessage, UserPromptMessage, \
TextPromptMessageContent, PromptMessageRole, AssistantPromptMessage
from core.model_runtime.entities.model_entities import ModelPropertyKey
from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
from core.prompt.prompt_builder import PromptBuilder
from core.prompt.prompt_template import PromptTemplateParser
from models.model import AppModelConfig
class AppMode(enum.Enum):
COMPLETION = 'completion'
CHAT = 'chat'
@classmethod
def value_of(cls, value: str) -> 'AppMode':
"""
Get value of given mode.
:param value: mode value
:return: mode
"""
for mode in cls:
if mode.value == value:
return mode
raise ValueError(f'invalid mode value {value}')
class ModelMode(enum.Enum):
COMPLETION = 'completion'
CHAT = 'chat'
@classmethod
def value_of(cls, value: str) -> 'ModelMode':
"""
Get value of given mode.
:param value: mode value
:return: mode
"""
for mode in cls:
if mode.value == value:
return mode
raise ValueError(f'invalid mode value {value}')
class PromptTransform:
def get_prompt(self,
app_mode: str,
pre_prompt: str,
prompt_template_entity: PromptTemplateEntity,
inputs: dict,
query: str,
files: List[PromptMessageFile],
files: List[FileObj],
context: Optional[str],
memory: Optional[BaseChatMemory],
model_instance: BaseLLM) -> \
memory: Optional[TokenBufferMemory],
model_config: ModelConfigEntity) -> \
Tuple[List[PromptMessage], Optional[List[str]]]:
app_mode = AppMode.value_of(app_mode)
model_mode = ModelMode.value_of(model_config.mode)
app_mode_enum = AppMode(app_mode)
model_mode_enum = model_instance.model_mode
prompt_rules = self._read_prompt_rules_from_file(self._prompt_file_name(
app_mode=app_mode,
provider=model_config.provider,
model=model_config.model
))
prompt_rules = self._read_prompt_rules_from_file(self._prompt_file_name(app_mode, model_instance))
if app_mode_enum == AppMode.CHAT and model_mode_enum == ModelMode.CHAT:
if app_mode == AppMode.CHAT and model_mode == ModelMode.CHAT:
stops = None
prompt_messages = self._get_simple_chat_app_chat_model_prompt_messages(prompt_rules, pre_prompt, inputs,
query, context, memory,
model_instance, files)
prompt_messages = self._get_simple_chat_app_chat_model_prompt_messages(
prompt_rules=prompt_rules,
pre_prompt=prompt_template_entity.simple_prompt_template,
inputs=inputs,
query=query,
files=files,
context=context,
memory=memory,
model_config=model_config
)
else:
stops = prompt_rules.get('stops')
if stops is not None and len(stops) == 0:
stops = None
prompt_messages = self._get_simple_others_prompt_messages(prompt_rules, pre_prompt, inputs, query, context,
memory,
model_instance, files)
prompt_messages = self._get_simple_others_prompt_messages(
prompt_rules=prompt_rules,
pre_prompt=prompt_template_entity.simple_prompt_template,
inputs=inputs,
query=query,
files=files,
context=context,
memory=memory,
model_config=model_config
)
return prompt_messages, stops
def get_advanced_prompt(self,
app_mode: str,
app_model_config: AppModelConfig,
def get_advanced_prompt(self, app_mode: str,
prompt_template_entity: PromptTemplateEntity,
inputs: dict,
query: str,
files: List[PromptMessageFile],
files: List[FileObj],
context: Optional[str],
memory: Optional[BaseChatMemory],
model_instance: BaseLLM) -> List[PromptMessage]:
model_mode = app_model_config.model_dict['mode']
app_mode_enum = AppMode(app_mode)
model_mode_enum = ModelMode(model_mode)
memory: Optional[TokenBufferMemory],
model_config: ModelConfigEntity) -> List[PromptMessage]:
app_mode = AppMode.value_of(app_mode)
model_mode = ModelMode.value_of(model_config.mode)
prompt_messages = []
if app_mode_enum == AppMode.CHAT:
if model_mode_enum == ModelMode.COMPLETION:
prompt_messages = self._get_chat_app_completion_model_prompt_messages(app_model_config, inputs, query,
files, context, memory,
model_instance)
elif model_mode_enum == ModelMode.CHAT:
prompt_messages = self._get_chat_app_chat_model_prompt_messages(app_model_config, inputs, query, files,
context, memory, model_instance)
elif app_mode_enum == AppMode.COMPLETION:
if model_mode_enum == ModelMode.CHAT:
prompt_messages = self._get_completion_app_chat_model_prompt_messages(app_model_config, inputs,
files, context)
elif model_mode_enum == ModelMode.COMPLETION:
prompt_messages = self._get_completion_app_completion_model_prompt_messages(app_model_config, inputs,
files, context)
if app_mode == AppMode.CHAT:
if model_mode == ModelMode.COMPLETION:
prompt_messages = self._get_chat_app_completion_model_prompt_messages(
prompt_template_entity=prompt_template_entity,
inputs=inputs,
query=query,
context=context,
memory=memory,
model_config=model_config
)
elif model_mode == ModelMode.CHAT:
prompt_messages = self._get_chat_app_chat_model_prompt_messages(
prompt_template_entity=prompt_template_entity,
inputs=inputs,
query=query,
files=files,
context=context,
memory=memory,
model_config=model_config
)
elif app_mode == AppMode.COMPLETION:
if model_mode == ModelMode.CHAT:
prompt_messages = self._get_completion_app_chat_model_prompt_messages(
prompt_template_entity=prompt_template_entity,
inputs=inputs,
files=files,
context=context,
)
elif model_mode == ModelMode.COMPLETION:
prompt_messages = self._get_completion_app_completion_model_prompt_messages(
prompt_template_entity=prompt_template_entity,
inputs=inputs,
context=context,
)
return prompt_messages
def _get_history_messages_from_memory(self, memory: BaseChatMemory,
max_token_limit: int) -> str:
def _get_history_messages_from_memory(self, memory: TokenBufferMemory,
max_token_limit: int,
human_prefix: Optional[str] = None,
ai_prefix: Optional[str] = None) -> str:
"""Get memory messages."""
memory.max_token_limit = max_token_limit
memory_key = memory.memory_variables[0]
external_context = memory.load_memory_variables({})
return external_context[memory_key]
kwargs = {
"max_token_limit": max_token_limit
}
def _get_history_messages_list_from_memory(self, memory: BaseChatMemory,
if human_prefix:
kwargs['human_prefix'] = human_prefix
if ai_prefix:
kwargs['ai_prefix'] = ai_prefix
return memory.get_history_prompt_text(
**kwargs
)
def _get_history_messages_list_from_memory(self, memory: TokenBufferMemory,
max_token_limit: int) -> List[PromptMessage]:
"""Get memory messages."""
memory.max_token_limit = max_token_limit
memory.return_messages = True
memory_key = memory.memory_variables[0]
external_context = memory.load_memory_variables({})
memory.return_messages = False
return to_prompt_messages(external_context[memory_key])
return memory.get_history_prompt_messages(
max_token_limit=max_token_limit
)
def _prompt_file_name(self, mode: str, model_instance: BaseLLM) -> str:
def _prompt_file_name(self, app_mode: AppMode, provider: str, model: str) -> str:
# baichuan
if isinstance(model_instance, BaichuanModel):
return self._prompt_file_name_for_baichuan(mode)
if provider == 'baichuan':
return self._prompt_file_name_for_baichuan(app_mode)
baichuan_model_hosted_platforms = (HuggingfaceHubModel, OpenLLMModel, XinferenceModel)
if isinstance(model_instance, baichuan_model_hosted_platforms) and 'baichuan' in model_instance.name.lower():
return self._prompt_file_name_for_baichuan(mode)
baichuan_supported_providers = ["huggingface_hub", "openllm", "xinference"]
if provider in baichuan_supported_providers and 'baichuan' in model.lower():
return self._prompt_file_name_for_baichuan(app_mode)
# common
if mode == 'completion':
if app_mode == AppMode.COMPLETION:
return 'common_completion'
else:
return 'common_chat'
def _prompt_file_name_for_baichuan(self, mode: str) -> str:
if mode == 'completion':
def _prompt_file_name_for_baichuan(self, app_mode: AppMode) -> str:
if app_mode == AppMode.COMPLETION:
return 'baichuan_completion'
else:
return 'baichuan_chat'
@@ -142,12 +210,14 @@ class PromptTransform:
with open(json_file_path, 'r') as json_file:
return json.load(json_file)
def _get_simple_chat_app_chat_model_prompt_messages(self, prompt_rules: dict, pre_prompt: str, inputs: dict,
def _get_simple_chat_app_chat_model_prompt_messages(self, prompt_rules: dict,
pre_prompt: str,
inputs: dict,
query: str,
context: Optional[str],
memory: Optional[BaseChatMemory],
model_instance: BaseLLM,
files: List[PromptMessageFile]) -> List[PromptMessage]:
files: List[FileObj],
memory: Optional[TokenBufferMemory],
model_config: ModelConfigEntity) -> List[PromptMessage]:
prompt_messages = []
context_prompt_content = ''
@@ -174,20 +244,34 @@ class PromptTransform:
prompt = re.sub(r'<\|.*?\|>', '', prompt)
prompt_messages.append(PromptMessage(type=MessageType.SYSTEM, content=prompt))
if prompt:
prompt_messages.append(SystemPromptMessage(content=prompt))
self._append_chat_histories(memory, prompt_messages, model_instance)
self._append_chat_histories(
memory=memory,
prompt_messages=prompt_messages,
model_config=model_config
)
prompt_messages.append(PromptMessage(type=MessageType.USER, content=query, files=files))
if files:
prompt_message_contents = [TextPromptMessageContent(data=query)]
for file in files:
prompt_message_contents.append(file.prompt_message_content)
prompt_messages.append(UserPromptMessage(content=prompt_message_contents))
else:
prompt_messages.append(UserPromptMessage(content=query))
return prompt_messages
def _get_simple_others_prompt_messages(self, prompt_rules: dict, pre_prompt: str, inputs: dict,
def _get_simple_others_prompt_messages(self, prompt_rules: dict,
pre_prompt: str,
inputs: dict,
query: str,
context: Optional[str],
memory: Optional[BaseChatMemory],
model_instance: BaseLLM,
files: List[PromptMessageFile]) -> List[PromptMessage]:
memory: Optional[TokenBufferMemory],
files: List[FileObj],
model_config: ModelConfigEntity) -> List[PromptMessage]:
context_prompt_content = ''
if context and 'context_prompt' in prompt_rules:
prompt_template = PromptTemplateParser(template=prompt_rules['context_prompt'])
@@ -214,19 +298,23 @@ class PromptTransform:
if memory and 'histories_prompt' in prompt_rules:
# append chat histories
tmp_human_message = PromptBuilder.to_human_message(
prompt_content=prompt + query_prompt,
inputs={
'query': query
}
tmp_human_message = UserPromptMessage(
content=PromptBuilder.parse_prompt(
prompt=prompt + query_prompt,
inputs={
'query': query
}
)
)
rest_tokens = self._calculate_rest_token(tmp_human_message, model_instance)
rest_tokens = self._calculate_rest_token([tmp_human_message], model_config)
memory.human_prefix = prompt_rules['human_prefix'] if 'human_prefix' in prompt_rules else 'Human'
memory.ai_prefix = prompt_rules['assistant_prefix'] if 'assistant_prefix' in prompt_rules else 'Assistant'
histories = self._get_history_messages_from_memory(memory, rest_tokens)
histories = self._get_history_messages_from_memory(
memory=memory,
max_token_limit=rest_tokens,
ai_prefix=prompt_rules['human_prefix'] if 'human_prefix' in prompt_rules else 'Human',
human_prefix=prompt_rules['assistant_prefix'] if 'assistant_prefix' in prompt_rules else 'Assistant'
)
prompt_template = PromptTemplateParser(template=prompt_rules['histories_prompt'])
histories_prompt_content = prompt_template.format({'histories': histories})
@@ -246,7 +334,7 @@ class PromptTransform:
prompt = re.sub(r'<\|.*?\|>', '', prompt)
return [PromptMessage(content=prompt, files=files)]
return [UserPromptMessage(content=prompt)]
def _set_context_variable(self, context: str, prompt_template: PromptTemplateParser, prompt_inputs: dict) -> None:
if '#context#' in prompt_template.variable_keys:
@@ -262,42 +350,63 @@ class PromptTransform:
else:
prompt_inputs['#query#'] = ''
def _set_histories_variable(self, memory: BaseChatMemory, raw_prompt: str, conversation_histories_role: dict,
prompt_template: PromptTemplateParser, prompt_inputs: dict,
model_instance: BaseLLM) -> None:
def _set_histories_variable(self, memory: TokenBufferMemory,
raw_prompt: str,
role_prefix: AdvancedCompletionPromptTemplateEntity.RolePrefixEntity,
prompt_template: PromptTemplateParser,
prompt_inputs: dict,
model_config: ModelConfigEntity) -> None:
if '#histories#' in prompt_template.variable_keys:
if memory:
tmp_human_message = PromptBuilder.to_human_message(
prompt_content=raw_prompt,
inputs={'#histories#': '', **prompt_inputs}
tmp_human_message = UserPromptMessage(
content=PromptBuilder.parse_prompt(
prompt=raw_prompt,
inputs={'#histories#': '', **prompt_inputs}
)
)
rest_tokens = self._calculate_rest_token(tmp_human_message, model_instance)
rest_tokens = self._calculate_rest_token([tmp_human_message], model_config)
memory.human_prefix = conversation_histories_role['user_prefix']
memory.ai_prefix = conversation_histories_role['assistant_prefix']
histories = self._get_history_messages_from_memory(memory, rest_tokens)
histories = self._get_history_messages_from_memory(
memory=memory,
max_token_limit=rest_tokens,
human_prefix=role_prefix.user,
ai_prefix=role_prefix.assistant
)
prompt_inputs['#histories#'] = histories
else:
prompt_inputs['#histories#'] = ''
def _append_chat_histories(self, memory: BaseChatMemory, prompt_messages: list[PromptMessage],
model_instance: BaseLLM) -> None:
def _append_chat_histories(self, memory: TokenBufferMemory,
prompt_messages: list[PromptMessage],
model_config: ModelConfigEntity) -> None:
if memory:
rest_tokens = self._calculate_rest_token(prompt_messages, model_instance)
memory.human_prefix = MessageType.USER.value
memory.ai_prefix = MessageType.ASSISTANT.value
rest_tokens = self._calculate_rest_token(prompt_messages, model_config)
histories = self._get_history_messages_list_from_memory(memory, rest_tokens)
prompt_messages.extend(histories)
def _calculate_rest_token(self, prompt_messages: BaseMessage, model_instance: BaseLLM) -> int:
def _calculate_rest_token(self, prompt_messages: list[PromptMessage], model_config: ModelConfigEntity) -> int:
rest_tokens = 2000
if model_instance.model_rules.max_tokens.max:
curr_message_tokens = model_instance.get_num_tokens(to_prompt_messages(prompt_messages))
max_tokens = model_instance.model_kwargs.max_tokens
rest_tokens = model_instance.model_rules.max_tokens.max - max_tokens - curr_message_tokens
model_context_tokens = model_config.model_schema.model_properties.get(ModelPropertyKey.CONTEXT_SIZE)
if model_context_tokens:
model_type_instance = model_config.provider_model_bundle.model_type_instance
model_type_instance = cast(LargeLanguageModel, model_type_instance)
curr_message_tokens = model_type_instance.get_num_tokens(
model_config.model,
model_config.credentials,
prompt_messages
)
max_tokens = 0
for parameter_rule in model_config.model_schema.parameter_rules:
if (parameter_rule.name == 'max_tokens'
or (parameter_rule.use_template and parameter_rule.use_template == 'max_tokens')):
max_tokens = (model_config.parameters.get(parameter_rule.name)
or model_config.parameters.get(parameter_rule.use_template)) or 0
rest_tokens = model_context_tokens - max_tokens - curr_message_tokens
rest_tokens = max(rest_tokens, 0)
return rest_tokens
@@ -311,16 +420,15 @@ class PromptTransform:
return prompt
def _get_chat_app_completion_model_prompt_messages(self,
app_model_config: AppModelConfig,
prompt_template_entity: PromptTemplateEntity,
inputs: dict,
query: str,
files: List[PromptMessageFile],
context: Optional[str],
memory: Optional[BaseChatMemory],
model_instance: BaseLLM) -> List[PromptMessage]:
memory: Optional[TokenBufferMemory],
model_config: ModelConfigEntity) -> List[PromptMessage]:
raw_prompt = app_model_config.completion_prompt_config_dict['prompt']['text']
conversation_histories_role = app_model_config.completion_prompt_config_dict['conversation_histories_role']
raw_prompt = prompt_template_entity.advanced_completion_prompt_template.prompt
role_prefix = prompt_template_entity.advanced_completion_prompt_template.role_prefix
prompt_messages = []
@@ -331,29 +439,35 @@ class PromptTransform:
self._set_query_variable(query, prompt_template, prompt_inputs)
self._set_histories_variable(memory, raw_prompt, conversation_histories_role, prompt_template, prompt_inputs,
model_instance)
self._set_histories_variable(
memory=memory,
raw_prompt=raw_prompt,
role_prefix=role_prefix,
prompt_template=prompt_template,
prompt_inputs=prompt_inputs,
model_config=model_config
)
prompt = self._format_prompt(prompt_template, prompt_inputs)
prompt_messages.append(PromptMessage(type=MessageType.USER, content=prompt, files=files))
prompt_messages.append(UserPromptMessage(content=prompt))
return prompt_messages
def _get_chat_app_chat_model_prompt_messages(self,
app_model_config: AppModelConfig,
prompt_template_entity: PromptTemplateEntity,
inputs: dict,
query: str,
files: List[PromptMessageFile],
files: List[FileObj],
context: Optional[str],
memory: Optional[BaseChatMemory],
model_instance: BaseLLM) -> List[PromptMessage]:
raw_prompt_list = app_model_config.chat_prompt_config_dict['prompt']
memory: Optional[TokenBufferMemory],
model_config: ModelConfigEntity) -> List[PromptMessage]:
raw_prompt_list = prompt_template_entity.advanced_chat_prompt_template.messages
prompt_messages = []
for prompt_item in raw_prompt_list:
raw_prompt = prompt_item['text']
raw_prompt = prompt_item.text
prompt_template = PromptTemplateParser(template=raw_prompt)
prompt_inputs = {k: inputs[k] for k in prompt_template.variable_keys if k in inputs}
@@ -362,20 +476,31 @@ class PromptTransform:
prompt = self._format_prompt(prompt_template, prompt_inputs)
prompt_messages.append(PromptMessage(type=MessageType(prompt_item['role']), content=prompt))
if prompt_item.role == PromptMessageRole.USER:
prompt_messages.append(UserPromptMessage(content=prompt))
elif prompt_item.role == PromptMessageRole.SYSTEM and prompt:
prompt_messages.append(SystemPromptMessage(content=prompt))
elif prompt_item.role == PromptMessageRole.ASSISTANT:
prompt_messages.append(AssistantPromptMessage(content=prompt))
self._append_chat_histories(memory, prompt_messages, model_instance)
self._append_chat_histories(memory, prompt_messages, model_config)
prompt_messages.append(PromptMessage(type=MessageType.USER, content=query, files=files))
if files:
prompt_message_contents = [TextPromptMessageContent(data=query)]
for file in files:
prompt_message_contents.append(file.prompt_message_content)
prompt_messages.append(UserPromptMessage(content=prompt_message_contents))
else:
prompt_messages.append(UserPromptMessage(content=query))
return prompt_messages
def _get_completion_app_completion_model_prompt_messages(self,
app_model_config: AppModelConfig,
prompt_template_entity: PromptTemplateEntity,
inputs: dict,
files: List[PromptMessageFile],
context: Optional[str]) -> List[PromptMessage]:
raw_prompt = app_model_config.completion_prompt_config_dict['prompt']['text']
raw_prompt = prompt_template_entity.advanced_completion_prompt_template.prompt
prompt_messages = []
@@ -386,21 +511,21 @@ class PromptTransform:
prompt = self._format_prompt(prompt_template, prompt_inputs)
prompt_messages.append(PromptMessage(type=MessageType(MessageType.USER), content=prompt, files=files))
prompt_messages.append(UserPromptMessage(content=prompt))
return prompt_messages
def _get_completion_app_chat_model_prompt_messages(self,
app_model_config: AppModelConfig,
prompt_template_entity: PromptTemplateEntity,
inputs: dict,
files: List[PromptMessageFile],
files: List[FileObj],
context: Optional[str]) -> List[PromptMessage]:
raw_prompt_list = app_model_config.chat_prompt_config_dict['prompt']
raw_prompt_list = prompt_template_entity.advanced_chat_prompt_template.messages
prompt_messages = []
for prompt_item in raw_prompt_list:
raw_prompt = prompt_item['text']
raw_prompt = prompt_item.text
prompt_template = PromptTemplateParser(template=raw_prompt)
prompt_inputs = {k: inputs[k] for k in prompt_template.variable_keys if k in inputs}
@@ -409,11 +534,21 @@ class PromptTransform:
prompt = self._format_prompt(prompt_template, prompt_inputs)
prompt_messages.append(PromptMessage(type=MessageType(prompt_item['role']), content=prompt))
if prompt_item.role == PromptMessageRole.USER:
prompt_messages.append(UserPromptMessage(content=prompt))
elif prompt_item.role == PromptMessageRole.SYSTEM and prompt:
prompt_messages.append(SystemPromptMessage(content=prompt))
elif prompt_item.role == PromptMessageRole.ASSISTANT:
prompt_messages.append(AssistantPromptMessage(content=prompt))
for prompt_message in prompt_messages[::-1]:
if prompt_message.type == MessageType.USER:
prompt_message.files = files
if prompt_message.role == PromptMessageRole.USER:
if files:
prompt_message_contents = [TextPromptMessageContent(data=prompt_message.content)]
for file in files:
prompt_message_contents.append(file.prompt_message_content)
prompt_message.content = prompt_message_contents
break
return prompt_messages