diff --git a/dialog2graph/pipelines/d2g_llm/three_stages_llm.py b/dialog2graph/pipelines/d2g_llm/three_stages_llm.py index 401f4b11..85f27684 100644 --- a/dialog2graph/pipelines/d2g_llm/three_stages_llm.py +++ b/dialog2graph/pipelines/d2g_llm/three_stages_llm.py @@ -14,7 +14,7 @@ from langchain.output_parsers import PydanticOutputParser, OutputFixingParser from langchain.schema import HumanMessage from langchain_openai import ChatOpenAI -from langchain_community.embeddings import HuggingFaceEmbeddings +from langchain_huggingface.embeddings import HuggingFaceEmbeddings from dialog2graph import metrics diff --git a/dialog2graph/pipelines/helpers/parse_data.py b/dialog2graph/pipelines/helpers/parse_data.py index c59afbe8..e944cac2 100644 --- a/dialog2graph/pipelines/helpers/parse_data.py +++ b/dialog2graph/pipelines/helpers/parse_data.py @@ -19,7 +19,7 @@ logger = Logger(__name__) -RawDialogsType = dict | list[list] | list[dict] | Dialog | list[Dialog] | PosixPath +RawDialogsType = dict | list[list] | list[dict] | list[list[dict]] | Dialog | list[Dialog] | PosixPath ValidatedDialogType = ( List[DialogMessage] | List[List[DialogMessage]] | Dialog | List[Dialog] ) diff --git a/dialog2graph/pipelines/model_storage.py b/dialog2graph/pipelines/model_storage.py index 9bc5a343..7a9d5533 100644 --- a/dialog2graph/pipelines/model_storage.py +++ b/dialog2graph/pipelines/model_storage.py @@ -5,14 +5,13 @@ import yaml import re import dotenv -from pydantic._internal._model_construction import ModelMetaclass -from typing import Union, Dict +from typing import Union, Dict, Type from pathlib import Path from pydantic import BaseModel, Field, model_validator -from langchain_community.chat_models import ChatOpenAI +from langchain_openai.chat_models import ChatOpenAI from langchain_core.language_models import BaseChatModel -from langchain_community.embeddings import HuggingFaceEmbeddings +from langchain_huggingface.embeddings import HuggingFaceEmbeddings from dialog2graph.utils.logger import Logger @@ -62,7 +61,7 @@ class StoredData(BaseModel): Attributes: key (str): Key for the stored model. config (dict): Configuration for the stored model. - model_type (Union[Literal["llm"], Literal["emb"]]): Type of the stored model, either "llm" (language model) or "emb" (embedding model). + model_type (Type[BaseChatModel | HuggingFaceEmbeddings]): Type of the stored model, for example ChatOpenAI, HuggingFaceEmbeddings. model (Union[HuggingFaceEmbeddings, BaseChatModel]): The actual model object, which can either be a HuggingFaceEmbeddings instance or a BaseChatModel instance. Methods: @@ -76,7 +75,7 @@ class StoredData(BaseModel): key: str = Field(description="Key for the stored model") config: dict = Field(description="Configuration for the stored model") - model_type: ModelMetaclass = Field(description="Type of the stored model") + model_type: Type[BaseChatModel | HuggingFaceEmbeddings] = Field(description="Type of the stored model") model: Union[ HuggingFaceEmbeddings, BaseChatModel, @@ -140,7 +139,7 @@ def add( self, key: str, config: dict, - model_type: ModelMetaclass, + model_type: Type[BaseChatModel | HuggingFaceEmbeddings], overwright: bool = False, ): """ @@ -155,7 +154,7 @@ def add( Args: key (str): The unique identifier for the model configuration. config (dict): The configuration dictionary for initializing the model. - model_type (ModelMetaclass): The type name of the model to be added. + model_type (Type[BaseChatModel | HuggingFaceEmbeddings]): The type of the model to be added. overwright (bool): Whether to overwright model existing under same key . Raises: diff --git a/examples/pipeline_usage/models_config.yml b/examples/pipeline_usage/models_config.yml index 4a6c6c31..21181317 100644 --- a/examples/pipeline_usage/models_config.yml +++ b/examples/pipeline_usage/models_config.yml @@ -1,20 +1,20 @@ -d2g_llm_filling_llm:v1: +my_filling_model: config: - name: o3-mini - temperature: 1 - model_type: llm -d2g_llm_grouping_llm:v1: + model_name: gpt-3.5-turbo + model_type: ChatOpenAI +three_stages_llm_formatting_llm:v1: config: - name: gpt-4o-latest + model_name: gpt-4o-mini temperature: 0 - model_type: llm -d2g_llm_sim_model:v1: + model_type: ChatOpenAI +three_stages_llm_grouping_llm:v1: + config: + model_name: chatgpt-4o-latest + temperature: 0 + model_type: ChatOpenAI +three_stages_llm_sim_model:v1: config: model_kwargs: device: cpu - model_name: cointegrated/LaBSE-en-ru - model_type: emb -my_model: - config: - name: gpt-3.5-turbo - model_type: llm + model_name: BAAI/bge-m3 + model_type: HuggingFaceEmbeddings diff --git a/examples/pipeline_usage/multiple_dialogs.json b/examples/pipeline_usage/multiple_dialogs.json new file mode 100644 index 00000000..148759ef --- /dev/null +++ b/examples/pipeline_usage/multiple_dialogs.json @@ -0,0 +1,240 @@ +[ + [ + { + "text": "Hello! How can I assist you with your calendar today?", + "participant": "assistant" + }, + { + "text": "I'm having trouble with my calendar not syncing properly.", + "participant": "user" + }, + { + "text": "I'm sorry to hear you're experiencing a sync delay. Can you tell me more about the issue?", + "participant": "assistant" + }, + { + "text": "Yes, I checked but it still doesn't sync.", + "participant": "user" + }, + { + "text": "Could you verify that the time zone settings are properly configured on your devices?", + "participant": "assistant" + }, + { + "text": "Alright, please guide me through the steps.", + "participant": "user" + }, + { + "text": "Sure, let me guide you through adjusting your time zone settings.", + "participant": "assistant" + }, + { + "text": "I want to change the time zone instead.", + "participant": "user" + }, + { + "text": "Of course! Which device would you like to adjust the time zone settings on?", + "participant": "assistant" + }, + { + "text": "Sure, let's adjust the time zone settings.", + "participant": "user" + }, + { + "text": "Sure, let me guide you through adjusting your time zone settings.", + "participant": "assistant" + }, + { + "text": "I've followed the steps and it seems to be working now.", + "participant": "user" + }, + { + "text": "Great! Is your calendar syncing correctly now?", + "participant": "assistant" + }, + { + "text": "Actually, it's still not syncing. I want to try something else.", + "participant": "user" + }, + { + "text": "I'm sorry we couldn't resolve the issue. If you need further assistance, feel free to reach out anytime. Have a great day!", + "participant": "assistant" + } + ], + [ + { + "text": "Hello! How can I assist you with your calendar today?", + "participant": "assistant" + }, + { + "text": "I'm having trouble with my calendar not syncing properly.", + "participant": "user" + }, + { + "text": "I'm sorry to hear you're experiencing a sync delay. Can you tell me more about the issue?", + "participant": "assistant" + }, + { + "text": "Yes, I checked but it still doesn't sync.", + "participant": "user" + }, + { + "text": "Have you checked if your time zone settings are correct on all your devices?", + "participant": "assistant" + }, + { + "text": "Alright, please guide me through the steps.", + "participant": "user" + }, + { + "text": "Sure, let me guide you through adjusting your time zone settings.", + "participant": "assistant" + }, + { + "text": "I want to change the time zone instead.", + "participant": "user" + }, + { + "text": "Of course! Which device would you like to adjust the time zone settings on?", + "participant": "assistant" + }, + { + "text": "Sure, let's adjust the time zone settings.", + "participant": "user" + }, + { + "text": "Sure, let me guide you through adjusting your time zone settings.", + "participant": "assistant" + }, + { + "text": "I've followed the steps and it seems to be working now.", + "participant": "user" + }, + { + "text": "Great! Is your calendar syncing correctly now?", + "participant": "assistant" + }, + { + "text": "Actually, it's still not syncing. I want to try something else.", + "participant": "user" + }, + { + "text": "I'm sorry we couldn't resolve the issue. If you need further assistance, feel free to reach out anytime. Have a great day!", + "participant": "assistant" + } + ], + [ + { + "text": "Hello! How can I assist you with your calendar today?", + "participant": "assistant" + }, + { + "text": "I'm having trouble with my calendar not syncing properly.", + "participant": "user" + }, + { + "text": "I'm sorry to hear you're experiencing a sync delay. Can you tell me more about the issue?", + "participant": "assistant" + }, + { + "text": "Yes, I checked but it still doesn't sync.", + "participant": "user" + }, + { + "text": "Could you verify that the time zone settings are properly configured on your devices?", + "participant": "assistant" + }, + { + "text": "Time zone settings are correct, but the issue persists.", + "participant": "user" + }, + { + "text": "If time zone settings are correct, we can try refreshing the calendar app or reinstalling it.", + "participant": "assistant" + }, + { + "text": "After adjusting, it still doesn't sync.", + "participant": "user" + }, + { + "text": "Great! Is your calendar syncing correctly now?", + "participant": "assistant" + }, + { + "text": "Actually, it's still not syncing. I want to try something else.", + "participant": "user" + }, + { + "text": "I'm sorry we couldn't resolve the issue. If you need further assistance, feel free to reach out anytime. Have a great day!", + "participant": "assistant" + } + ], + [ + { + "text": "Hello! How can I assist you with your calendar today?", + "participant": "assistant" + }, + { + "text": "I'm having trouble with my calendar not syncing properly.", + "participant": "user" + }, + { + "text": "I'm sorry to hear you're experiencing a sync delay. Can you tell me more about the issue?", + "participant": "assistant" + }, + { + "text": "Yes, I checked but it still doesn't sync.", + "participant": "user" + }, + { + "text": "Have you checked if your time zone settings are correct on all your devices?", + "participant": "assistant" + }, + { + "text": "Time zone settings are correct, but the issue persists.", + "participant": "user" + }, + { + "text": "If time zone settings are correct, we can try refreshing the calendar app or reinstalling it.", + "participant": "assistant" + }, + { + "text": "After adjusting, it still doesn't sync.", + "participant": "user" + }, + { + "text": "Great! Is your calendar syncing correctly now?", + "participant": "assistant" + }, + { + "text": "Actually, it's still not syncing. I want to try something else.", + "participant": "user" + }, + { + "text": "I'm sorry we couldn't resolve the issue. If you need further assistance, feel free to reach out anytime. Have a great day!", + "participant": "assistant" + } + ], + [ + { + "text": "Hello! How can I assist you with your calendar today?", + "participant": "assistant" + }, + { + "text": "I'm having trouble with my calendar not syncing properly.", + "participant": "user" + }, + { + "text": "I'm sorry to hear you're experiencing a sync delay. Can you tell me more about the issue?", + "participant": "assistant" + }, + { + "text": "I think I'll handle it later. Thanks anyway.", + "participant": "user" + }, + { + "text": "I'm sorry we couldn't resolve the issue. If you need further assistance, feel free to reach out anytime. Have a great day!", + "participant": "assistant" + } + ] +] \ No newline at end of file diff --git a/examples/pipeline_usage/pipeline_example.ipynb b/examples/pipeline_usage/pipeline_example.ipynb index 554536d8..55615da4 100644 --- a/examples/pipeline_usage/pipeline_example.ipynb +++ b/examples/pipeline_usage/pipeline_example.ipynb @@ -11,24 +11,48 @@ "First of all we need to import the `ModelStorage` and `Pipeline` we will be using." ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import getpass\n", + "import logging\n", + "import warnings\n", + "\n", + "logging.disable(level=logging.CRITICAL)\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/askatasuna/Документы/DeepPavlov/chatsky-llm-autoconfig/.venv/lib/python3.12/site-packages/pydantic/_internal/_fields.py:198: UserWarning: Field name \"validate\" in \"Dialog\" shadows an attribute in parent \"BaseModel\"\n", - " warnings.warn(\n", - "2025-04-01 21:17:00,978 - datasets - INFO - PyTorch version 2.6.0 available.\n" - ] - } - ], + "outputs": [], + "source": [ + "# Required to run D2GLLMPipeline\n", + "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()\n", + "\n", + "# Replace if you use different base_url\n", + "base_url = \"\"\n", + "if base_url:\n", + " os.environ[\"OPENAI_BASE_URL\"] = base_url" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], "source": [ + "from langchain_openai.chat_models import ChatOpenAI\n", + "\n", "from dialog2graph.pipelines.model_storage import ModelStorage\n", - "from dialog2graph.pipelines.d2g_llm.pipeline import D2GLLMPipeline" + "from dialog2graph.pipelines.d2g_llm.pipeline import D2GLLMPipeline\n", + "from dialog2graph.pipelines.helpers.parse_data import PipelineRawDataType" ] }, { @@ -42,59 +66,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2025-04-01 21:17:01,652 - dialog2graph.pipelines.model_storage - INFO - Added llm model 'my_model' to storage\n", - "2025-04-01 21:17:01,707 - dialog2graph.pipelines.model_storage - INFO - Added llm model 'd2g_llm_grouping_llm:v1' to storage\n", - "2025-04-01 21:17:01,760 - dialog2graph.pipelines.model_storage - INFO - Added llm model 'd2g_llm_filling_llm:v1' to storage\n", - "2025-04-01 21:17:01,762 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: cointegrated/LaBSE-en-ru\n", - "2025-04-01 21:17:05,250 - dialog2graph.pipelines.model_storage - INFO - Added emb model 'd2g_llm_sim_model:v1' to storage\n" - ] - } - ], + "outputs": [], "source": [ "ms = ModelStorage()\n", "ms.add(\n", - " \"my_model\",\n", - " config={\"name\": \"gpt-3.5-turbo\"},\n", - " model_type=\"llm\",\n", + " \"my_filling_model\",\n", + " config={\"model_name\": \"gpt-3.5-turbo\"},\n", + " model_type=ChatOpenAI,\n", ")\n", - "\n", - "pipe = D2GLLMPipeline(ms, formatting_llm=\"my_model\")" + "pipe = D2GLLMPipeline(\"d2g_pipeline\", model_storage=ms, filling_llm=\"my_filling_model\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Example of building graph based on single dialogue" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 50, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2025-04-01 21:17:10,679 - httpx - INFO - HTTP Request: POST https://api.vsegpt.ru/v1/chat/completions \"HTTP/1.1 200 OK\"\n", - "2025-04-01 21:17:10,721 - chromadb.telemetry.product.posthog - INFO - Anonymized telemetry enabled. See https://docs.trychroma.com/telemetry for more information.\n", - "/home/askatasuna/Документы/DeepPavlov/chatsky-llm-autoconfig/dialog2graph/utils/vector_stores.py:42: UserWarning: Relevance scores must be between 0 and 1, got [(Document(id='0', metadata={'id': 0}, page_content='hey there! how can i help you today?'), 0.9999999999998331), (Document(id='1', metadata={'id': 1}, page_content='sure! i can help with that. when is your flight, and where are you departing from?'), 0.3425369380032218), (Document(id='3', metadata={'id': 3}, page_content='no worries! feel free to reach out anytime.'), 0.09999855712188555), (Document(id='4', metadata={'id': 4}, page_content=\"you're welcome! have a fantastic trip!\"), 0.012217798441700123), (Document(id='2', metadata={'id': 2}, page_content=\"if you'd prefer, i can send you options for ride-share services instead. would you like that?\"), -0.15093265214397067)]\n", - " docs = self.assistant_store.similarity_search_with_relevance_scores(\n", - "/home/askatasuna/Документы/DeepPavlov/chatsky-llm-autoconfig/dialog2graph/utils/vector_stores.py:42: UserWarning: Relevance scores must be between 0 and 1, got [(Document(id='2', metadata={'id': 2}, page_content=\"if you'd prefer, i can send you options for ride-share services instead. would you like that?\"), 0.9999999999997823), (Document(id='1', metadata={'id': 1}, page_content='sure! i can help with that. when is your flight, and where are you departing from?'), 0.07645962652224825), (Document(id='4', metadata={'id': 4}, page_content=\"you're welcome! have a fantastic trip!\"), -0.1350976596899427), (Document(id='0', metadata={'id': 0}, page_content='hey there! how can i help you today?'), -0.15093282073136471), (Document(id='3', metadata={'id': 3}, page_content='no worries! feel free to reach out anytime.'), -0.1615920958945578)]\n", - " docs = self.assistant_store.similarity_search_with_relevance_scores(\n", - "/home/askatasuna/Документы/DeepPavlov/chatsky-llm-autoconfig/dialog2graph/utils/vector_stores.py:42: UserWarning: Relevance scores must be between 0 and 1, got [(Document(id='3', metadata={'id': 3}, page_content='no worries! feel free to reach out anytime.'), 0.9999999999998337), (Document(id='4', metadata={'id': 4}, page_content=\"you're welcome! have a fantastic trip!\"), 0.1991303893367219), (Document(id='0', metadata={'id': 0}, page_content='hey there! how can i help you today?'), 0.09999855712188555), (Document(id='1', metadata={'id': 1}, page_content='sure! i can help with that. when is your flight, and where are you departing from?'), 0.09619067365262324), (Document(id='2', metadata={'id': 2}, page_content=\"if you'd prefer, i can send you options for ride-share services instead. would you like that?\"), -0.1615924330693459)]\n", - " docs = self.assistant_store.similarity_search_with_relevance_scores(\n", - "/home/askatasuna/Документы/DeepPavlov/chatsky-llm-autoconfig/dialog2graph/utils/vector_stores.py:42: UserWarning: Relevance scores must be between 0 and 1, got [(Document(id='4', metadata={'id': 4}, page_content=\"you're welcome! have a fantastic trip!\"), 0.9999999999998329), (Document(id='3', metadata={'id': 3}, page_content='no worries! feel free to reach out anytime.'), 0.1991303893367219), (Document(id='1', metadata={'id': 1}, page_content='sure! i can help with that. when is your flight, and where are you departing from?'), 0.04436421132532331), (Document(id='0', metadata={'id': 0}, page_content='hey there! how can i help you today?'), 0.012217629854306078), (Document(id='2', metadata={'id': 2}, page_content=\"if you'd prefer, i can send you options for ride-share services instead. would you like that?\"), -0.1350977439836396)]\n", - " docs = self.assistant_store.similarity_search_with_relevance_scores(\n", - "2025-04-01 21:17:11,456 - dialog2graph.pipelines.core.graph - WARNING - requires pygraphviz http://pygraphviz.github.io/.\n", - "Install pygraphviz from http://pygraphviz.github.io/ .\n", - "Falling back to default layout.\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -121,55 +120,139 @@ " {\"text\": \"Alright, thanks anyway.\", \"participant\": \"user\"},\n", " {\"text\": \"You're welcome! Have a fantastic trip!\", \"participant\": \"assistant\"},\n", "]\n", - "graph = pipe.invoke(data)\n", + "data = PipelineRawDataType(dialogs=data)\n", + "graph, report = pipe.invoke(data)\n", "graph.visualise_short(\"transfer\")" ] }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 'greeting',\n", + " 2: 'ask_flight_info',\n", + " 3: 'offer_rideshare',\n", + " 4: 'closing_no_help',\n", + " 5: 'farewell'}" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{node['id']: node['label'] for node in graph.graph_dict['nodes']}" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Also you can load and dump the models with their configs to the `.yml` files." + "Use multiple dialogues to build complex graphs" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "2025-04-01 21:17:11,641 - dialog2graph.pipelines.model_storage - INFO - Saved 4 models to models_config.yml\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with open(\"multiple_dialogs.json\") as f:\n", + " multiple_dialogs = json.load(f)\n", + "\n", + "data = PipelineRawDataType(dialogs=multiple_dialogs)\n", + "graph, report = pipe.invoke(data)\n", + "graph.visualise_short(\"transfer\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 'start',\n", + " 2: 'ask_issue_details',\n", + " 3: 'ask_timezone_verification',\n", + " 4: 'guide_timezone_adjustment',\n", + " 5: 'ask_device_for_timezone',\n", + " 6: 'suggest_refresh_or_reinstall',\n", + " 7: 'ask_sync_confirmation',\n", + " 8: 'closing_unresolved'}" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" } ], + "source": [ + "{node['id']: node['label'] for node in graph.graph_dict['nodes']}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Also you can load and dump the models with their configs to the `.yml` files." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], "source": [ "ms.save(\"models_config.yml\")" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "d2g_llm_filling_llm:v1:\n", - " name: o3-mini\n", - " temperature: 1\n", - "d2g_llm_grouping_llm:v1:\n", - " name: gpt-4o-latest\n", - " temperature: 0\n", - "d2g_llm_sim_model:v1:\n", - " model_kwargs:\n", - " device: cpu\n", - " model_name: cointegrated/LaBSE-en-ru\n", - "my_model:\n", - " name: gpt-3.5-turbo\n" + "my_filling_model:\n", + " config:\n", + " model_name: gpt-3.5-turbo\n", + " model_type: ChatOpenAI\n", + "three_stages_llm_formatting_llm:v1:\n", + " config:\n", + " model_name: gpt-4o-mini\n", + " temperature: 0\n", + " model_type: ChatOpenAI\n", + "three_stages_llm_grouping_llm:v1:\n", + " config:\n", + " model_name: chatgpt-4o-latest\n", + " temperature: 0\n", + " model_type: ChatOpenAI\n", + "three_stages_llm_sim_model:v1:\n", + " config:\n", + " model_kwargs:\n", + " device: cpu\n", + " model_name: BAAI/bge-m3\n", + " model_type: HuggingFaceEmbeddings\n" ] } ], @@ -180,7 +263,7 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "dialog2graph-py3.12 (3.12.3)", "language": "python", "name": "python3" },