From a4bcbe49892ce6dcaf82d1e8f339341c383020da Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Tue, 24 Sep 2024 21:33:23 -0700 Subject: [PATCH 01/19] add costorm project to knowledge_storm --- .../collaborative_storm/__init__.py | 4 + knowledge_storm/collaborative_storm/engine.py | 691 ++++++++++++++++++ .../collaborative_storm/modules/__init__.py | 8 + .../modules/article_generation.py | 123 ++++ .../collaborative_storm/modules/callback.py | 197 +++++ .../modules/co_storm_agents.py | 341 +++++++++ .../modules/collaborative_storm_utils.py | 380 ++++++++++ .../costorm_expert_utterance_generator.py | 160 ++++ .../modules/expert_generation.py | 83 +++ .../modules/grounded_question_answering.py | 163 +++++ .../modules/grounded_question_generation.py | 104 +++ .../modules/information_insertion_module.py | 422 +++++++++++ .../modules/knowledge_base_summary.py | 32 + .../modules/simulate_user.py | 37 + .../modules/warmstart_hierarchical_chat.py | 398 ++++++++++ 15 files changed, 3143 insertions(+) create mode 100644 knowledge_storm/collaborative_storm/__init__.py create mode 100644 knowledge_storm/collaborative_storm/engine.py create mode 100644 knowledge_storm/collaborative_storm/modules/__init__.py create mode 100644 knowledge_storm/collaborative_storm/modules/article_generation.py create mode 100644 knowledge_storm/collaborative_storm/modules/callback.py create mode 100644 knowledge_storm/collaborative_storm/modules/co_storm_agents.py create mode 100644 knowledge_storm/collaborative_storm/modules/collaborative_storm_utils.py create mode 100644 knowledge_storm/collaborative_storm/modules/costorm_expert_utterance_generator.py create mode 100644 knowledge_storm/collaborative_storm/modules/expert_generation.py create mode 100644 knowledge_storm/collaborative_storm/modules/grounded_question_answering.py create mode 100644 knowledge_storm/collaborative_storm/modules/grounded_question_generation.py create mode 100644 knowledge_storm/collaborative_storm/modules/information_insertion_module.py create mode 100644 knowledge_storm/collaborative_storm/modules/knowledge_base_summary.py create mode 100644 knowledge_storm/collaborative_storm/modules/simulate_user.py create mode 100644 knowledge_storm/collaborative_storm/modules/warmstart_hierarchical_chat.py diff --git a/knowledge_storm/collaborative_storm/__init__.py b/knowledge_storm/collaborative_storm/__init__.py new file mode 100644 index 0000000..62e6bfb --- /dev/null +++ b/knowledge_storm/collaborative_storm/__init__.py @@ -0,0 +1,4 @@ +from .modules import * +from .engine import * +from .demo_runner import * +from .baseline import * diff --git a/knowledge_storm/collaborative_storm/engine.py b/knowledge_storm/collaborative_storm/engine.py new file mode 100644 index 0000000..e8c6092 --- /dev/null +++ b/knowledge_storm/collaborative_storm/engine.py @@ -0,0 +1,691 @@ +import dspy +import os +from dataclasses import dataclass, field, asdict +from typing import List, Union, Literal, Optional, Dict + +from .modules import collaborative_storm_utils as collaborative_storm_utils +from .modules.callback import BaseCallbackHandler +from .modules.co_storm_agents import ( + SimulatedUser, + PureRAGAgent, + Moderator, + CoStormExpert, +) +from .modules.expert_generation import GenerateExpertModule +from .modules.warmstart_hierarchical_chat import WarmStartModule +from ..dataclass import ConversationTurn, KnowledgeBase +from ..interface import LMConfigs, Agent +from ..logging_wrapper import LoggingWrapper +from ..lm import OpenAIModel, AzureOpenAIModel, TogetherClient +from ..rm import BingSearch + + +class CollaborativeStormLMConfigs(LMConfigs): + """Configurations for LLM used in different parts of STORM. + + Given that different parts in STORM framework have different complexity, we use different LLM configurations + to achieve a balance between quality and efficiency. If no specific configuration is provided, we use the default + setup in the paper. + """ + + def __init__(self): + self.question_answering_lm = None + self.discourse_manage_lm = None + self.utterance_polishing_lm = None + self.warmstart_outline_gen_lm = None + self.question_asking_lm = None + self.knowledge_base_lm = None + + def init( + self, + lm_type: Literal["openai", "azure", "together"], + temperature: Optional[float] = 1.0, + top_p: Optional[float] = 0.9, + ): + if lm_type and lm_type == "openai": + openai_kwargs = { + "api_key": os.getenv("OPENAI_API_KEY"), + "api_provider": "openai", + "temperature": temperature, + "top_p": top_p, + "api_base": None, + } + self.question_answering_lm = OpenAIModel( + model="gpt-4o-2024-05-13", max_tokens=1000, **openai_kwargs + ) + self.discourse_manage_lm = OpenAIModel( + model="gpt-4o-2024-05-13", max_tokens=500, **openai_kwargs + ) + self.utterance_polishing_lm = OpenAIModel( + model="gpt-4o-2024-05-13", max_tokens=2000, **openai_kwargs + ) + self.warmstart_outline_gen_lm = OpenAIModel( + model="gpt-4-1106-preview", max_tokens=500, **openai_kwargs + ) + self.question_asking_lm = OpenAIModel( + model="gpt-4o-2024-05-13", max_tokens=300, **openai_kwargs + ) + self.knowledge_base_lm = OpenAIModel( + model="gpt-4o-2024-05-13", max_tokens=1000, **openai_kwargs + ) + elif lm_type and lm_type == "azure": + azure_kwargs = { + "api_key": os.getenv("AZURE_API_KEY"), + "temperature": temperature, + "top_p": top_p, + "api_base": os.getenv("AZURE_API_BASE"), + "api_version": os.getenv("AZURE_API_VERSION"), + } + self.question_answering_lm = AzureOpenAIModel( + model="gpt-4o", max_tokens=1000, **azure_kwargs, model_type="chat" + ) + self.discourse_manage_lm = AzureOpenAIModel( + model="gpt-4o", max_tokens=500, **azure_kwargs, model_type="chat" + ) + self.utterance_polishing_lm = AzureOpenAIModel( + model="gpt-4o", max_tokens=2000, **azure_kwargs, model_type="chat" + ) + self.warmstart_outline_gen_lm = AzureOpenAIModel( + model="gpt-4o", max_tokens=300, **azure_kwargs, model_type="chat" + ) + self.question_asking_lm = AzureOpenAIModel( + model="gpt-4o", max_tokens=300, **azure_kwargs, model_type="chat" + ) + self.knowledge_base_lm = AzureOpenAIModel( + model="gpt-4o", max_tokens=1000, **azure_kwargs, model_type="chat" + ) + elif lm_type and lm_type == "together": + together_kwargs = { + "api_key": os.getenv("TOGETHER_API_KEY"), + "temperature": temperature, + "top_p": top_p, + } + self.question_answering_lm = TogetherClient( + model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", + max_tokens=1000, + model_type="chat", + **together_kwargs, + ) + self.discourse_manage_lm = TogetherClient( + model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", + max_tokens=500, + model_type="chat", + **together_kwargs, + ) + self.utterance_polishing_lm = TogetherClient( + model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", + max_tokens=2000, + model_type="chat", + **together_kwargs, + ) + self.warmstart_outline_gen_lm = TogetherClient( + model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", + max_tokens=500, + model_type="chat", + **together_kwargs, + ) + self.question_asking_lm = TogetherClient( + model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", + max_tokens=300, + model_type="chat", + **together_kwargs, + ) + self.knowledge_base_lm = TogetherClient( + model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", + max_tokens=1000, + model_type="chat", + **together_kwargs, + ) + else: + raise Exception( + "No valid OpenAI API provider is provided. Cannot use default LLM configurations." + ) + + def set_question_answering_lm(self, model: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.question_answering_lm = model + + def set_discourse_manage_lm(self, model: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.discourse_manage_lm = model + + def set_utterance_polishing_lm(self, model: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.utterance_polishing_lm = model + + def set_warmstart_outline_gen_lm(self, model: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.warmstart_outline_gen_lm = model + + def set_question_asking_lm(self, model: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.question_asking_lm = model + + def set_knowledge_base_lm(self, model: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.knowledge_base_lm = model + + def collect_and_reset_lm_usage(self): + lm_usage = {} + for attr_name in self.__dict__: + if "_lm" in attr_name and hasattr( + getattr(self, attr_name), "get_usage_and_reset" + ): + usage = getattr(self, attr_name).get_usage_and_reset() + if any( + value["prompt_tokens"] != 0 or value["completion_tokens"] != 0 + for value in usage.values() + ): + lm_usage[attr_name] = usage + return lm_usage + + def to_dict(self): + """ + Converts the CollaborativeStormLMConfigs instance to a dictionary representation. + + Returns: + dict: The dictionary representation of the CollaborativeStormLMConfigs. + """ + config_dict = {} + for attr_name in self.__dict__: + config_dict[attr_name] = getattr(self, attr_name).kwargs + return config_dict + + +@dataclass +class RunnerArgument: + """Arguments for controlling the STORM Wiki pipeline.""" + + topic: str = field( + metadata={"help": "Topic of discourse"}, + ) + retrieve_top_k: int = field( + default=10, + metadata={"help": "retrieve top k results for each query in retriever"}, + ) + max_search_queries: int = field( + default=2, + metadata={ + "help": "Maximum number of search queries to consider for each question." + }, + ) + total_conv_turn: int = field( + default=20, + metadata={"help": "Maximum number turn in conversation."}, + ) + max_search_thread: int = field( + default=5, + metadata={"help": "Maximum number of parallel thread for retriever"}, + ) + max_search_queries_per_turn: int = field( + default=3, + metadata={"help": "Maximum number of search queries to consider in each turn."}, + ) + warmstart_max_num_experts: int = field( + default=3, + metadata={ + "help": "Max number of experts in perspective guided QA in warm start process" + }, + ) + warmstart_max_turn_per_experts: int = field( + default=2, + metadata={"help": "Max number of turns per perspective in warm start process"}, + ) + warmstart_max_thread: int = field( + default=3, + metadata={ + "help": "Max number thread for parallel perspective guided QA in warm start process" + }, + ) + max_thread_num: int = field( + default=10, + metadata={ + "help": "Maximum number of threads to use. " + "Consider reducing it if keep getting 'Exceed rate limit' error when calling LM API." + }, + ) + max_num_round_table_experts: int = field( + default=2, + metadata={"help": "Max number of active experts in round table discussion."}, + ) + moderator_override_N_consecutive_answering_turn: int = field( + default=3, + metadata={ + "help": "Number of consecutive experts answering turn before moderator override the conversation" + }, + ) + node_expansion_trigger_count: int = field( + default=10, + metadata={ + "help": "Trigger node expansion for node that contain more than N snippets" + }, + ) + disable_moderator: bool = field( + default=False, + metadata={"help": "If True, disable moderator."}, + ) + disable_multi_experts: bool = field( + default=False, + metadata={"help": "If True, disable moderator."}, + ) + rag_only_baseline_mode: bool = field( + default=False, + metadata={"help": "If True, switch to rag online baseline mode"}, + ) + + def to_dict(self): + """ + Converts the RunnerArgument instance to a dictionary representation. + + Returns: + dict: The dictionary representation of the RunnerArgument. + """ + return asdict(self) + + @classmethod + def from_dict(cls, data): + """ + Constructs a RunnerArgument instance from a dictionary representation. + + Args: + data (dict): The dictionary representation of the RunnerArgument. + + Returns: + RunnerArgument: The constructed RunnerArgument instance. + """ + return cls(**data) + + +@dataclass +class TurnPolicySpec: + should_reorganize_knowledge_base: bool = False + should_update_experts_list: bool = False + should_polish_utterance: bool = False + agent: Agent = None + + +class DiscourseManager: + def __init__( + self, + logging_wrapper: LoggingWrapper, + lm_config: CollaborativeStormLMConfigs, + runner_argument: RunnerArgument, + rm: dspy.Retrieve, + callback_handler: BaseCallbackHandler, + ): + # parameter management + self.lm_config = lm_config + self.runner_argument = runner_argument + self.logging_wrapper = logging_wrapper + self.callback_handler = callback_handler + self.rm = rm + # role management + self.experts: List[CoStormExpert] = [] + self.simulated_user: SimulatedUser = SimulatedUser( + topic=self.runner_argument.topic, + role_name="Guest", + role_description="", + intent=None, + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + callback_handler=self.callback_handler, + ) + self.pure_rag_agent: PureRAGAgent = PureRAGAgent( + topic=self.runner_argument.topic, + role_name="PureRAG", + role_description="", + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + rm=self.rm, + callback_handler=self.callback_handler, + ) + self.moderator: Moderator = Moderator( + topic=self.runner_argument.topic, + role_name="Moderator", + role_description="", + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + callback_handler=self.callback_handler, + ) + self.general_knowledge_provider = CoStormExpert( + topic=self.runner_argument.topic, + role_name="General Knowledge Provider", + role_description="Focus on broadly covering the basic facts about the question.", + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + rm=self.rm, + callback_handler=self.callback_handler, + ) + self.generate_expert_module = GenerateExpertModule( + engine=self.lm_config.discourse_manage_lm + ) + self.next_turn_moderator_override = False + + def serialize_experts(self) -> List[Dict]: + return [ + { + "topic": expert.topic, + "role_name": expert.role_name, + "role_description": expert.role_description, + } + for expert in self.experts + ] + + def deserialize_experts(self, data: List[Dict]): + for expert_data in data: + self.experts.append( + CoStormExpert( + topic=expert_data["topic"], + role_name=expert_data["role_name"], + role_description=expert_data["role_description"], + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + rm=self.rm, + callback_handler=self.callback_handler, + ) + ) + + def _should_generate_question( + self, conversation_history: List[ConversationTurn] + ) -> bool: + consecutive_non_questioning_turn = 0 + for conv_turn in reversed(conversation_history): + if conv_turn.utterance_type not in [ + "Original Question", + "Information Request", + ]: + consecutive_non_questioning_turn += 1 + else: + break + return ( + consecutive_non_questioning_turn + >= self.runner_argument.moderator_override_N_consecutive_answering_turn + ) + + def _parse_expert_names_to_agent(self, expert_descriptions: Union[str, List[str]]): + if type(expert_descriptions) == str: + expert_descriptions = [expert_descriptions] + agents: CoStormExpert = [] + for expert_name in expert_descriptions: + role_name, role_description = expert_name.split(":") + role_name = role_name.strip() + role_description = role_description.strip() + new_costorm_expert = CoStormExpert( + topic=self.runner_argument.topic, + role_name=role_name, + role_description=role_description, + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + rm=self.rm, + callback_handler=self.callback_handler, + ) + agents.append(new_costorm_expert) + return agents + + def _update_expert_list_from_utterance(self, focus: str, background_info: str): + expert_names = self.generate_expert_module( + topic=self.runner_argument.topic, + background_info=background_info, + focus=focus, + num_experts=self.runner_argument.max_num_round_table_experts, + ).experts + self.experts = self._parse_expert_names_to_agent(expert_names) + + def _is_last_turn_questioning(self, conversation_history: List[ConversationTurn]): + return conversation_history and conversation_history[-1].utterance_type in [ + "Original Question", + "Information Request", + ] + + def get_next_turn_policy( + self, + conversation_history: List[ConversationTurn], + dry_run=False, + simulate_user=False, + simulate_user_intent: str = None, + ) -> TurnPolicySpec: + next_turn_policy = TurnPolicySpec() + if simulate_user: + self.simulated_user.intent = simulate_user_intent + next_turn_policy.agent = self.simulated_user + elif self.runner_argument.rag_only_baseline_mode: + assert self.conversation_history[-1].role == "Guest" + next_turn_policy.agent = self.pure_rag_agent + elif ( + not self.runner_argument.disable_moderator + and self._should_generate_question(conversation_history) + ): + next_turn_policy.agent = self.moderator + next_turn_policy.should_reorganize_knowledge_base = True + elif self.next_turn_moderator_override: + next_turn_policy.agent = self.moderator + if not dry_run: + self.next_turn_moderator_override = False + # experts RAG gen + else: + next_turn_policy.agent = self.general_knowledge_provider + if ( + not self._is_last_turn_questioning(conversation_history) + and not self.runner_argument.disable_multi_experts + ): + if dry_run: + next_turn_policy.agent = self.experts[0] + else: + next_turn_policy.agent = self.experts.pop(0) + self.experts.append(next_turn_policy.agent) + next_turn_policy.should_update_experts_list = ( + self._is_last_turn_questioning(conversation_history) + and not self.runner_argument.disable_multi_experts + ) + next_turn_policy.should_polish_utterance = True + return next_turn_policy + + +class CoStormRunner: + def __init__( + self, + lm_config: CollaborativeStormLMConfigs, + runner_argument: RunnerArgument, + logging_wrapper: LoggingWrapper, + rm: Optional[dspy.Retrieve] = None, + callback_handler: BaseCallbackHandler = None, + ): + self.runner_argument = runner_argument + self.lm_config = lm_config + self.logging_wrapper = logging_wrapper + self.callback_handler = callback_handler + if rm is None: + self.rm = BingSearch(k=runner_argument.retrieve_top_k) + else: + self.rm = rm + self.conversation_history = [] + self.warmstart_conv_archive = [] + self.knowledge_base = KnowledgeBase( + topic=self.runner_argument.topic, + knowledge_base_lm=self.lm_config.knowledge_base_lm, + node_expansion_trigger_count=self.runner_argument.node_expansion_trigger_count, + ) + self.discourse_manager = DiscourseManager( + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + rm=self.rm, + callback_handler=callback_handler, + ) + + def to_dict(self): + return { + "runner_argument": self.runner_argument.to_dict(), + "lm_config": self.lm_config.to_dict(), + "conversation_history": [ + turn.to_dict() for turn in self.conversation_history + ], + "warmstart_conv_archive": [ + turn.to_dict() for turn in self.warmstart_conv_archive + ], + "experts": self.discourse_manager.serialize_experts(), + "knowledge_base": self.knowledge_base.to_dict(), + } + + @classmethod + def from_dict(cls, data): + # FIXME: does not use the lm_config data but naively use default setting + lm_config = CollaborativeStormLMConfigs() + lm_config.init(lm_type=os.getenv("OPENAI_API_TYPE")) + costorm_runner = cls( + lm_config=lm_config, + runner_argument=RunnerArgument.from_dict(data["runner_argument"]), + logging_wrapper=LoggingWrapper(lm_config), + ) + costorm_runner.conversation_history = [ + ConversationTurn.from_dict(turn) for turn in data["conversation_history"] + ] + costorm_runner.warmstart_conv_archive = [ + ConversationTurn.from_dict(turn) + for turn in data.get("warmstart_conv_archive", []) + ] + costorm_runner.discourse_manager.deserialize_experts(data["experts"]) + costorm_runner.knowledge_base = KnowledgeBase.from_dict( + data=data["knowledge_base"], + knowledge_base_lm=costorm_runner.lm_config.knowledge_base_lm, + node_expansion_trigger_count=costorm_runner.runner_argument.node_expansion_trigger_count, + ) + return costorm_runner + + def warm_start(self): + with self.logging_wrapper.log_pipeline_stage( + pipeline_stage=f"warm start stage" + ): + if not self.runner_argument.rag_only_baseline_mode: + warm_start_module = WarmStartModule( + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + rm=self.rm, + callback_handler=self.callback_handler, + ) + + warmstart_conv, warmstart_revised_conv, warmstart_experts = ( + warm_start_module.initiate_warm_start( + topic=self.runner_argument.topic, + knowledge_base=self.knowledge_base, + ) + ) + self.discourse_manager.experts = ( + self.discourse_manager._parse_expert_names_to_agent( + warmstart_experts + ) + ) + self.discourse_manager.next_turn_moderator_override = True + self.conversation_history = ( + warmstart_revised_conv if warmstart_revised_conv else warmstart_conv + ) + self.warmstart_conv_archive = warmstart_conv + self.knowledge_base.reogranize() + else: + if self.knowledge_base is None: + self.knowledge_base = KnowledgeBase( + topic=self.runner_argument.topic + ) + if self.conversation_history is None: + self.conversation_history = [] + conv_turn = ( + self.discourse_manager.pure_rag_agent.generate_topic_background() + ) + self.conversation_history.append(conv_turn) + self.knowledge_base.update_from_conv_turn( + conv_turn=conv_turn, + allow_create_new_node=True, + insert_under_root=self.runner_argument.rag_only_baseline_mode, + ) + + def generate_report(self) -> str: + with self.logging_wrapper.log_pipeline_stage("report generation stage"): + with self.logging_wrapper.log_event( + "report generation stage: generate report" + ): + return self.knowledge_base.to_report() + + def dump_logging_and_reset(self): + return self.logging_wrapper.dump_logging_and_reset() + + def get_next_turn_experts_for_frontend_render(self): + turn_policy = self.discourse_manager.get_next_turn_policy( + conversation_history=self.conversation_history, + simulate_user=False, + dry_run=True, + ) + return turn_policy.agent.role_name + + def step( + self, + user_utterance: str = "", + simulate_user: bool = False, + simulate_user_intent: str = "", + ) -> ConversationTurn: + last_conv_turn = self.conversation_history[-1] + cur_turn_name = f"conv turn: {len(self.conversation_history) + 1}" + with self.logging_wrapper.log_pipeline_stage( + pipeline_stage=f"{cur_turn_name} stage" + ): + conv_turn = None + if user_utterance: + self.discourse_manager.next_turn_moderator_override = False + conv_turn = ConversationTurn( + role="Guest", + raw_utterance=user_utterance, + utterance_type="Original Question", + ) + self.conversation_history.append(conv_turn) + else: + with self.logging_wrapper.log_event( + f"{cur_turn_name}: get turn policy" + ): + if self.callback_handler is not None: + self.callback_handler.on_turn_policy_planning_start() + turn_policy = self.discourse_manager.get_next_turn_policy( + conversation_history=self.conversation_history, + simulate_user=simulate_user, + simulate_user_intent=simulate_user_intent, + dry_run=False, + ) + + with self.logging_wrapper.log_event( + f"{cur_turn_name}: generate utterance" + ): + conv_turn = turn_policy.agent.generate_utterance( + knowledge_base=self.knowledge_base, + conversation_history=self.conversation_history, + ) + + if turn_policy.should_update_experts_list: + with self.logging_wrapper.log_event( + f"{cur_turn_name}: update experts list" + ): + self.discourse_manager._update_expert_list_from_utterance( + focus=last_conv_turn.raw_utterance, + background_info=conv_turn.raw_utterance, + ) + + if conv_turn is not None: + self.conversation_history.append(conv_turn) + with self.logging_wrapper.log_event( + f"{cur_turn_name}: insert into knowledge base" + ): + if self.callback_handler is not None: + self.callback_handler.on_mindmap_insert_start() + self.knowledge_base.update_from_conv_turn( + conv_turn=conv_turn, + allow_create_new_node=True, + insert_under_root=self.runner_argument.rag_only_baseline_mode, + ) + if self.callback_handler is not None: + self.callback_handler.on_mindmap_insert_end() + if turn_policy.should_reorganize_knowledge_base: + with self.logging_wrapper.log_event( + f"{cur_turn_name}: reorganize knowledge base" + ): + if self.callback_handler is not None: + self.callback_handler.on_mindmap_reorg_start() + self.knowledge_base.reogranize() + return conv_turn diff --git a/knowledge_storm/collaborative_storm/modules/__init__.py b/knowledge_storm/collaborative_storm/modules/__init__.py new file mode 100644 index 0000000..3807c64 --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/__init__.py @@ -0,0 +1,8 @@ +from .article_generation import * +from .grounded_question_answering import * +from .grounded_question_generation import * +from .information_insertion_module import * +from .simulate_user import * +from .warmstart_hierarchical_chat import * +from .knowledge_base_summary import * +from .costorm_expert_utterance_generator import * diff --git a/knowledge_storm/collaborative_storm/modules/article_generation.py b/knowledge_storm/collaborative_storm/modules/article_generation.py new file mode 100644 index 0000000..be61400 --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/article_generation.py @@ -0,0 +1,123 @@ +import dspy +from concurrent.futures import ThreadPoolExecutor, as_completed +from typing import Set, Union + +from .collaborative_storm_utils import clean_up_section +from ...dataclass import KnowledgeBase, KnowledgeNode + + +class ArticleGenerationModule(dspy.Module): + """Use the information collected from the information-seeking conversation to write a section.""" + + def __init__( + self, + engine: Union[dspy.dsp.LM, dspy.dsp.HFModel], + ): + super().__init__() + self.write_section = dspy.Predict(WriteSection) + self.engine = engine + + def _get_cited_information_string( + self, + all_citation_index: Set[int], + knowledge_base: KnowledgeBase, + max_words: int = 1500, + ): + information = [] + cur_word_count = 0 + for index in sorted(list(all_citation_index)): + info = knowledge_base.info_uuid_to_info_dict[index] + snippet = info.snippets[0] + info_text = f"[{index}]: {snippet} (Question: {info.meta['question']}. Query: {info.meta['query']})" + cur_snippet_length = len(info_text.split()) + if cur_snippet_length + cur_word_count > max_words: + break + cur_word_count += cur_snippet_length + information.append(info_text) + return "\n".join(information) + + def gen_section( + self, topic: str, node: KnowledgeNode, knowledge_base: KnowledgeBase + ): + if node is None or len(node.content) == 0: + return "" + if ( + node.synthesize_output is not None + and node.synthesize_output + and not node.need_regenerate_synthesize_output + ): + return node.synthesize_output + all_citation_index = node.collect_all_content() + information = self._get_cited_information_string( + all_citation_index=all_citation_index, knowledge_base=knowledge_base + ) + with dspy.settings.context(lm=self.engine): + synthesize_output = clean_up_section( + self.write_section( + topic=topic, info=information, section=node.name + ).output + ) + node.synthesize_output = synthesize_output + node.need_regenerate_synthesize_output = False + return node.synthesize_output + + def forward(self, knowledge_base: KnowledgeBase): + all_nodes = knowledge_base.collect_all_nodes() + node_to_paragraph = {} + + # Define a function to generate paragraphs for nodes + def _node_generate_paragraph(node): + node_gen_paragraph = self.gen_section( + topic=knowledge_base.topic, node=node, knowledge_base=knowledge_base + ) + lines = node_gen_paragraph.split("\n") + if lines[0].strip().replace("*", "").replace("#", "") == node.name: + lines = lines[1:] + node_gen_paragraph = "\n".join(lines) + path = " -> ".join(node.get_path_from_root()) + return path, node_gen_paragraph + + with ThreadPoolExecutor(max_workers=5) as executor: + # Submit all tasks + future_to_node = { + executor.submit(_node_generate_paragraph, node): node + for node in all_nodes + } + + # Collect the results as they complete + for future in as_completed(future_to_node): + path, node_gen_paragraph = future.result() + node_to_paragraph[path] = node_gen_paragraph + + def helper(cur_root, level): + to_return = [] + if cur_root is not None: + hash_tag = "#" * level + " " + cur_path = " -> ".join(cur_root.get_path_from_root()) + node_gen_paragraph = node_to_paragraph[cur_path] + to_return.append(f"{hash_tag}{cur_root.name}\n{node_gen_paragraph}") + for child in cur_root.children: + to_return.extend(helper(child, level + 1)) + return to_return + + to_return = [] + for child in knowledge_base.root.children: + to_return.extend(helper(child, level=1)) + + return "\n".join(to_return) + + +class WriteSection(dspy.Signature): + """Write a Wikipedia section based on the collected information. You will be given the topic, the section you are writing and relevant information. + Each information will be provided with the raw content along with question and query lead to that information. + Here is the format of your writing: + Use [1], [2], ..., [n] in line (for example, "The capital of the United States is Washington, D.C.[1][3]."). You DO NOT need to include a References or Sources section to list the sources at the end. + """ + + info = dspy.InputField(prefix="The collected information:\n", format=str) + topic = dspy.InputField(prefix="The topic of the page: ", format=str) + section = dspy.InputField(prefix="The section you need to write: ", format=str) + output = dspy.OutputField( + prefix="Write the section with proper inline citations (Start your writing. Don't include the page title, section name, or try to write other sections. Do not start the section with topic name.):\n", + format=str, + ) diff --git a/knowledge_storm/collaborative_storm/modules/callback.py b/knowledge_storm/collaborative_storm/modules/callback.py new file mode 100644 index 0000000..339c7e3 --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/callback.py @@ -0,0 +1,197 @@ +from typing import List +from ...interface import Information + + +class BaseCallbackHandler: + """Base callback handler to manage callbacks from the STORM pipeline.""" + + def on_turn_policy_planning_start(self, **kwargs): + """Run when the turn policy planning begins, before deciding the direction or goal for the next conversation turn.""" + pass + + def on_expert_action_planning_start(self, **kwargs): + """Run when the expert action planning begins, preparing to determine the actions that each expert should take.""" + pass + + def on_expert_action_planning_end(self, **kwargs): + """Run when the expert action planning ends, after deciding the actions that each expert should take.""" + pass + + def on_expert_information_collection_start(self, **kwargs): + """Run when the expert information collection starts, start gathering all necessary data from selected sources.""" + pass + + def on_expert_information_collection_end(self, info: List[Information], **kwargs): + """Run when the expert information collection ends, after gathering all necessary data from selected sources.""" + pass + + def on_expert_utterance_generation_end(self, **kwargs): + """Run when the expert utterance generation ends, before creating responses or statements from each expert.""" + pass + + def on_expert_utterance_polishing_start(self, **kwargs): + """Run when the expert utterance polishing begins, to refine and improve the clarity and coherence of generated content.""" + pass + + def on_mindmap_insert_start(self, **kwargs): + """Run when the process of inserting new information into the mindmap starts.""" + pass + + def on_mindmap_insert_end(self, **kwargs): + """Run when the process of inserting new information into the mindmap ends.""" + pass + + def on_mindmap_reorg_start(self, **kwargs): + """Run when the reorganization of the mindmap begins, to restructure and optimize the flow of information.""" + pass + + def on_expert_list_update_start(self, **kwargs): + """Run when the expert list update starts, to modify or refresh the list of active experts.""" + pass + + def on_article_generation_start(self, **kwargs): + """Run when the article generation process begins, to compile and format the final article content.""" + pass + + def on_warmstart_update(self, message, **kwargs): + """Run when the warm start process has update.""" + pass + + +class CoStormDemoCallBackHandler(BaseCallbackHandler): + from ...api import BackendAPI + + def __init__(self, backend_api: BackendAPI, conversation_id: int): + self.backend_api = backend_api + self.conversation_id = conversation_id + + def on_turn_policy_planning_start(self, **kwargs): + """Run when the turn policy planning begins, before deciding the direction or goal for the next conversation turn.""" + # self.backend_api.update_conversation_status( + # self.conversation_id, + # "active", + # "Start planning next expert; inspect mind map; inspect system state.", + # ) + # skip this part due to message sync latency in the frontend UI, which introduce more confusion. + pass + + def on_expert_action_planning_start(self, **kwargs): + """Run when the expert action planning begins, preparing to determine the actions that each expert should take.""" + self.backend_api.update_conversation_status( + self.conversation_id, + "active", + "Reviewing discourse history; Deciding utterance intent.", + ) + + def on_expert_information_collection_start(self, **kwargs): + """Run when the expert information collection ends, after gathering all necessary data from selected sources.""" + self.backend_api.update_conversation_status( + self.conversation_id, + "active", + "Start searching and browsing collected information; drafting utterance", + ) + + def on_expert_information_collection_end(self, info: List[Information], **kwargs): + """Run when the expert information collection ends, after gathering all necessary data from selected sources.""" + if info: + urls = [i.url for i in info] + information_string = "\n".join([f"Finish browsing {url}" for url in urls]) + self.backend_api.update_conversation_status( + self.conversation_id, "active", information_string + ) + + def on_expert_utterance_generation_end(self, **kwargs): + """Run when the expert utterance generation ends, before creating responses or statements from each expert.""" + self.backend_api.update_conversation_status( + self.conversation_id, + "active", + "Finish generating utterance from collected information.", + ) + + def on_expert_utterance_polishing_start(self, **kwargs): + """Run when the expert utterance polishing begins, to refine and improve the clarity and coherence of generated content.""" + self.backend_api.update_conversation_status( + self.conversation_id, "active", "Start polishing utterance." + ) + + def on_mindmap_insert_start(self, **kwargs): + """Run when the process of inserting new information into the mindmap starts.""" + self.backend_api.update_conversation_status( + self.conversation_id, "active", "Start inserting information into mind map." + ) + + def on_mindmap_insert_end(self, **kwargs): + """Run when the process of inserting new information into the mindmap ends.""" + self.backend_api.update_conversation_status(self.conversation_id, "active", "") + + def on_mindmap_reorg_start(self, **kwargs): + """Run when the reorganization of the mindmap begins, to restructure and optimize the flow of information.""" + self.backend_api.update_conversation_status( + self.conversation_id, "active", "Start re-organizing mind map." + ) + + def on_expert_list_update_start(self, **kwargs): + """Run when the expert list update starts, to modify or refresh the list of active experts.""" + self.backend_api.update_conversation_status( + self.conversation_id, "active", "Start updating expert candidates." + ) + + def on_warmstart_update(self, message, **kwargs): + """Run when the warm start process has update.""" + self.backend_api.update_conversation_status( + self.conversation_id, "warmup", message + ) + + +class LocalConsolePrintCallBackHandler(BaseCallbackHandler): + from ...api import BackendAPI + + def __init__(self): + pass + + def on_turn_policy_planning_start(self, **kwargs): + """Run when the turn policy planning begins, before deciding the direction or goal for the next conversation turn.""" + print("Start planning next expert; inspect mind map; inspect system state.") + + def on_expert_action_planning_start(self, **kwargs): + """Run when the expert action planning begins, preparing to determine the actions that each expert should take.""" + print("Reviewing discourse history; Deciding utterance intent.") + + def on_expert_information_collection_start(self, **kwargs): + """Run when the expert information collection ends, after gathering all necessary data from selected sources.""" + print("Start searching with the search engine; browsing collected information.") + + def on_expert_information_collection_end(self, info: List[Information], **kwargs): + """Run when the expert information collection ends, after gathering all necessary data from selected sources.""" + if info: + urls = [i.url for i in info] + information_string = "\n".join([f"Finish browsing {url}" for url in urls]) + print(information_string) + + def on_expert_utterance_generation_end(self, **kwargs): + """Run when the expert utterance generation ends, before creating responses or statements from each expert.""" + print("Finish generating utterance from collected information.") + + def on_expert_utterance_polishing_start(self, **kwargs): + """Run when the expert utterance polishing begins, to refine and improve the clarity and coherence of generated content.""" + print("Start polishing utterance.") + + def on_mindmap_insert_start(self, **kwargs): + """Run when the process of inserting new information into the mindmap starts.""" + print("Start inserting information into mind map.") + + def on_mindmap_insert_end(self, **kwargs): + """Run when the process of inserting new information into the mindmap ends.""" + print("Finish inserting information into mind map.") + + def on_mindmap_reorg_start(self, **kwargs): + """Run when the reorganization of the mindmap begins, to restructure and optimize the flow of information.""" + print("Start re-organizing mind map.") + + def on_expert_list_update_start(self, **kwargs): + """Run when the expert list update starts, to modify or refresh the list of active experts.""" + print("Start updating expert candidates.") + + def on_warmstart_update(self, message, **kwargs): + """Run when the warm start process has update.""" + print(f"Warm start update: {message}") diff --git a/knowledge_storm/collaborative_storm/modules/co_storm_agents.py b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py new file mode 100644 index 0000000..045bb32 --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py @@ -0,0 +1,341 @@ +import dspy +from itertools import zip_longest +import numpy as np +from sklearn.metrics.pairwise import cosine_similarity +from typing import List, Optional, TYPE_CHECKING + +from .callback import BaseCallbackHandler +from .collaborative_storm_utils import ( + extract_storm_info_snippet, + _get_answer_question_module_instance, +) +from .costorm_expert_utterance_generator import CoStormExpertUtteranceGenerationModule +from .grounded_question_generation import GroundedQuestionGenerationModule +from .simulate_user import GenSimulatedUserUtterance +from ...dataclass import ConversationTurn, KnowledgeBase +from ...encoder import get_text_embeddings +from ...interface import Agent, Information, LMConfigs +from ...logging_wrapper import LoggingWrapper + +if TYPE_CHECKING: + from ..engine import RunnerArgument + + +class CoStormExpert(Agent): + def __init__( + self, + topic: str, + role_name: str, + role_description: str, + lm_config: LMConfigs, + runner_argument: "RunnerArgument", + logging_wrapper: LoggingWrapper, + rm: Optional[dspy.Retrieve] = None, + callback_handler: BaseCallbackHandler = None, + ): + super().__init__(topic, role_name, role_description) + self.lm_config = lm_config + self.runner_argument = runner_argument + self.logging_wrapper = logging_wrapper + self.callback_handler = callback_handler + self.costorm_agent_utterance_generator = ( + self._get_costorm_expert_utterance_generator(rm=rm) + ) + + def _get_costorm_expert_utterance_generator( + self, rm: Optional[dspy.Retrieve] = None + ): + return CoStormExpertUtteranceGenerationModule( + action_planning_lm=self.lm_config.discourse_manage_lm, + utterance_polishing_lm=self.lm_config.utterance_polishing_lm, + answer_question_module=_get_answer_question_module_instance( + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + rm=rm, + ), + logging_wrapper=self.logging_wrapper, + callback_handler=self.callback_handler, + ) + + def generate_utterance( + self, + knowledge_base: KnowledgeBase, + conversation_history: List[ConversationTurn], + ): + with self.logging_wrapper.log_event( + "CoStormExpert generate utternace: get knowledge base summary" + ): + if self.callback_handler is not None: + self.callback_handler.on_expert_action_planning_start() + conversation_summary = knowledge_base.get_knowledge_base_summary() + with self.logging_wrapper.log_event( + "CoStormExpert.generate_utterance generate utterance" + ): + last_conv_turn = conversation_history[-1] + conv_turn = self.costorm_agent_utterance_generator( + topic=self.topic, + current_expert=self.get_role_description(), + conversation_summary=conversation_summary, + last_conv_turn=last_conv_turn, + ).conversation_turn + with self.logging_wrapper.log_event( + "CoStormExpert generate utterance: polish utterance" + ): + if self.callback_handler is not None: + self.callback_handler.on_expert_utterance_polishing_start() + self.costorm_agent_utterance_generator.polish_utterance( + conversation_turn=conv_turn, last_conv_turn=last_conv_turn + ) + return conv_turn + + +class SimulatedUser(Agent): + def __init__( + self, + topic: str, + role_name: str, + role_description: str, + intent: str, + lm_config: LMConfigs, + runner_argument: "RunnerArgument", + logging_wrapper: LoggingWrapper, + callback_handler: BaseCallbackHandler = None, + ): + super().__init__(topic, role_name, role_description) + self.intent = intent + self.lm_config = lm_config + self.runner_argument = runner_argument + self.logging_wrapper = logging_wrapper + self.gen_simulated_user_utterance = GenSimulatedUserUtterance( + engine=self.lm_config.question_answering_lm + ) + self.callback_handler = callback_handler + + def generate_utterance( + self, + knowledge_base: KnowledgeBase, + conversation_history: List[ConversationTurn], + ): + assert ( + self.intent is not None and self.intent + ), "Simulate user intent is not initialized." + + with self.logging_wrapper.log_event( + "SimulatedUser generate utternace: generate utterance" + ): + utterance = self.gen_simulated_user_utterance( + topic=self.topic, intent=self.intent, conv_history=conversation_history + ) + return ConversationTurn( + role="Guest", raw_utterance=utterance, utterance_type="Original Question" + ) + + +class Moderator(Agent): + def __init__( + self, + topic: str, + role_name: str, + role_description: str, + lm_config: LMConfigs, + runner_argument: "RunnerArgument", + logging_wrapper: LoggingWrapper, + callback_handler: BaseCallbackHandler = None, + ): + super().__init__(topic, role_name, role_description) + self.lm_config = lm_config + self.runner_argument = runner_argument + self.logging_wrapper = logging_wrapper + self.grounded_question_generation_module = GroundedQuestionGenerationModule( + engine=self.lm_config.question_asking_lm + ) + self.callback_handler = callback_handler + + def _get_conv_turn_unused_information( + self, conv_turn: ConversationTurn, knowledge_base: KnowledgeBase + ): + # extract all snippets from raw retrieved information + raw_retrieved_info: List[Information] = conv_turn.raw_retrieved_info + raw_retrieved_single_snippet_info: List[Information] = [] + for info in raw_retrieved_info: + for snippet_idx in range(len(info.snippets)): + raw_retrieved_single_snippet_info.append( + extract_storm_info_snippet(info, snippet_index=snippet_idx) + ) + # get all cited information + cited_info = list(knowledge_base.info_uuid_to_info_dict.values()) + cited_info_hash_set = set([hash(info) for info in cited_info]) + cited_snippets = [info.snippets[0] for info in cited_info] + # get list of unused information + unused_information: List[Information] = [ + info + for info in raw_retrieved_single_snippet_info + if hash(info) not in cited_info_hash_set + ] + if not unused_information: + return [] + # extract snippets to get embeddings + unused_information_snippets = [info.snippets[0] for info in unused_information] + # get embeddings + cache = knowledge_base.embedding_cache + unused_snippets_embeddings, _ = get_text_embeddings( + unused_information_snippets, embedding_cache=cache, max_workers=100 + ) + claim_embedding, _ = get_text_embeddings( + conv_turn.claim_to_make, embedding_cache=cache + ) + query_embedding, _ = get_text_embeddings( + conv_turn.queries, embedding_cache=cache + ) + cited_snippets_embedding, _ = get_text_embeddings( + cited_snippets, embedding_cache=cache + ) + # calculate similarity + query_similarities = cosine_similarity( + unused_snippets_embeddings, query_embedding + ) + max_query_similarity = np.max(query_similarities, axis=1) + cited_snippets_similarity = np.max( + cosine_similarity(unused_snippets_embeddings, cited_snippets_embedding), + axis=1, + ) + cited_snippets_similarity = np.clip(cited_snippets_similarity, 0, 1) + # use claim similarity to filter out "real" not useful data + claim_similarity = cosine_similarity( + unused_snippets_embeddings, claim_embedding.reshape(1, -1) + ).flatten() + claim_similarity = np.where(claim_similarity >= 0.25, 1.0, 0.0) + # calculate score: snippet that is close to topic but far from query + query_sim_weight = 0.5 + cited_snippets_sim_weight = 1 - query_sim_weight + combined_scores = ( + ((1 - max_query_similarity) ** query_sim_weight) + * ((1 - cited_snippets_similarity) ** cited_snippets_sim_weight) + * claim_similarity + ) + sorted_indices = np.argsort(combined_scores)[::-1] + return [unused_information[idx] for idx in sorted_indices] + + def _get_sorted_unused_snippets( + self, + knowledge_base: KnowledgeBase, + conversation_history: List[ConversationTurn], + last_n_conv_turn: int = 2, + ): + # get last N conv turn and batch encode all related strings + considered_conv_turn = [] + batch_snippets = [self.topic] + for conv_turn in reversed(conversation_history): + if len(considered_conv_turn) == last_n_conv_turn: + break + if conv_turn.utterance_type == "Questioning": + break + considered_conv_turn.append(conv_turn) + batch_snippets.extend( + sum([info.snippets for info in conv_turn.raw_retrieved_info], []) + ) + batch_snippets.append(conv_turn.claim_to_make) + batch_snippets.extend(conv_turn.queries) + cache = knowledge_base.embedding_cache + get_text_embeddings(batch_snippets, embedding_cache=cache, max_workers=300) + + # get sorted unused snippets for each turn + sorted_snippets = [] + for conv_turn in considered_conv_turn: + sorted_snippets.append( + self._get_conv_turn_unused_information( + conv_turn=conv_turn, knowledge_base=knowledge_base + ) + ) + + # use round robin rule to merge these snippets + merged_snippets = [] + for elements in zip_longest(*sorted_snippets, fillvalue=None): + merged_snippets.extend(e for e in elements if e is not None) + return merged_snippets + + def generate_utterance( + self, + knowledge_base: KnowledgeBase, + conversation_history: List[ConversationTurn], + ): + with self.logging_wrapper.log_event( + "Moderator generate utternace: get unused snippets" + ): + unused_snippets: List[Information] = self._get_sorted_unused_snippets( + knowledge_base=knowledge_base, conversation_history=conversation_history + ) + with self.logging_wrapper.log_event( + "Moderator generate utternace: QuestionGeneration module" + ): + generated_question = self.grounded_question_generation_module( + topic=self.topic, + knowledge_base=knowledge_base, + last_conv_turn=conversation_history[-1], + unused_snippets=unused_snippets, + ) + return ConversationTurn( + role=self.role_name, + raw_utterance=generated_question.raw_utterance, + utterance_type="Original Question", + utterance=generated_question.utterance, + cited_info=generated_question.cited_info, + ) + + +class PureRAGAgent(Agent): + def __init__( + self, + topic: str, + role_name: str, + role_description: str, + lm_config: LMConfigs, + runner_argument: "RunnerArgument", + logging_wrapper: LoggingWrapper, + rm: Optional[dspy.Retrieve] = None, + callback_handler: BaseCallbackHandler = None, + ): + super().__init__(topic, role_name, role_description) + self.lm_config = lm_config + self.runner_argument = runner_argument + self.logging_wrapper = logging_wrapper + self.grounded_question_answering_module = _get_answer_question_module_instance( + lm_config=self.lm_config, + runner_argument=self.runner_argument, + logging_wrapper=self.logging_wrapper, + rm=rm, + ) + + def _gen_utterance_from_question(self, question: str): + grounded_answer = self.grounded_question_answering_module( + topic=self.topic, + question=question, + mode="brief", + style="conversational and concise", + ) + conversation_turn = ConversationTurn( + role=self.role_name, raw_utterance="", utterance_type="Potential Answer" + ) + conversation_turn.claim_to_make = question + conversation_turn.raw_utterance = grounded_answer.response + conversation_turn.utterance = grounded_answer.response + conversation_turn.queries = grounded_answer.queries + conversation_turn.raw_retrieved_info = grounded_answer.raw_retrieved_info + conversation_turn.cited_info = grounded_answer.cited_info + return conversation_turn + + def generate_topic_background(self): + return self._gen_utterance_from_question(self.topic) + + def generate_utterance( + self, + knowledge_base: KnowledgeBase, + conversation_history: List[ConversationTurn], + ): + with self.logging_wrapper.log_event( + "PureRAGAgent generate utternace: generate utterance" + ): + return self._gen_utterance_from_question( + question=conversation_history[-1].utterance + ) diff --git a/knowledge_storm/collaborative_storm/modules/collaborative_storm_utils.py b/knowledge_storm/collaborative_storm/modules/collaborative_storm_utils.py new file mode 100644 index 0000000..661c49f --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/collaborative_storm_utils.py @@ -0,0 +1,380 @@ +import dspy +import os +import re +import sys +import toml +from typing import List, Tuple, Dict, Optional, TYPE_CHECKING + +if TYPE_CHECKING: + from ..engine import RunnerArgument +from ...interface import Information, Retriever, LMConfigs +from ...logging_wrapper import LoggingWrapper +from ...rm import BingSearch + + +def extract_storm_info_snippet(info: Information, snippet_index: int) -> Information: + """ + Constructs a new Information instance with only the specified snippet index. + + Args: + storm_info (Information): The original Information instance. + snippet_index (int): The index of the snippet to retain. + + Returns: + Information: A new Information instance with only the specified snippet. + """ + if snippet_index < 0 or snippet_index >= len(info.snippets): + raise ValueError("Snippet index out of range") + + new_snippets = [info.snippets[snippet_index]] + new_storm_info = Information( + info.url, info.description, new_snippets, info.title, info.meta + ) + return new_storm_info + + +def format_search_results( + searched_results: List[Information], + info_max_num_words: int = 1000, + mode: str = "brief", +) -> Tuple[str, Dict[int, Information]]: + """ + Constructs a string from a list of search results with a specified word limit and returns a mapping of indices to Information. + + Args: + searched_results (List[Information]): List of Information objects to process. + info_max_num_words (int, optional): Maximum number of words allowed in the output string. Defaults to 1000. + mode (str, optional): Mode of summarization. 'brief' takes only the first snippet of each Information. + 'extensive' adds snippets iteratively until the word limit is reached. Defaults to 'brief'. + + Returns: + Tuple[str, Dict[int, Information]]: + - Formatted string with search results, constrained by the word limit. + - Dictionary mapping indices to the corresponding Information objects. + """ + total_length = 0 + + extracted_snippet_queue = [] + max_snippets = ( + max(len(info.snippets) for info in searched_results) if searched_results else 0 + ) + max_snippets = 1 if mode == "brief" else max_snippets + abort = False + included_snippets = set() + for i in range(max_snippets): + for info in searched_results: + if i < len(info.snippets) and not abort: + cur_snippet = info.snippets[i] + cur_snippet_len = len(info.snippets[i].split()) + if total_length + cur_snippet_len > info_max_num_words: + abort = True + break + if cur_snippet not in included_snippets: + included_snippets.add(cur_snippet) + info = extract_storm_info_snippet(info, snippet_index=i) + extracted_snippet_queue.append(info) + total_length += cur_snippet_len + output = [] + index_mapping = {} + for idx, info in enumerate(extracted_snippet_queue): + output.append(f"[{idx + 1}]: {info.snippets[0]}") + index_mapping[idx + 1] = info + assert -1 not in index_mapping + return "\n".join(output), index_mapping + + +def extract_cited_storm_info( + response: str, index_to_storm_info: Dict[int, Information] +) -> Dict[int, Information]: + """ + Extracts a sub-dictionary of Information instances that are cited in the response. + + Args: + response (str): The response string containing inline citations like [1], [2], etc. + index_to_storm_info (Dict[int, Information]): A dictionary mapping indices to Information instances. + + Returns: + Dict[int, Information]: A sub-dictionary with only the indices that appear in the response. + """ + cited_indices = set(map(int, re.findall(r"\[(\d+)\]", response))) + cited_storm_info = { + index: info + for index, info in index_to_storm_info.items() + if index in cited_indices + } + return cited_storm_info + + +def trim_output_after_hint(response: str, hint: str) -> str: + """ + Trims the output string to only keep the substring after the given hint (not including the hint). + + Args: + response (str): The original output string. + hint (str): The hint string after which the substring should be kept. + + Returns: + str: The trimmed output string, or the original string if the hint is not found. + """ + if hint in response: + start_index = response.find(hint) + len(hint) + return response[start_index:].strip() + return response.strip("\n") + + +def separate_citations(text: str) -> str: + """ + Separates multiple citations within square brackets into individual citations. + + Args: + text (str): The input string containing citations. + + Returns: + str: The string with separated citations. + """ + + # Define a function to process each match + def replace_citations(match): + citations = match.group(1).split(",") + return "".join(f"[{citation.strip()}]" for citation in citations) + + # Use regular expressions to find and replace citations + pattern = re.compile(r"\[(\d+(?:,\s*\d+)*)\]") + return pattern.sub(replace_citations, text) + + +def extract_and_remove_citations(text: str) -> Tuple[str, List[int]]: + """ + Removes single inline citations from the input string and returns the modified string and a list of citation integers. + + Args: + text (str): The input string containing citations. + + Returns: + Tuple[str, List[int]]: The string after removal of citations and a list of citation integers. + """ + citations = [] + + # Define a function to process each match + def extract_citation(match): + citation = int(match.group(1)) + citations.append(citation) + return "" + + # Use regular expressions to find and replace citations + pattern = re.compile(r"\[(\d+)\]") + modified_text = pattern.sub(extract_citation, text) + + return modified_text, citations + + +def keep_first_and_last_paragraph(text: str) -> str: + """ + Processes the input text to keep the first and last paragraphs and replace + the middle paragraphs with '[content omitted due to space limit]'. + + Args: + text (str): The input text containing paragraphs separated by '\n\n'. + + Returns: + str: The processed text. + """ + paragraphs = text.split("\n\n") + + if len(paragraphs) <= 3: + return text + + first_paragraph = paragraphs[0] + last_paragraph = "\n\n".join(paragraphs[-2:]) + return ( + f"{first_paragraph}\n\n[content omitted due to space limit]\n\n{last_paragraph}" + ) + + +def clean_up_section(text): + """Clean up a section: + 1. Remove uncompleted sentences (usually due to output token limitation). + 2. Deduplicate individual groups of citations. + 3. Remove unnecessary summary.""" + + paragraphs = text.split("\n") + output_paragraphs = [] + summary_sec_flag = False + for p in paragraphs: + p = p.strip() + if len(p) == 0: + continue + if not p.startswith("#"): + p = separate_citations(p) + if summary_sec_flag: + if p.startswith("#"): + summary_sec_flag = False + else: + continue + if ( + p.startswith("Overall") + or p.startswith("In summary") + or p.startswith("In conclusion") + ): + continue + if "# Summary" in p or "# Conclusion" in p: + summary_sec_flag = True + continue + output_paragraphs.append(p) + + return "\n\n".join(output_paragraphs) # Join with '\n\n' for markdown format. + + +def load_api_key(toml_file_path): + try: + with open(toml_file_path, "r") as file: + data = toml.load(file) + except FileNotFoundError: + print(f"File not found: {toml_file_path}", file=sys.stderr) + return + except toml.TomlDecodeError: + print(f"Error decoding TOML file: {toml_file_path}", file=sys.stderr) + return + # Set environment variables + for key, value in data.items(): + os.environ[key] = str(value) + + +def construct_frontend_display_data( + knowledge_base, + conv_turn, + is_warm_start: bool = False, + next_turn_role: Optional[str] = None, +): + def to_dict(node): + if node is None: + return None + data = { + "node_name": node.name, + "node_uuid": " -> ".join(node.get_path_from_root()), + "content": list(node.content), + "child_node": [], + } + for child in node.children: + child_data = to_dict(child) + if child_data is not None: + data["child_node"].append(child_data) + return data + + def split_paragraph(paragraph): + # Regular expression to match sentences with citations + sentence_pattern = re.compile(r"([^.?!]*[.?!])(\s*\[\d+\])*") + citation_pattern = re.compile(r"\[(\d+)\]") + + # Check if there are any sentence separators in the paragraph + if not re.search(r"[.?!]", paragraph): + # If no separators, consider the whole paragraph as a single sentence + citations = list(map(int, citation_pattern.findall(paragraph))) + sentence = citation_pattern.sub("", paragraph).strip() + return [(sentence, citations)] + + sentences = [] + + for match in sentence_pattern.finditer(paragraph): + sentence_with_citations = match.group(0).strip() + sentence = match.group(1).strip() + citations = list( + map(int, citation_pattern.findall(sentence_with_citations)) + ) + + # Remove citations from the sentence + sentence = citation_pattern.sub("", sentence).strip() + + sentences.append((sentence, citations)) + + return sentences + + # get mind map + mind_map = to_dict(knowledge_base.root) + # get last turn utterance + role = conv_turn.role + utterance = str(conv_turn.utterance) + sentences_w_citations = split_paragraph(utterance) + + # get cited info + cited_info = {} + for citation_idx, info in knowledge_base.info_uuid_to_info_dict.items(): + cited_info[citation_idx] = { + "description": info.description, + "snippets": info.snippets, + "url": info.url, + "title": info.title, + "placement": info.meta.get("placement", ""), + } + evaluation_questions = None + if conv_turn.role != "Guest": + evaluation_questions = [ + { + "question": "Does this new utterance help steer the discourse towards a new and interesting direction?", + "type": "multiple_choice", + "choices": ["Yes", "No"], + "id": 1, + }, + { + "question": "Has the mind map reasonably managing the discourse so far?", + "type": "multiple_choice", + "choices": ["Yes", "No"], + "id": 2, + }, + { + "question": "(Optional) Any comments?", + "type": "freeform", + "choices": [], + "id": 3, + }, + ] + to_return = { + "mind_map": mind_map, + "conversation_turn": { + "role": role, + "content": sentences_w_citations, + "is_warm_start": is_warm_start, + }, + "cited_info": cited_info, + "eval": evaluation_questions, + "next_turn_role": next_turn_role, + } + return to_return + + +def construct_article_frontend_display_data(knowledge_base, article: str): + cited_info = { + key: value.to_dict() + for key, value in knowledge_base.info_uuid_to_info_dict.items() + } + data = {"article": article, "cited_info": cited_info} + return data + + +def construct_round_table_conversation_databackup(round_table_conversation): + round_tabld_dump = round_table_conversation.to_dict() + log_dump = round_table_conversation.logging_wrapper.dump_logging_and_reset( + reset_logging=False + ) + return {"round_tabld_dump": round_tabld_dump, "log_dump": log_dump} + + +def _get_answer_question_module_instance( + lm_config: LMConfigs, + runner_argument: "RunnerArgument", + logging_wrapper: LoggingWrapper, + rm: Optional[dspy.Retrieve] = None, +): + from .grounded_question_answering import AnswerQuestionModule + + # configure retriever + if rm is None: + rm = BingSearch(k=runner_argument.retrieve_top_k) + retriever = Retriever(rm=rm, max_thread=runner_argument.max_search_thread) + # return AnswerQuestionModule instance + return AnswerQuestionModule( + retriever=retriever, + max_search_queries=runner_argument.max_search_queries, + question_answering_lm=lm_config.question_answering_lm, + logging_wrapper=logging_wrapper, + ) diff --git a/knowledge_storm/collaborative_storm/modules/costorm_expert_utterance_generator.py b/knowledge_storm/collaborative_storm/modules/costorm_expert_utterance_generator.py new file mode 100644 index 0000000..2c7c350 --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/costorm_expert_utterance_generator.py @@ -0,0 +1,160 @@ +import dspy +from typing import Union + +from .callback import BaseCallbackHandler +from .collaborative_storm_utils import ( + trim_output_after_hint, + extract_and_remove_citations, + keep_first_and_last_paragraph, +) + +from .grounded_question_answering import AnswerQuestionModule +from .grounded_question_generation import ConvertUtteranceStyle +from ...dataclass import ConversationTurn +from ...logging_wrapper import LoggingWrapper + + +class GenExpertActionPlanning(dspy.Signature): + """ + You are an invited speaker in the round table conversation. Your task is to make a very short note to your assistant to help you prepare for your turn in the conversation. + You will be given the topic we are discussing, your expertise, and the conversation history. + Take a look at conversation history, especially last few turns, then let your assistant prepare the material for you with one of following ways. + 1. Original Question: Initiates a new question to other speakers. + 2. Further Details: Provides additional information. + 3. Information Request: Requests information from other speakers. + 4. Potential Answer: Offers a possible solution or answer. + + Strictly follow this format: [type of contribution]: [one sentence description]. For example, Original Question: [description] + """ + + topic = dspy.InputField(prefix="topic of discussion: ", format=str) + expert = dspy.InputField(prefix="You are inivited as: ", format=str) + summary = dspy.InputField(prefix="Discussion history: \n", format=str) + last_utterance = dspy.InputField( + prefix="Last utterance in the conversation: \n", format=str + ) + resposne = dspy.OutputField( + prefix="Now give your note. Start with one of [Original Question, Further Details, Information Request, Potential Answer] with one sentence description\n", + format=str, + ) + + +class CoStormExpertUtteranceGenerationModule(dspy.Module): + def __init__( + self, + action_planning_lm: Union[dspy.dsp.LM, dspy.dsp.HFModel], + utterance_polishing_lm: Union[dspy.dsp.LM, dspy.dsp.HFModel], + answer_question_module: AnswerQuestionModule, + logging_wrapper: LoggingWrapper, + callback_handler: BaseCallbackHandler = None, + ): + self.action_planning_lm = action_planning_lm + self.utterance_polishing_lm = utterance_polishing_lm + self.expert_action = dspy.Predict(GenExpertActionPlanning) + self.change_style = dspy.Predict(ConvertUtteranceStyle) + self.answer_question_module = answer_question_module + self.logging_wrapper = logging_wrapper + self.callback_handler = callback_handler + + def parse_action(self, action): + action_types = [ + "Original Question", + "Further Details", + "Information Request", + "Potential Answer", + ] + for action_type in action_types: + if f"{action_type}:" in action: + return action_type, trim_output_after_hint(action, f"{action_type}:") + elif f"[{action_type}]:" in action: + return action_type, trim_output_after_hint(action, f"[{action_type}]:") + return "Undefined", "" + + def polish_utterance( + self, conversation_turn: ConversationTurn, last_conv_turn: ConversationTurn + ): + # change utterance style + action_type = conversation_turn.utterance_type + with self.logging_wrapper.log_event( + "RoundTableConversationModule.ConvertUtteranceStyle" + ): + with dspy.settings.context( + lm=self.utterance_polishing_lm, show_guidelines=False + ): + action_string = ( + f"{action_type} about: {conversation_turn.claim_to_make}" + ) + if action_type in ["Original Question", "Information Request"]: + action_string = f"{action_type}" + last_expert_utterance_wo_citation, _ = extract_and_remove_citations( + last_conv_turn.utterance + ) + trimmed_last_expert_utterance = keep_first_and_last_paragraph( + last_expert_utterance_wo_citation + ) + utterance = self.change_style( + expert=conversation_turn.role, + action=action_string, + prev=trimmed_last_expert_utterance, + content=conversation_turn.raw_utterance, + ).utterance + conversation_turn.utterance = utterance + + def forward( + self, + topic: str, + current_expert: str, + conversation_summary: str, + last_conv_turn: ConversationTurn, + ): + last_utterance, _ = extract_and_remove_citations(last_conv_turn.utterance) + if last_conv_turn.utterance_type in [ + "Original Question", + "Information Request", + ]: + action_type = "Potential Answer" + action_content = last_utterance + else: + with self.logging_wrapper.log_event( + "CoStormExpertUtteranceGenerationModule: GenExpertActionPlanning" + ): + with dspy.settings.context( + lm=self.action_planning_lm, show_guidelines=False + ): + action = self.expert_action( + topic=topic, + expert=current_expert, + summary=conversation_summary, + last_utterance=last_utterance, + ).resposne + action_type, action_content = self.parse_action(action) + + if self.callback_handler is not None: + self.callback_handler.on_expert_action_planning_end() + # get response + conversation_turn = ConversationTurn( + role=current_expert, raw_utterance="", utterance_type=action_type + ) + + if action_type == "Undefined": + raise Exception(f"unexpected output: {action}") + elif action_type in ["Further Details", "Potential Answer"]: + with self.logging_wrapper.log_event( + "RoundTableConversationModule: QuestionAnswering" + ): + grounded_answer = self.answer_question_module( + topic=topic, + question=action_content, + mode="brief", + style="conversational and concise", + callback_handler=self.callback_handler, + ) + conversation_turn.claim_to_make = action_content + conversation_turn.raw_utterance = grounded_answer.response + conversation_turn.queries = grounded_answer.queries + conversation_turn.raw_retrieved_info = grounded_answer.raw_retrieved_info + conversation_turn.cited_info = grounded_answer.cited_info + elif action_type in ["Original Question", "Information Request"]: + conversation_turn.raw_utterance = action_content + + return dspy.Prediction(conversation_turn=conversation_turn) diff --git a/knowledge_storm/collaborative_storm/modules/expert_generation.py b/knowledge_storm/collaborative_storm/modules/expert_generation.py new file mode 100644 index 0000000..a95915a --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/expert_generation.py @@ -0,0 +1,83 @@ +import dspy +import re +from typing import Union + + +class GenerateExpertGeneral(dspy.Signature): + """You need to select a group of diverse experts who will be suitable to be invited to a roundtable discussion on the given topic. + Each expert should represent a different perspective, role, or affiliation related to this topic. + You can use the background information provided about the topic for inspiration. For each expert, add a description of their expertise and what they will focus on during the discussion. + No need to include speakers name in the output. + Strictly follow format below: + 1. [speaker 1 role]: [speaker 1 short description] + 2. [speaker 2 role]: [speaker 2 short description] + """ + + topic = dspy.InputField(prefix="Topic of interest:", format=str) + background_info = dspy.InputField( + prefix="Background information about the topic:\n", format=str + ) + topN = dspy.InputField(prefix="Number of speakers needed: ", format=str) + experts = dspy.OutputField(format=str) + + +class GenerateExpertWithFocus(dspy.Signature): + """ + You need to select a group of speakers who will be suitable to have roundtable discussion on the [topic] of specific [focus]. + You may consider inviting speakers having opposite stands on the topic; speakers representing different interest parties; Ensure that the selected speakers are directly connected to the specific context and scenario provided. + For example, if the discussion focus is about a recent event at a specific university, consider inviting students, faculty members, journalists covering the event, university officials, and local community members. + Use the background information provided about the topic for inspiration. For each speaker, add a description of their interests and what they will focus on during the discussion. + No need to include speakers name in the output. + Strictly follow format below: + 1. [speaker 1 role]: [speaker 1 short description] + 2. [speaker 2 role]: [speaker 2 short description] + """ + + topic = dspy.InputField(prefix="Topic of interest:", format=str) + background_info = dspy.InputField(prefix="Background information:\n", format=str) + focus = dspy.InputField(prefix="Discussion focus: ", format=str) + topN = dspy.InputField(prefix="Number of speakers needed: ", format=str) + experts = dspy.OutputField(format=str) + + +class GenerateExpertModule(dspy.Module): + def __init__(self, engine: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.engine = engine + self.generate_expert_general = dspy.Predict(GenerateExpertGeneral) + self.generate_expert_w_focus = dspy.ChainOfThought(GenerateExpertWithFocus) + + def trim_background(self, background: str, max_words: int = 100): + words = background.split() + cur_len = len(words) + if cur_len <= max_words: + return background + trimmed_words = words[: min(cur_len, max_words)] + trimmed_background = " ".join(trimmed_words) + return f"{trimmed_background} [rest content omitted]." + + def forward( + self, topic: str, num_experts: int, background_info: str = "", focus: str = "" + ): + with dspy.settings.context(lm=self.engine, show_guidelines=False): + if not focus: + output = self.generate_expert_general( + topic=topic, background_info=background_info, topN=num_experts + ).experts + else: + background_info = self.trim_background( + background=background_info, max_words=100 + ) + output = self.generate_expert_w_focus( + topic=topic, + background_info=background_info, + focus=focus, + topN=num_experts, + ).experts + output = output.replace("*", "").replace("[", "").replace("]", "") + expert_list = [] + for s in output.split("\n"): + match = re.search(r"\d+\.\s*(.*)", s) + if match: + expert_list.append(match.group(1)) + expert_list = [expert.strip() for expert in expert_list if expert.strip()] + return dspy.Prediction(experts=expert_list, raw_output=output) diff --git a/knowledge_storm/collaborative_storm/modules/grounded_question_answering.py b/knowledge_storm/collaborative_storm/modules/grounded_question_answering.py new file mode 100644 index 0000000..4065018 --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/grounded_question_answering.py @@ -0,0 +1,163 @@ +import dspy +from typing import Union, List + +from .callback import BaseCallbackHandler +from .collaborative_storm_utils import ( + trim_output_after_hint, + format_search_results, + extract_cited_storm_info, + separate_citations, +) +from ...logging_wrapper import LoggingWrapper +from ...utils import ArticleTextProcessing +from ...interface import Information + + +class QuestionToQuery(dspy.Signature): + """You want to answer the question or support a claim using Google search. What do you type in the search box? + The question is raised in a round table discussion on a topic. The question may or may not focus on the topic itself. + Write the queries you will use in the following format: + - query 1 + - query 2 + ... + - query n""" + + topic = dspy.InputField(prefix="Topic context:", format=str) + question = dspy.InputField( + prefix="I want to collect information about: ", format=str + ) + queries = dspy.OutputField(prefix="Queries: \n", format=str) + + +class AnswerQuestion(dspy.Signature): + """You are an expert who can use information effectively. You have gathered the related information and will now use the information to form a response. + Make your response as informative as possible and make sure every sentence is supported by the gathered information. + If [Gathered information] is not directly related to the [Topic] and [Question], provide the most relevant answer you can based on the available information, and explain any limitations or gaps. + Use [1], [2], ..., [n] in line (for example, "The capital of the United States is Washington, D.C.[1][3]."). + You DO NOT need to include a References or Sources section to list the sources at the end. The style of writing should be formal. + """ + + topic = dspy.InputField(prefix="Topic you are discussing about:", format=str) + question = dspy.InputField(prefix="You want to provide insight on: ", format=str) + info = dspy.InputField(prefix="Gathered information:\n", format=str) + style = dspy.InputField(prefix="Style of your response should be:", format=str) + answer = dspy.OutputField( + prefix="Now give your response. (Try to use as many different sources as possible and do not hallucinate.)", + format=str, + ) + + +class AnswerQuestionModule(dspy.Module): + def __init__( + self, + retriever: dspy.Retrieve, + max_search_queries: int, + question_answering_lm: Union[dspy.dsp.LM, dspy.dsp.HFModel], + logging_wrapper: LoggingWrapper, + ): + super().__init__() + self.question_answering_lm = question_answering_lm + self.question_to_query = dspy.Predict(QuestionToQuery) + self.answer_question = dspy.Predict(AnswerQuestion) + self.retriever = retriever + self.max_search_queries = max_search_queries + self.logging_wrapper = logging_wrapper + + def retrieve_information(self, topic, question): + # decompose question to queries + with self.logging_wrapper.log_event( + f"AnswerQuestionModule.question_to_query ({hash(question)})" + ): + with dspy.settings.context(lm=self.question_answering_lm): + queries = self.question_to_query(topic=topic, question=question).queries + queries = trim_output_after_hint(queries, hint="Queries:") + queries = [ + q.replace("-", "").strip().strip('"').strip('"').strip() + for q in queries.split("\n") + ] + queries = queries[: self.max_search_queries] + self.logging_wrapper.add_query_count(count=len(queries)) + with self.logging_wrapper.log_event( + f"AnswerQuestionModule.retriever.retrieve ({hash(question)})" + ): + # retrieve information using retriever + searched_results: List[Information] = self.retriever.retrieve( + list(set(queries)), exclude_urls=[] + ) + # update storm information meta to include the question + for storm_info in searched_results: + storm_info.meta["question"] = question + return queries, searched_results + + def forward( + self, + topic: str, + question: str, + mode: str = "brief", + style: str = "conversational", + callback_handler: BaseCallbackHandler = None, + ): + """ + Processes a topic and question to generate a response with relevant information and citations. + + Args: + topic (str): The topic of interest. + question (str): The specific question related to the topic. + mode (str, optional): Mode of summarization. 'brief' takes only the first snippet of each Information. + 'extensive' adds snippets iteratively until the word limit is reached. Defaults to 'brief'. + + Returns: + dspy.Prediction: An object containing the following: + - question (str): the question to answer + - queries (List[str]): List of query strings used for information retrieval. + - raw_retrieved_info (List[Information]): List of Information instances retrieved. + - cited_info (Dict[int, Information]): Dictionary of cited Information instances, indexed by their citation number. + - response (str): The generated response string with inline citations. + """ + # retrieve information + if callback_handler is not None: + callback_handler.on_expert_information_collection_start() + queries, searched_results = self.retrieve_information( + topic=topic, question=question + ) + if callback_handler is not None: + callback_handler.on_expert_information_collection_end(searched_results) + # format information string for answer generation + info_text, index_to_information_mapping = format_search_results( + searched_results, mode=mode + ) + answer = "Sorry, there is insufficient information to answer the question." + # generate answer to the question + if info_text: + with self.logging_wrapper.log_event( + f"AnswerQuestionModule.answer_question ({hash(question)})" + ): + with dspy.settings.context( + lm=self.question_answering_lm, show_guidelines=False + ): + answer = self.answer_question( + topic=topic, question=question, info=info_text, style=style + ).answer + answer = ArticleTextProcessing.remove_uncompleted_sentences_with_citations( + answer + ) + answer = trim_output_after_hint( + answer, + hint="Now give your response. (Try to use as many different sources as possible and do not hallucinate.)", + ) + # enforce single citation index bracket. [1, 2] -> [1][2] + answer = separate_citations(answer) + if callback_handler is not None: + callback_handler.on_expert_utterance_generation_end() + # construct cited search result + cited_searched_results = extract_cited_storm_info( + response=answer, index_to_storm_info=index_to_information_mapping + ) + + return dspy.Prediction( + question=question, + queries=queries, + raw_retrieved_info=searched_results, + cited_info=cited_searched_results, + response=answer, + ) diff --git a/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py b/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py new file mode 100644 index 0000000..f09339d --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py @@ -0,0 +1,104 @@ +import dspy +from typing import List, Union + +from .collaborative_storm_utils import ( + format_search_results, + extract_and_remove_citations, + keep_first_and_last_paragraph, + extract_cited_storm_info, +) +from ...dataclass import ConversationTurn, KnowledgeBase +from ...interface import Information + + +class KnowledgeBaseSummmary(dspy.Signature): + """Your job is to give brief summary of what's been discussed in a roundtable conversation. Contents are themantically organized into hierarchical sections. + You will be presented with these sections where "#" denotes level of section. + """ + + topic = dspy.InputField(prefix="topic: ", format=str) + structure = dspy.InputField(prefix="Tree structure: \n", format=str) + output = dspy.OutputField(prefix="Now give brief summary:\n", format=str) + + +class ConvertUtteranceStyle(dspy.Signature): + """ + You are an invited speaker in the round table conversation. + Your task is to make the question or the response more conversational and engaging to facilicate the flow of conversation. + Note that this is ongoing conversation so no need to have welcoming and concluding words. Previous speaker utterance is provided only for making the conversation more natural. + Note that do not hallucinate and keep the citation index like [1] as it is. Also, + """ + + expert = dspy.InputField(prefix="You are inivited as: ", format=str) + action = dspy.InputField( + prefix="You want to contribute to conversation by: ", format=str + ) + prev = dspy.InputField(prefix="Previous speaker said: ", format=str) + content = dspy.InputField( + prefix="Question or response you want to say: ", format=str + ) + utterance = dspy.OutputField( + prefix="Your utterance (keep the information as much as you can with citations, prefer shorter answers without loss of information): ", + format=str, + ) + + +class GroundedQuestionGeneration(dspy.Signature): + """Your job is to find next discussion focus in a roundtable conversation. You will be given previous conversation summary and some information that might assist you discover new discussion focus. + Note that the new discussion focus should bring new angle and perspective to the discussion and avoid repetition. The new discussion focus should be grounded on the available information and push the boundaries of the current discussion for broader exploration. + The new discussion focus should have natural flow from last utterance in the conversation. + Use [1][2] in line to ground your question. + """ + + topic = dspy.InputField(prefix="topic: ", format=str) + summary = dspy.InputField(prefix="Discussion history: \n", format=str) + information = dspy.InputField(prefix="Available information: \n", format=str) + last_utterance = dspy.InputField( + prefix="Last utterance in the conversation: \n", format=str + ) + output = dspy.OutputField( + prefix="Now give next discussion focus in the format of one sentence question:\n", + format=str, + ) + + +class GroundedQuestionGenerationModule(dspy.Module): + def __init__(self, engine: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.engine = engine + self.gen_focus = dspy.Predict(GroundedQuestionGeneration) + self.polish_style = dspy.Predict(ConvertUtteranceStyle) + self.gen_summary = dspy.Predict(KnowledgeBaseSummmary) + + def forward( + self, + topic: str, + knowledge_base: KnowledgeBase, + last_conv_turn: ConversationTurn, + unused_snippets: List[Information], + ): + information, index_to_information_mapping = format_search_results( + unused_snippets, info_max_num_words=1000 + ) + summary = knowledge_base.get_knowledge_base_summary() + last_utterance, _ = extract_and_remove_citations(last_conv_turn.utterance) + with dspy.settings.context(lm=self.engine, show_guidelines=False): + raw_utterance = self.gen_focus( + topic=topic, + summary=summary, + information=information, + last_utterance=last_utterance, + ).output + utterance = self.polish_style( + expert="Roundtable conversation moderator", + action="Raising a new question by natural transit from previous utterance.", + prev=keep_first_and_last_paragraph(last_utterance), + content=raw_utterance, + ).utterance + cited_searched_results = extract_cited_storm_info( + response=utterance, index_to_storm_info=index_to_information_mapping + ) + return dspy.Prediction( + raw_utterance=raw_utterance, + utterance=utterance, + cited_info=cited_searched_results, + ) diff --git a/knowledge_storm/collaborative_storm/modules/information_insertion_module.py b/knowledge_storm/collaborative_storm/modules/information_insertion_module.py new file mode 100644 index 0000000..c858671 --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/information_insertion_module.py @@ -0,0 +1,422 @@ +import dspy +import numpy as np +import re +import traceback + +from concurrent.futures import ThreadPoolExecutor, as_completed +from sklearn.metrics.pairwise import cosine_similarity +from typing import List, Union, Dict, Optional + +from .collaborative_storm_utils import trim_output_after_hint +from ...dataclass import KnowledgeNode, KnowledgeBase +from ...encoder import get_text_embeddings +from ...interface import Information + + +class InsertInformation(dspy.Signature): + """Your job is to insert the given information to the knowledge base. The knowledge base is a tree based data structure to organize the collection information. Each knowledge node contains information derived from themantically similar question or intent. + To decide the best placement of the information, you will be navigated in this tree based data structure layer by layer. + You will be presented with the question and query leads to ththeis information, and tree structure. + + Output should strictly follow one of options presetned below with no other information. + - 'insert': to place the information under the current node. + - 'step: [child node name]': to step into a specified child node. + - 'create: [new child node name]': to create new child node and insert the info under it. + + Example outputs: + - insert + - step: node2 + - create: node3 + """ + + intent = dspy.InputField( + prefix="Question and query leads to this info: ", format=str + ) + structure = dspy.InputField(prefix="Tree structure: \n", format=str) + choice = dspy.OutputField(prefix="Choice:\n", format=str) + + +class InsertInformationCandidateChoice(dspy.Signature): + """Your job is to insert the given information to the knowledge base. The knowledge base is a tree based data structure to organize the collection information. Each knowledge node contains information derived from themantically similar question or intent. + You will be presented with the question and query leads to this information, and candidate choices of placement. In these choices, -> denotes parent-child relationship. Note that reasonable may not be in these choices. + + If there exists reasonable choice, output "Best placement: [choice index]"; otherwise, output "No reasonable choice". + """ + + intent = dspy.InputField( + prefix="Question and query leads to this info: ", format=str + ) + choices = dspy.InputField(prefix="Candidate placement:\n", format=str) + decision = dspy.OutputField(prefix="Decision:\n", format=str) + + +class InsertInformationModule(dspy.Module): + def __init__(self, engine: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.engine = engine + self.insert_info = dspy.ChainOfThought(InsertInformation) + self.candidate_choosing = dspy.Predict(InsertInformationCandidateChoice) + + def _construct_intent(self, question: str, query: str): + intent = "" + if query == "Not applicable": + return question + if question: + intent += f"Question: {question}\n" + if query: + intent += f"Query: {query}\n" + if not intent: + intent = "Not available." + return intent + + def _get_navigation_choice( + self, knowledge_node: KnowledgeNode, question: str, query: str + ): + # construct information intent + intent = self._construct_intent(question, query) + # construct current kb structure + structure = f"Current Node: {knowledge_node.name}\n" + child_names = ", ".join(knowledge_node.get_children_names()) + if child_names: + structure += f"Child Nodes: {child_names}" + navigated_path = " -> ".join(knowledge_node.get_path_from_root()) + structure += f"Path you have nagivated: {navigated_path}" + + # get predicted action + with dspy.settings.context(lm=self.engine): + predicted_action = self.insert_info( + intent=intent, structure=structure + ).choice + + # parse action + cleaned_predicted_action = trim_output_after_hint( + predicted_action, "Choice:" + ).strip() + cleaned_predicted_action = cleaned_predicted_action.strip("-").strip() + if cleaned_predicted_action.startswith("insert"): + return "insert", "" + elif cleaned_predicted_action.startswith("step:"): + node_name = trim_output_after_hint(cleaned_predicted_action, "step:") + return "step", node_name + elif cleaned_predicted_action.startswith("create:"): + node_name = trim_output_after_hint(cleaned_predicted_action, "create:") + return "create", node_name + raise Exception( + f"Undefined predicted action in knowledge navigation. {predicted_action}" + ) + + def layer_by_layer_navigation_placement( + self, + knowledge_base: KnowledgeBase, + question: str, + query: str, + allow_create_new_node: bool = False, + root: Optional[KnowledgeNode] = None, + ): + current_node: KnowledgeNode = knowledge_base.root if root is None else root + + while True: + action_type, node_name = self._get_navigation_choice( + knowledge_node=current_node, question=question, query=query + ) + if action_type == "insert": + return dspy.Prediction( + information_placement=" -> ".join( + current_node.get_path_from_root(root) + ), + note="None", + ) + elif action_type == "step": + for child in current_node.children: + if child.name == node_name: + current_node = child + break + else: + raise ValueError(f"Child node with name {node_name} not found.") + elif action_type == "create": + placement_path = current_node.get_path_from_root(root) + if allow_create_new_node: + placement_path.append(node_name) + note = f"create new node: {{{node_name}}} under {{{current_node.name}}}" + else: + note = f"attempt to create new node: {{{node_name}}} under {{{current_node.name}}}" + return dspy.Prediction( + information_placement=" -> ".join(placement_path), note=note + ) + else: + raise ValueError(f"Unknown action type: {action_type}") + + def _get_sorted_embed_sim_section( + self, + encoded_outline: np.ndarray, + outlines: List[str], + question: str, + query: str, + ): + if encoded_outline is not None and encoded_outline.size > 0: + encoded_query, token_usage = get_text_embeddings(f"{question}, {query}") + sim = cosine_similarity([encoded_query], encoded_outline)[0] + sorted_indices = np.argsort(sim) + sorted_outlines = np.array(outlines)[sorted_indices[::-1]] + return sorted_outlines + else: + return outlines + + def _parse_selected_index(self, string: str): + match = re.search(r"\[(\d+)\]", string) + if match: + return int(match.group(1)) + try: + return int(string.strip()) + except: + pass + return None + + def choose_candidate_from_embedding_ranking( + self, + question: str, + query: str, + encoded_outlines: np.ndarray, + outlines: List[str], + top_N_candidates: int = 5, + ): + sorted_candidates = self._get_sorted_embed_sim_section( + encoded_outlines, outlines, question, query + ) + considered_candidates = sorted_candidates[ + : min(len(sorted_candidates), top_N_candidates) + ] + choices_string = "\n".join( + [ + f"{idx + 1}: {candidate}" + for idx, candidate in enumerate(considered_candidates) + ] + ) + with dspy.settings.context(lm=self.engine, show_guidelines=False): + decision = self.candidate_choosing( + intent=self._construct_intent(question=question, query=query), + choices=choices_string, + ).decision + decision = trim_output_after_hint(decision, hint="Decision:") + if "Best placement:" in decision: + decision = trim_output_after_hint(decision, hint="Best placement:") + selected_index = self._parse_selected_index(decision) + if selected_index is not None: + selected_index = selected_index - 1 + if selected_index < len(sorted_candidates) and selected_index >= 0: + return dspy.Prediction( + information_placement=sorted_candidates[selected_index], + note=f"Choosing from:\n{considered_candidates}", + ) + return None + + def _info_list_to_intent_mapping(self, information_list: List[Information]): + intent_to_placement_dict = {} + for info in information_list: + intent = (info.meta.get("question", ""), info.meta.get("query", "")) + if intent not in intent_to_placement_dict: + intent_to_placement_dict[intent] = None + return intent_to_placement_dict + + def forward( + self, + knowledge_base: KnowledgeBase, + information: Union[Information, List[Information]], + allow_create_new_node: bool = False, + max_thread: int = 5, + insert_root: Optional[KnowledgeNode] = None, + skip_candidate_from_embedding: bool = False, + ): + + if not isinstance(information, List): + information = [information] + intent_to_placement_dict: Dict = self._info_list_to_intent_mapping( + information_list=information + ) + + # process one intent + def process_intent(question: str, query: str): + candidate_placement = None + try: + if not skip_candidate_from_embedding: + candidate_placement = self.choose_candidate_from_embedding_ranking( + question=question, + query=query, + encoded_outlines=encoded_outlines, + outlines=outlines, + top_N_candidates=8, + ) + if candidate_placement is None: + candidate_placement = self.layer_by_layer_navigation_placement( + knowledge_base=knowledge_base, + question=question, + query=query, + allow_create_new_node=allow_create_new_node, + root=insert_root, + ) + return (question, query), candidate_placement + except Exception as e: + print(traceback.format_exc()) + return (question, query), None + + def insert_info_to_kb(info, placement_prediction): + if placement_prediction is not None: + missing_node_handling = ( + "raise error" if not allow_create_new_node else "create" + ) + knowledge_base.insert_information( + path=placement_prediction.information_placement, + information=info, + missing_node_handling=missing_node_handling, + root=insert_root, + ) + + encoded_outlines, outlines = ( + knowledge_base.get_knowledge_base_structure_embedding(root=insert_root) + ) + to_return = [] + if not allow_create_new_node: + # use multi thread as knowledge base structure does not change + with ThreadPoolExecutor(max_workers=max_thread) as executor: + futures = { + executor.submit(process_intent, question, query): (question, query) + for (question, query) in intent_to_placement_dict + } + + for future in as_completed(futures): + (question, query), candidate_placement = future.result() + intent_to_placement_dict[(question, query)] = candidate_placement + # back mapping placement to each information + for info in information: + intent = (info.meta.get("question", ""), info.meta.get("query", "")) + placement_prediction = intent_to_placement_dict.get(intent, None) + insert_info_to_kb(info, placement_prediction) + to_return.append((info, placement_prediction)) + return to_return + else: + # use sequential insert as knowledge base structure might change + for question, query in intent_to_placement_dict: + encoded_outlines, outlines = ( + knowledge_base.get_knowledge_base_structure_embedding( + root=insert_root + ) + ) + _, placement_prediction = process_intent(question=question, query=query) + intent_to_placement_dict[(question, query)] = placement_prediction + + for info in information: + intent = (info.meta.get("question", ""), info.meta.get("query", "")) + placement_prediction = intent_to_placement_dict.get(intent, None) + insert_info_to_kb(info, placement_prediction) + to_return.append((info, placement_prediction)) + return to_return + + +class ExpandSection(dspy.Signature): + """Your task is to expand a section in the mind map by creating new subsections under the given section. + You will be given a list of question and query that are used to collect information. + Output should be subsection names where each section should serve as a coherent and themantic organization of information and corresponding citation numbers. These subsection names are preferred to be concise and precise. + Output follows the format below: + subsection 1 + subsection 2 + subsection 3 + """ + + section = dspy.InputField(prefix="The section you need to expand: ", format=str) + info = dspy.InputField(prefix="The collected information:\n", format=str) + output = dspy.OutputField( + prefix="Now provide the expanded subsection names (If there's no need to expand current section as itself serves good organization, then output None):\n", + format=str, + ) + + +class ExpandNodeModule(dspy.Module): + def __init__( + self, + engine: Union[dspy.dsp.LM, dspy.dsp.HFModel], + information_insert_module: dspy.Module, + node_expansion_trigger_count: int, + ): + self.engine = engine + self.expand_section = dspy.Predict(ExpandSection) + self.information_insert_module = information_insert_module + self.node_expansion_trigger_count = node_expansion_trigger_count + + def _get_cited_info_meta_string(self, node, knowledge_base): + meta_string = set() + for index in sorted(list(node.content)): + info = knowledge_base.info_uuid_to_info_dict[index] + intent = f"Question: {info.meta['question']}\nQuery: {info.meta['query']}" + meta_string.add(intent) + + return "\n\n".join(meta_string) + + def _get_expand_subnode_names(self, node, knowledge_base): + information = self._get_cited_info_meta_string(node, knowledge_base) + node_path = node.get_path_from_root() + with dspy.settings.context(lm=self.engine, show_guidelines=False): + output = self.expand_section(section=node_path, info=information).output + subsections = [] + if "\n" in output and output != "None": + subsections = output.split("\n") + # remove any integer followed by a dot and a space, a leading dashline, + # or a specific hint at the start of the string + subsections = [ + re.sub(r"^\d+\.\s|-|" + re.escape(node.name), "", text) + .replace("*", "") + .strip() + for text in subsections + ] + return subsections + + def _find_first_node_to_expand( + self, root: KnowledgeNode, expanded_nodes: List[KnowledgeNode] + ): + if root is None: + return None + if ( + root not in expanded_nodes + and len(root.content) >= self.node_expansion_trigger_count + ): + return root + for child in root.children: + to_return = self._find_first_node_to_expand( + root=child, expanded_nodes=expanded_nodes + ) + if to_return is not None: + return to_return + return None + + def _expand_node(self, node: KnowledgeNode, knowledge_base: KnowledgeBase): + subsection_names = self._get_expand_subnode_names(node, knowledge_base) + if len(subsection_names) <= 1: + return + # create new nodes + for subsection_name in subsection_names: + # remove citation bracket in the subsection name + subsection_name = re.sub(r"\[.*?\]", "", subsection_name) + knowledge_base.insert_node(new_node_name=subsection_name, parent_node=node) + # reset original information placement + original_cited_index = node.content + original_cited_information = [ + knowledge_base.info_uuid_to_info_dict[index] + for index in original_cited_index + ] + node.content = set() + # re-insert under expanded section + self.information_insert_module( + knowledge_base=knowledge_base, + information=original_cited_information, + allow_create_new_node=False, + insert_root=node, + ) + + def forward(self, knowledge_base: KnowledgeBase): + expanded_nodes = [] + while True: + node_to_expand = self._find_first_node_to_expand( + root=knowledge_base.root, expanded_nodes=expanded_nodes + ) + if node_to_expand is None: + break + self._expand_node(node=node_to_expand, knowledge_base=knowledge_base) + expanded_nodes.append(node_to_expand) diff --git a/knowledge_storm/collaborative_storm/modules/knowledge_base_summary.py b/knowledge_storm/collaborative_storm/modules/knowledge_base_summary.py new file mode 100644 index 0000000..fb8e340 --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/knowledge_base_summary.py @@ -0,0 +1,32 @@ +import dspy +from typing import Union +from ...dataclass import KnowledgeBase + + +class KnowledgeBaseSummmary(dspy.Signature): + """Your job is to give brief summary of what's been discussed in a roundtable conversation. Contents are themantically organized into hierarchical sections. + You will be presented with these sections where "#" denotes level of section. + """ + + topic = dspy.InputField(prefix="topic: ", format=str) + structure = dspy.InputField(prefix="Tree structure: \n", format=str) + output = dspy.OutputField(prefix="Now give brief summary:\n", format=str) + + +class KnowledgeBaseSummaryModule(dspy.Module): + def __init__(self, engine: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.engine = engine + self.gen_summary = dspy.Predict(KnowledgeBaseSummmary) + + def forward(self, knowledge_base: KnowledgeBase): + structure = knowledge_base.get_node_hierarchy_string( + include_indent=False, + include_full_path=False, + include_hash_tag=True, + include_node_content_count=False, + ) + with dspy.settings.context(lm=self.engine, show_guidelines=False): + summary = self.gen_summary( + topic=knowledge_base.topic, structure=structure + ).output + return summary diff --git a/knowledge_storm/collaborative_storm/modules/simulate_user.py b/knowledge_storm/collaborative_storm/modules/simulate_user.py new file mode 100644 index 0000000..2d03e9d --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/simulate_user.py @@ -0,0 +1,37 @@ +import dspy +from typing import List, Union + +from .collaborative_storm_utils import extract_and_remove_citations +from ...dataclass import ConversationTurn +from ...storm_wiki.modules.knowledge_curation import AskQuestionWithPersona + + +class GenSimulatedUserUtterance(dspy.Module): + def __init__(self, engine: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.engine = engine + self.ask_qeustion = dspy.Predict(AskQuestionWithPersona) + + def gen_conv_history_string(self, conversation_turns: List[ConversationTurn]): + conv_history = [] + total_turns = len(conversation_turns) + + for i, turn in enumerate(conversation_turns): + utterance, _ = extract_and_remove_citations(turn.utterance) + if i >= total_turns - 4: + conv_history.append(f"{turn.role}: {utterance}") + else: + if turn.claim_to_make: + conv_history.append(f"{turn.role}: {turn.claim_to_make}") + else: + conv_history.append(f"{turn.role}: {utterance}") + + return "\n".join(conv_history) + + def forward(self, topic: str, intent: str, conv_history: List[ConversationTurn]): + conv_history_string = self.gen_conv_history_string(conv_history) + with dspy.settings.context(lm=self.engine, show_guidelines=False): + return self.ask_qeustion( + topic=topic, + persona=f"researcher with interest in {intent}", + conv=conv_history_string, + ).question diff --git a/knowledge_storm/collaborative_storm/modules/warmstart_hierarchical_chat.py b/knowledge_storm/collaborative_storm/modules/warmstart_hierarchical_chat.py new file mode 100644 index 0000000..a6351aa --- /dev/null +++ b/knowledge_storm/collaborative_storm/modules/warmstart_hierarchical_chat.py @@ -0,0 +1,398 @@ +import dspy +import concurrent.futures +from threading import Lock +from typing import List, Optional, Union, TYPE_CHECKING + +from .callback import BaseCallbackHandler +from .collaborative_storm_utils import _get_answer_question_module_instance +from .expert_generation import GenerateExpertModule +from .grounded_question_answering import AnswerQuestionModule +from ...dataclass import ConversationTurn, KnowledgeBase +from ...interface import LMConfigs +from ...logging_wrapper import LoggingWrapper +from ...storm_wiki.modules.outline_generation import WritePageOutline +from ...utils import ArticleTextProcessing as AP + + +if TYPE_CHECKING: + from ..engine import RunnerArgument + + +class WarmStartModerator(dspy.Signature): + """ + You are a moderator in a roundtable discussion. The goal is to chat with multiple experts to discuss the facts and background of the topic to familiarize the audience with the topic. + You will be presented with the topic, the history of question you have already asked, and the current expert you are discussing with. + Based on these information, generate the next question for the current expert to further the discussion. + + The output should only include the next question for the current expert. Do not include any other information or preamble. + """ + + topic = dspy.InputField(prefix="Topic for roundtable discussion: ", format=str) + history = dspy.InputField( + prefix="Experts you have already interacted with: ", format=str + ) + current_expert = dspy.InputField(prefix="Expert you are talking with:", format=str) + question = dspy.OutputField( + prefix="Next question for the expert you are talking with: ", format=str + ) + + +class SectionToConvTranscript(dspy.Signature): + """ + You are given a section of a brief report on a specific topic. Your task is to transform this section into an engaging opening discussion for a roundtable conversation. + The goal is to help participants and the audience quickly understand the key information. + Both question and answer should be in the tone of roundtable discussion talking to audiences. + + Specifically, you need to: + 1. Generate an engaging question that leverages section name and topic that opens discussion of the content. + 2. Provide a brief and engaging answer (with all inline citations from original text) derived from the section serving as pointers and avoid too much details. + """ + + topic = dspy.InputField(prefix="topic:", format=str) + section_name = dspy.InputField(prefix="section name:", format=str) + section_content = dspy.InputField(prefix="section content:", format=str) + question = dspy.OutputField(prefix="Now give engaging question only.\nQuestion:") + answer = dspy.OutputField( + prefix="Now give engaging answer only with all inline citations from original text.\nAnswer:" + ) + + +class ReportToConversation(dspy.Module): + def __init__(self, engine: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.engine = engine + self.section_to_conv_transcript = dspy.Predict(SectionToConvTranscript) + + def forward(self, knowledge_base: KnowledgeBase): + def process_node(node, topic): + with dspy.settings.context(lm=self.engine, show_guidelines=False): + output = self.section_to_conv_transcript( + topic=topic, + section_name=node.get_path_from_root(), + section_content=node.synthesize_output, + ) + question = output.question.replace("Question:", "").strip() + answer = output.answer.replace("Answer:", "").strip() + return question, answer + + conversations = [] + nodes = knowledge_base.collect_all_nodes() + nodes = [node for node in nodes if node.name != "root" and node.content] + topic = knowledge_base.topic + + with concurrent.futures.ThreadPoolExecutor() as executor: + future_to_node = { + executor.submit(process_node, node, topic): node for node in nodes + } + for future in concurrent.futures.as_completed(future_to_node): + node = future_to_node[future] + question, answer = future.result() + conversations.append( + ConversationTurn( + role="Background discussion moderator", + raw_utterance=question, + utterance_type="Original Question", + utterance=question, + cited_info=[ + knowledge_base.info_uuid_to_info_dict[idx] + for idx in AP.parse_citation_indices(question) + ], + ) + ) + conversations.append( + ConversationTurn( + role="Background discussion expert", + raw_utterance=answer, + utterance_type="Potential Answer", + utterance=answer, + cited_info=[ + knowledge_base.info_uuid_to_info_dict[idx] + for idx in AP.parse_citation_indices(answer) + ], + ) + ) + return conversations + + +class WarmStartConversation(dspy.Module): + def __init__( + self, + question_asking_lm: Union[dspy.dsp.LM, dspy.dsp.HFModel], + generate_expert_module: GenerateExpertModule, + answer_question_module: AnswerQuestionModule, + logging_wrapper: LoggingWrapper, + max_num_experts: int = 3, + max_turn_per_experts: int = 2, + max_thread: int = 3, + callback_handler: BaseCallbackHandler = None, + ): + self.ask_question = dspy.Predict(WarmStartModerator) + self.max_num_experts = max_num_experts + self.max_turn_per_experts = max_turn_per_experts + self.question_asking_lm = question_asking_lm + self.answer_question_module = answer_question_module + self.max_thread = max_thread + self.generate_experts_module = generate_expert_module + self.logging_wrapper = logging_wrapper + self.callback_handler = callback_handler + + def format_dialogue_question_history_string( + self, conversation_history: List[ConversationTurn] + ): + output = [] + for idx, turn in enumerate(conversation_history): + info = turn.claim_to_make if turn.claim_to_make else turn.utterance + output.append(f"{idx + 1}: {info}") + return "\n".join(output) + + def generate_warmstart_experts(self, topic: str): + background_seeking_dialogue = self.get_background_info(topic=topic) + background_info = background_seeking_dialogue.utterance + gen_expert_output = self.generate_experts_module( + topic=topic, + background_info=background_info, + num_experts=self.max_num_experts, + ) + return gen_expert_output.experts, background_seeking_dialogue + + def get_background_info(self, topic: str): + question = f"Background information about {topic}" + answer = self.answer_question_module( + topic=topic, question=question, mode="extensive", style="conversational" + ) + + return ConversationTurn( + role="Default Background Researcher", + raw_utterance=answer.response, + utterance_type="Questioning", + claim_to_make=question, + queries=answer.queries, + raw_retrieved_info=answer.raw_retrieved_info, + cited_info=answer.cited_info, + ) + + def forward(self, topic: str): + with self.logging_wrapper.log_event( + "warm start, perspective guided QA: identify experts" + ): + # do background research, generate some experts + experts, background_seeking_dialogue = self.generate_warmstart_experts( + topic=topic + ) + # init list to store the dialogue history + conversation_history: List[ConversationTurn] = [] + lock = Lock() + + # hierarchical chat: chat with one expert. Generate question, get answer + def process_expert(expert): + expert_name, expert_descriptoin = expert.split(":") + for idx in range(self.max_turn_per_experts): + with self.logging_wrapper.log_event( + f"warm start, perspective guided QA: expert {expert_name}; turn {idx + 1}" + ): + try: + with lock: + history = self.format_dialogue_question_history_string( + conversation_history + ) + with dspy.settings.context(lm=self.question_asking_lm): + question = self.ask_question( + topic=topic, history=history, current_expert=expert + ).question + answer = self.answer_question_module( + topic=topic, + question=question, + mode="brief", + style="conversational", + ) + conversation_turn = ConversationTurn( + role=expert, + claim_to_make=question, + raw_utterance=answer.response, + utterance_type="Support", + queries=answer.queries, + raw_retrieved_info=answer.raw_retrieved_info, + cited_info=answer.cited_info, + ) + if self.callback_handler is not None: + self.callback_handler.on_warmstart_update( + message="\n".join( + [ + f"Finish browsing {url}" + for url in [ + i.url for i in answer.raw_retrieved_info + ] + ] + ) + ) + with lock: + conversation_history.append(conversation_turn) + except Exception as e: + print(f"Error processing expert {expert}: {e}") + + # multi-thread conversation + with concurrent.futures.ThreadPoolExecutor( + max_workers=self.max_thread + ) as executor: + futures = [ + executor.submit(process_expert, expert) + for expert in experts[: min(len(experts), self.max_num_experts)] + ] + concurrent.futures.wait(futures) + + conversation_history = [background_seeking_dialogue] + conversation_history + + return dspy.Prediction( + conversation_history=conversation_history, experts=experts + ) + + +class GenerateWarmStartOutline(dspy.Signature): + """Generate a outline of the wikipedia-like report from a roundtable discussion. You will be presented discussion points in the conversation and corresponding queries. + You will be given a draft outline which you can borrow some inspiration. Do not include sections that are not mentioned in the given discussion history. + Use "#" to denote section headings, "##" to denote subsection headings, and so on. + Follow these guidelines: + 1. Use "#" for section titles, "##" for subsection titles, "###" for subsubsection titles, and so on. + 2. Do not include any additional information. + 3. Exclude the topic name from the outline. + The organization of outline should adopt wikiepdia style. + """ + + topic = dspy.InputField(prefix="The topic discussed: ", format=str) + draft = dspy.InputField(prefix="Draft outline you can reference to: ", format=str) + conv = dspy.InputField(prefix="Discussion history:\n", format=str) + outline = dspy.OutputField( + prefix='Write the conversation outline (Use "#" Title" to indicate section title, "##" Title" to indicate subsection title, ...):\n', + format=str, + ) + + +class GenerateWarmStartOutlineModule(dspy.Module): + def __init__(self, engine: Union[dspy.dsp.LM, dspy.dsp.HFModel]): + self.engine = engine + self.gen_outline = dspy.Predict(GenerateWarmStartOutline) + self.draft_outline = dspy.Predict(WritePageOutline) + + def extract_questions_and_queries(self, conv: List[ConversationTurn]): + context = [] + for turn in conv: + focus = turn.claim_to_make + queries = turn.queries + queries_string = "\n\t".join( + f"Query {idx + 1}: {query}" for idx, query in enumerate(queries) + ) + string = f"Discussion focus {len(context) + 1}: {focus}\n\t{queries_string}" + context.append(string) + return "\n".join(context) + + def get_draft_outline(self, topic: str): + with dspy.settings.context(lm=self.engine): + return self.draft_outline(topic=topic).outline + + def forward(self, topic: str, conv: List[ConversationTurn]): + discussion_history = self.extract_questions_and_queries(conv) + draft_outline = self.get_draft_outline(topic=topic) + with dspy.settings.context(lm=self.engine): + outline = self.gen_outline( + topic=topic, draft=draft_outline, conv=discussion_history + ).outline + outline = AP.clean_up_outline(outline) + return dspy.Prediction(outline=outline, draft_outline=draft_outline) + + +class WarmStartModule: + def __init__( + self, + lm_config: LMConfigs, + runner_argument: "RunnerArgument", + logging_wrapper: LoggingWrapper, + rm: Optional[dspy.Retrieve] = None, + callback_handler: BaseCallbackHandler = None, + ): + generate_expert_module = GenerateExpertModule( + engine=lm_config.discourse_manage_lm + ) + self.warmstart_conv = WarmStartConversation( + question_asking_lm=lm_config.question_asking_lm, + generate_expert_module=generate_expert_module, + answer_question_module=_get_answer_question_module_instance( + lm_config=lm_config, + runner_argument=runner_argument, + logging_wrapper=logging_wrapper, + rm=rm, + ), + max_num_experts=runner_argument.warmstart_max_num_experts, + max_turn_per_experts=runner_argument.warmstart_max_turn_per_experts, + max_thread=runner_argument.warmstart_max_thread, + logging_wrapper=logging_wrapper, + callback_handler=callback_handler, + ) + self.warmstart_outline_gen_module = GenerateWarmStartOutlineModule( + engine=lm_config.warmstart_outline_gen_lm + ) + self.report_to_conversation = ReportToConversation(lm_config.knowledge_base_lm) + self.logging_wrapper = logging_wrapper + self.callback_handler = callback_handler + + def initiate_warm_start(self, topic: str, knowledge_base: KnowledgeBase): + """ + Initiates a warm start process for the given topic by generating a warm start conversation and inserting the + resulting information into a knowledge base. + + Args: + topic (str): The topic for which to initiate the warm start process. + + Returns: + Tuple[List[ConversationTurn], List[str], KnowledgeBase]: + - A list of ConversationTurn instances representing the conversation history. + - A list of strings representing the experts involved in the conversation. + - A KnowledgeBase instance containing the organized information. + """ + warm_start_conversation_history: List[ConversationTurn] = [] + warm_start_experts = None + # get warm start conversations + with self.logging_wrapper.log_event("warm start: perspective guided QA"): + if self.callback_handler is not None: + self.callback_handler.on_warmstart_update( + message="Start getting familiar with the topic by chatting with multiple LLM experts (Step 1 / 4)" + ) + warm_start_result = self.warmstart_conv(topic=topic) + warm_start_conversation_history = warm_start_result.conversation_history + warm_start_experts = warm_start_result.experts + + # get warm start conv outline + with self.logging_wrapper.log_event("warm start: outline generation"): + if self.callback_handler is not None: + self.callback_handler.on_warmstart_update( + "Organizing collected information (Step 2 / 4)" + ) + warm_start_outline_output = self.warmstart_outline_gen_module( + topic=topic, conv=warm_start_conversation_history + ) + # init knowledge base + with self.logging_wrapper.log_event("warm start: insert into knowledge base"): + if self.callback_handler is not None: + self.callback_handler.on_warmstart_update( + "Inserting collected information into knowledge base (Step 3 / 4)" + ) + knowledge_base.insert_from_outline_string( + outline_string=warm_start_outline_output.outline + ) + # insert information to knowledge base + for turn in warm_start_conversation_history: + knowledge_base.update_from_conv_turn( + conv_turn=turn, allow_create_new_node=False + ) + # knowledge base to report + if self.callback_handler is not None: + self.callback_handler.on_warmstart_update( + "Synthesizing background information discussion utterances (Step 4 / 4)" + ) + knowledge_base.to_report() + + # generate engaging conversations + engaging_conversations = self.report_to_conversation(knowledge_base) + return ( + warm_start_conversation_history, + engaging_conversations, + warm_start_experts, + ) From 4f4aab9b1b06f530f3f8489425d11fc76cfc11c7 Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Tue, 24 Sep 2024 21:38:57 -0700 Subject: [PATCH 02/19] refactor interfaces of dataclasses, encoder, retriever, logging wrapper, to support datatype sharing between storm and co-storm --- knowledge_storm/dataclass.py | 831 ++++++++++++++++++ knowledge_storm/encoder.py | 169 ++++ knowledge_storm/interface.py | 205 ++++- knowledge_storm/lm.py | 44 +- knowledge_storm/logging_wrapper.py | 212 +++++ knowledge_storm/rm.py | 136 ++- knowledge_storm/storm_wiki/engine.py | 48 +- .../storm_wiki/modules/article_generation.py | 12 +- .../storm_wiki/modules/knowledge_curation.py | 9 +- .../storm_wiki/modules/retriever.py | 24 - .../storm_wiki/modules/storm_dataclass.py | 75 +- 11 files changed, 1571 insertions(+), 194 deletions(-) create mode 100644 knowledge_storm/dataclass.py create mode 100644 knowledge_storm/encoder.py create mode 100644 knowledge_storm/logging_wrapper.py diff --git a/knowledge_storm/dataclass.py b/knowledge_storm/dataclass.py new file mode 100644 index 0000000..1ec1a8c --- /dev/null +++ b/knowledge_storm/dataclass.py @@ -0,0 +1,831 @@ +import dspy +import numpy as np +import re +import threading +from typing import Set, Dict, List, Optional, Union, Tuple + +from .encoder import get_text_embeddings +from .interface import Information + + +class ConversationTurn: + """ + A class to represent a turn in a conversation. + + Attributes: + role (str): A short phrase of the role of the speaker for the current conversation turn. + raw_utterance (str): The response generated by the LM model without polished style and tone. + utterance_type (str): The type of utterance (e.g., statement, question). + claim_to_make (Optional[str]): The point that this utterance tries to make. Should be empty if the utterance type is questioning. + utterance (Optional[str]): The response generated by the model with polished style and tone. Defaults to raw_utterance if not provided. + queries (List[str]): The queries used to gather information to have a grounded answer. + raw_retrieved_info (List['Information']): A list of Information type that is retrieved. + cited_info (Dict[int, 'Information']): A dictionary where the key is the citation index and the value is Information type. + role_description (Optional[str]): A few sentences description of the role. Defaults to an empty string if not provided. + """ + + def __init__( + self, + role: str, + raw_utterance: str, + utterance_type: str, + claim_to_make: Optional[str] = None, + utterance: Optional[str] = None, + queries: Optional[List[str]] = None, + raw_retrieved_info: Optional[List[Information]] = None, + cited_info: Optional[List[Information]] = None, + ): + self.utterance = utterance if utterance is not None else raw_utterance + self.raw_utterance = raw_utterance + self.role = role if ":" not in role else role.split(":")[0] + self.role_description = "" if ":" not in role else role.split(":")[1] + self.queries = queries if queries is not None else [] + self.raw_retrieved_info = ( + raw_retrieved_info if raw_retrieved_info is not None else [] + ) + self.cited_info = cited_info if cited_info is not None else {} + self.utterance_type = utterance_type + self.claim_to_make = claim_to_make if claim_to_make is not None else "" + + def get_all_citation_index(self): + citation_pattern = re.compile(r"\[(\d+)\]") + return list(map(int, citation_pattern.findall(self.utterance))) + + def to_dict(self): + raw_retrieved_info = [info.to_dict() for info in self.raw_retrieved_info] + return { + "utterance": self.utterance, + "raw_utterance": self.raw_utterance, + "role": self.role, + "role_description": self.role_description, + "queries": self.queries, + "utterance_type": self.utterance_type, + "claim_to_make": self.claim_to_make, + "raw_retrieved_info": raw_retrieved_info, + "cited_info": None, + } + + @classmethod + def from_dict(cls, conv_turn_dict: Dict): + raw_retrieved_info = [ + Information.from_dict(info) for info in conv_turn_dict["raw_retrieved_info"] + ] + + return cls( + utterance=conv_turn_dict["utterance"], + raw_utterance=conv_turn_dict["raw_utterance"], + role=f"{conv_turn_dict['role']}: {conv_turn_dict['role_description']}", + queries=conv_turn_dict["queries"], + raw_retrieved_info=raw_retrieved_info, + cited_info=None, + utterance_type=conv_turn_dict["utterance_type"], + claim_to_make=conv_turn_dict["claim_to_make"], + ) + + +class KnowledgeNode: + """ + Class representing a node in the knowledge base. + + Attributes: + name (str): The name of the node. + content (list): A list of Information instances. + children (list): A list of child KnowledgeNode instances. + parent (KnowledgeNode): The parent node of the current node. + """ + + def __init__( + self, + name: str, + content: Optional[str] = None, + parent: Optional["KnowledgeNode"] = None, + children: Optional[List["KnowledgeNode"]] = None, + synthesize_output: Optional[str] = None, + need_regenerate_synthesize_output: bool = True, + ): + """ + Initializes a KnowledgeNode instance. + + Args: + name (str): The name of the node. + content (list, optional): A list of information uuid. Defaults to None. + parent (KnowledgeNode, optional): The parent node of the current node. Defaults to None. + """ + self.name = name + self.content: Set[int] = set(content) if content is not None else set() + self.children = [] if children is None else children + self.parent = parent + self.synthesize_output = synthesize_output + self.need_regenerate_synthesize_output = need_regenerate_synthesize_output + + def collect_all_content(self): + """ + Collects all content from the current node and its descendants. + + Returns: + Set[int]: A set containing all content from the current node and its descendants. + """ + all_content = set(self.content) + for child in self.children: + all_content.update(child.collect_all_content()) + return all_content + + def has_child(self, child_node_name: str): + """ + Check if the node has the child of given name. + """ + return child_node_name in [child.name for child in self.children] + + def add_child(self, child_node_name: str, duplicate_handling: str = "skip"): + """ + Adds a child node to the current node. + duplicate_handling (str): How to handle duplicate nodes. Options are "skip", "none", and "raise error". + """ + if self.has_child(child_node_name): + if duplicate_handling == "skip": + for child in self.children: + if child.name == child_node_name: + return child + elif duplicate_handling == "raise error": + raise Exception( + f"Insert node error. Node {child_node_name} already exists under its parent node {self.name}." + ) + child_node = KnowledgeNode(name=child_node_name, parent=self) + self.children.append(child_node) + return child_node + + def get_parent(self): + """ + Returns the parent node of the current node. + + Returns: + KnowledgeNode: The parent node of the current node. + """ + return self.parent + + def get_children(self): + """ + Returns the children of the current node. + + Returns: + list: A list of child KnowledgeNode instances. + """ + return self.children + + def get_children_names(self): + """ + Returns a list of children names. + """ + return [child.name for child in self.children] + + def __repr__(self): + """ + Returns a string representation of the KnowledgeNode instance. + + Returns: + str: String representation of the KnowledgeNode instance. + """ + return f"KnowledgeNode(name={self.name}, content={self.content}, children={len(self.children)})" + + def get_path_from_root(self, root: Optional["KnowledgeNode"] = None): + """ + Get a list of names from the root to this node. + + Returns: + List[str]: A list of node names from the root to this node. + """ + path = [] + current_node = self + while current_node: + path.append(current_node.name) + if root is not None and current_node.name == root.name: + break + current_node = current_node.parent + return path[::-1] + + def insert_information(self, information_index: int): + if information_index not in self.content: + self.need_regenerate_synthesize_output = True + self.content.add(information_index) + + def get_all_descendents(self) -> List["KnowledgeNode"]: + """ + Get a list of all descendant nodes. + + Returns: + List[KnowledgeNode]: A list of all descendant nodes. + """ + descendents = [] + + def collect_descendents(node): + for child in node.children: + descendents.append(child) + collect_descendents(child) + + collect_descendents(self) + return descendents + + def get_all_predecessors(self) -> List["KnowledgeNode"]: + """ + Get a list of all predecessor nodes (from current node to root). + + Returns: + List[KnowledgeNode]: A list of all predecessor nodes. + """ + predecessors = [] + current_node = self.parent + while current_node is not None: + predecessors.append(current_node) + current_node = current_node.parent + return predecessors + + def to_dict(self): + """ + Converts the KnowledgeNode instance to a dictionary representation. + + Returns: + dict: The dictionary representation of the KnowledgeNode. + """ + return { + "name": self.name, + "content": list(self.content), + "children": [child.to_dict() for child in self.children], + "parent": self.parent.name if self.parent else None, + "synthesize_output": self.synthesize_output, + "need_regenerate_synthesize_output": self.need_regenerate_synthesize_output, + } + + @classmethod + def from_dict(cls, data): + """ + Constructs a KnowledgeNode instance from a dictionary representation. + + Args: + data (dict): The dictionary representation of the KnowledgeNode. + + Returns: + KnowledgeNode: The constructed KnowledgeNode instance. + """ + + def helper(cls, data, parent_node=None): + if parent_node is not None: + assert data["parent"] is not None and data["parent"] == parent_node.name + node = cls( + name=data["name"], + content=data["content"], + parent=parent_node, + children=None, + synthesize_output=data.get("synthesize_output", None), + need_regenerate_synthesize_output=data.get( + "need_regenerate_synthesize_output", True + ), + ) + for child_data in data["children"]: + child_node = helper(cls, child_data, parent_node=node) + node.children.append(child_node) + return node + + return helper(cls, data) + + +class KnowledgeBase: + """ + Class representing the knowledge base. + + Attributes: + root (KnowledgeNode): The root node of the knowledge base. + """ + + def __init__( + self, + topic: str, + knowledge_base_lm: Union[dspy.dsp.LM, dspy.dsp.HFModel], + node_expansion_trigger_count: int, + ): + """ + Initializes a KnowledgeBase instance. + + Args: + topic (str): The topic of the knowledge base + expand_node_module (dspy.Module): The module that organize knowledge base in place. + The module should accept knowledge base as param. E.g. expand_node_module(self) + article_generation_module (dspy.Module): The module that generate report from knowledge base. + The module should return string. E.g. report = article_generation_module(self) + """ + from .collaborative_storm.modules.article_generation import ( + ArticleGenerationModule, + ) + from .collaborative_storm.modules.information_insertion_module import ( + InsertInformationModule, + ExpandNodeModule, + ) + from .collaborative_storm.modules.knowledge_base_summary import ( + KnowledgeBaseSummaryModule, + ) + + self.topic: str = topic + + self.information_insert_module = InsertInformationModule( + engine=knowledge_base_lm + ) + self.expand_node_module = ExpandNodeModule( + engine=knowledge_base_lm, + information_insert_module=self.information_insert_module, + node_expansion_trigger_count=node_expansion_trigger_count, + ) + self.article_generation_module = ArticleGenerationModule( + engine=knowledge_base_lm + ) + self.gen_summary_module = KnowledgeBaseSummaryModule(engine=knowledge_base_lm) + + self.root: KnowledgeNode = KnowledgeNode(name="root") + self.kb_embedding = { + "hash": hash(""), + "encoded_structure": np.array([[]]), + "structure_string": "", + } + self.embedding_cache: Dict[str, np.ndarray] = {} + self.info_uuid_to_info_dict: Dict[int, Information] = {} + self.info_hash_to_uuid_dict: Dict[int, int] = {} + self._lock = threading.Lock() + + def to_dict(self): + info_uuid_to_info_dict = { + key: value.to_dict() for key, value in self.info_uuid_to_info_dict.items() + } + return { + "topic": self.topic, + "tree": self.root.to_dict(), + "info_uuid_to_info_dict": info_uuid_to_info_dict, + "info_hash_to_uuid_dict": self.info_hash_to_uuid_dict, + } + + @classmethod + def from_dict( + cls, + data: Dict, + knowledge_base_lm: Union[dspy.dsp.LM, dspy.dsp.HFModel], + node_expansion_trigger_count: int, + ): + knowledge_base = cls( + topic=data["topic"], + knowledge_base_lm=knowledge_base_lm, + node_expansion_trigger_count=node_expansion_trigger_count, + ) + knowledge_base.root = KnowledgeNode.from_dict(data["tree"]) + knowledge_base.info_hash_to_uuid_dict = { + int(key): int(value) + for key, value in data["info_hash_to_uuid_dict"].items() + } + info_uuid_to_info_dict = { + int(key): Information.from_dict(value) + for key, value in data["info_uuid_to_info_dict"].items() + } + knowledge_base.info_uuid_to_info_dict = info_uuid_to_info_dict + return knowledge_base + + def get_knowledge_base_structure_embedding( + self, root: Optional[KnowledgeNode] = None + ) -> Tuple[np.ndarray, List[str]]: + outline_string = self.get_node_hierarchy_string( + include_indent=False, + include_full_path=True, + include_hash_tag=False, + root=root, + ) + outline_string_hash = hash(outline_string) + if outline_string_hash != self.kb_embedding["hash"]: + outline_strings: List[str] = outline_string.split("\n") + cleaned_outline_strings = [ + outline.replace(" -> ", ", ") for outline in outline_strings + ] + encoded_outline, _ = get_text_embeddings( + cleaned_outline_strings, embedding_cache=self.embedding_cache + ) + self.kb_embedding = { + "hash": outline_string_hash, + "encoded_structure": encoded_outline, + "structure_string": outline_strings, + } + return ( + self.kb_embedding["encoded_structure"], + self.kb_embedding["structure_string"], + ) + + def traverse_down(self, node): + """ + Traverses the tree downward from the given node. + + Args: + node (KnowledgeNode): The node to start the traversal from. + + Returns: + list: A list of KnowledgeNode instances in the order they were visited. + """ + nodes = [] + + def _traverse(current_node): + nodes.append(current_node) + for child in current_node.get_children(): + _traverse(child) + + _traverse(node) + return nodes + + def traverse_up(self, node): + """ + Traverses the tree upward from the given node. + + Args: + node (KnowledgeNode): The node to start the traversal from. + + Returns: + list: A list of KnowledgeNode instances in the order they were visited. + """ + nodes = [] + while node is not None: + nodes.append(node) + node = node.get_parent() + return nodes + + def collect_all_nodes(self): + nodes = [] + + def _collect(node): + nodes.append(node) + for child in node.children: + _collect(child) + + _collect(self.root) + return nodes + + def insert_node( + self, + new_node_name, + parent_node: Optional[KnowledgeNode] = None, + duplicate_handling="skip", + ): + """ + Inserts a new node into the knowledge base under the specified parent node. + + Args: + new_node_name (str): The name of the new node. + parent_node_name (str): The name of the parent node. If None, the new node is inserted under the root. + duplicate_handling (str): How to handle duplicate nodes. Options are "skip", "none", and "raise error". + """ + if parent_node is None: + return self.root.add_child( + new_node_name, duplicate_handling=duplicate_handling + ) + else: + return parent_node.add_child( + new_node_name, duplicate_handling=duplicate_handling + ) + + def find_node(self, current_node, node_name): + """ + Finds a node by name in the knowledge base. + + Args: + current_node (KnowledgeNode): The node to start the search from. + node_name (str): The name of the node to find. + + Returns: + KnowledgeNode: The node with the specified name, or None if not found. + """ + if current_node.name == node_name: + return current_node + for child in current_node.get_children(): + result = self.find_node(child, node_name) + if result is not None: + return result + return None + + def insert_from_outline_string(self, outline_string, duplicate_handling="skip"): + """ + Creates and inserts nodes into the knowledge base from a string outline. + + Args: + outline_string (str): The outline string where each line starts with '#' denoting the level. + duplicate_handling (str): How to handle duplicate nodes. Options are "skip", "none", and "raise error". + """ + last_node_at_level = {} + for line in outline_string.split("\n"): + level = line.count("#") + if level > 0: + title = line.strip("# ").strip() + if title.lower() in ["overview", "summary", "introduction"]: + continue + parent_node = None if level == 1 else last_node_at_level.get(level - 1) + new_node = self.insert_node( + new_node_name=title, + parent_node=parent_node, + duplicate_handling=duplicate_handling, + ) + last_node_at_level[level] = new_node + for deeper_level in list(last_node_at_level.keys()): + if deeper_level > level: + del last_node_at_level[deeper_level] + + def get_node_hierarchy_string( + self, + include_indent=False, + include_full_path=False, + include_hash_tag=True, + include_node_content_count=False, + cited_indices: Optional[List[int]] = None, + root: Optional[KnowledgeNode] = None, + ) -> str: + + def find_node_contain_index(node, index): + """ + Traverses the tree downward from the given node. + + Args: + node (KnowledgeNode): The node to start the traversal from. + + Returns: + list: A list of KnowledgeNode instances in the order they were visited. + """ + nodes = [] + + def _traverse(current_node): + if current_node is not None and index in current_node.content: + nodes.append(current_node) + for child in current_node.get_children(): + _traverse(child) + + _traverse(node) + return nodes + + paths_to_highlight = set() + nodes_to_include = set() + if cited_indices is not None: + for index in cited_indices: + for cur_node in find_node_contain_index(self.root, index): + paths_to_highlight.add(" -> ".join(cur_node.get_path_from_root())) + nodes_to_include.add(cur_node) + nodes_to_include.update(cur_node.get_all_descendents()) + predecessors = cur_node.get_all_predecessors() + for predecessor in predecessors: + nodes_to_include.update(predecessor.children) + nodes_to_include.update(predecessors) + + def should_include_node(node): + if cited_indices is None: + return True + return node in nodes_to_include + + def should_omit_child_nodes(node): + if cited_indices is None: + return False + for child in node.children: + if should_include_node(child): + return False + return True + + def helper(cur_root, level): + to_return = [] + if cur_root is not None: + should_include_current_node = should_include_node(cur_root) + + indent = "" if not include_indent else "\t" * (level - 1) + full_path = " -> ".join(cur_root.get_path_from_root(root=root)) + node_info = cur_root.name if not include_full_path else full_path + hash_tag = "#" * level + " " if include_hash_tag else "" + content_count = ( + f" ({len(cur_root.content)})" if include_node_content_count else "" + ) + special_note = ( + "" + if cited_indices is None or full_path not in paths_to_highlight + else " ⭐" + ) + + if should_include_current_node: + to_return.append( + f"{indent}{hash_tag}{node_info}{content_count}{special_note}" + ) + if should_omit_child_nodes(cur_root): + if len(cur_root.children) > 0: + child_indent = indent = ( + "" if not include_indent else "\t" * (level) + ) + to_return.append(f"{child_indent}...") + else: + for child in cur_root.children: + to_return.extend(helper(child, level + 1)) + return to_return + + to_return = [] + if root is None and self.root is not None: + for child in self.root.children: + to_return.extend(helper(child, level=1)) + else: + to_return.extend(helper(root, level=1)) + + return "\n".join(to_return) + + def find_node_by_path( + self, + path: str, + missing_node_handling="abort", + root: Optional[KnowledgeNode] = None, + ): + """ + Returns the target node given a path string. + + Args: + path (str): The path to the node, with node names connected by " -> ". + missing_node_handling (str): How to handle missing nodes. Options are "abort", "create", and "raise error". + + Returns: + KnowledgeNode: The target node. + """ + node_names = path.split(" -> ") + current_node = self.root if root is None else root + + for name in node_names[1:]: + found_node = next( + (child for child in current_node.children if child.name == name), None + ) + if found_node is None: + if missing_node_handling == "abort": + return + elif missing_node_handling == "create": + new_node = current_node.add_child(child_node_name=name) + current_node = new_node + elif missing_node_handling == "raise error": + structure = self.get_node_hierarchy_string( + include_indent=True, + include_full_path=False, + include_hash_tag=True, + ) + raise Exception( + f"Insert information error. Unable to find node {{{name}}} under {{{current_node.name}}}\n{structure}" + ) + else: + current_node = found_node + return current_node + + def insert_information( + self, + path: str, + information: Information, + missing_node_handling="abort", + root: Optional[KnowledgeNode] = None, + ): + """ + Inserts information into the knowledge base at the specified path. + + Args: + path (str): The placement path string, connected by " -> " linking the name of nodes. + information (Information): The information to insert. + missing_node_handling (str): How to handle missing nodes. Options are "abort", "create", and "raise error". + Return: + uuid of insertion information + """ + with self._lock: + target_node: KnowledgeNode = self.find_node_by_path( + path=path, missing_node_handling=missing_node_handling, root=root + ) + information_hash = hash(information) + if information.citation_uuid == -1: + info_citation_uuid = self.info_hash_to_uuid_dict.get( + information_hash, len(self.info_hash_to_uuid_dict) + 1 + ) + information.citation_uuid = info_citation_uuid + self.info_hash_to_uuid_dict[information_hash] = info_citation_uuid + self.info_uuid_to_info_dict[info_citation_uuid] = information + if target_node is not None: + self.info_uuid_to_info_dict[information.citation_uuid].meta[ + "placement" + ] = " -> ".join(target_node.get_path_from_root()) + target_node.insert_information(information.citation_uuid) + + def trim_empty_leaf_nodes(self): + """ + Trims all leaf nodes that do not have any content. Iteratively does it until all leaf nodes have at least one content. + """ + + def trim_node(node): + if not node.children and not node.content: + return True + node.children = [child for child in node.children if not trim_node(child)] + return not node.children and not node.content + + # Start the trimming process from the root + while True: + before_trim = len(self.get_all_leaf_nodes()) + trim_node(self.root) + after_trim = len(self.get_all_leaf_nodes()) + if before_trim == after_trim: + break + + def get_all_leaf_nodes(self): + """ + Helper function to get all leaf nodes. + + Returns: + List[KnowledgeNode]: A list of all leaf nodes in the knowledge base. + """ + leaf_nodes = [] + + def find_leaf_nodes(node): + if not node.children: + leaf_nodes.append(node) + for child in node.children: + find_leaf_nodes(child) + + find_leaf_nodes(self.root) + return leaf_nodes + + def merge_single_child_nodes(self): + """ + Merges content of a node with its single child and removes the child node. + Iteratively does this from leaf nodes back to the root. + """ + + def merge_node(node): + # Recursively merge children first + for child in node.children: + merge_node(child) + + # If the node has exactly one child, merge its content with the child and remove the child + if len(node.children) == 1: + single_child = node.children[0] + node.content.update(single_child.content) + node.children = single_child.children + for grandchild in node.children: + grandchild.parent = node + + merge_node(self.root) + + def update_all_info_path(self): + def _helper(node): + for citation_idx in node.content: + self.info_uuid_to_info_dict[citation_idx].meta["placement"] = ( + " -> ".join(node.get_path_from_root()) + ) + for child in node.children: + _helper(child) + + _helper(self.root) + + def update_from_conv_turn( + self, + conv_turn: ConversationTurn, + allow_create_new_node: bool = False, + insert_under_root: bool = False, + ): + if conv_turn is None: + return + info_to_insert = list(conv_turn.cited_info.values()) + if insert_under_root: + for info in info_to_insert: + self.insert_information(path=self.root.name, information=info) + else: + self.information_insert_module( + knowledge_base=self, + information=info_to_insert, + allow_create_new_node=allow_create_new_node, + ) + old_to_new_citation_idx_mapping = { + old_idx: info.citation_uuid + for old_idx, info in conv_turn.cited_info.items() + } + + for old_idx, new_idx in old_to_new_citation_idx_mapping.items(): + conv_turn.utterance = conv_turn.utterance.replace( + f"[{old_idx}]", f"[_{new_idx}_]" + ) + conv_turn.raw_utterance = conv_turn.raw_utterance.replace( + f"[{old_idx}]", f"[_{new_idx}_]" + ) + for _, new_idx in old_to_new_citation_idx_mapping.items(): + conv_turn.utterance = conv_turn.utterance.replace( + f"[_{new_idx}_]", f"[{new_idx}]" + ) + conv_turn.utterance.replace("[-1]", "") + conv_turn.raw_utterance = conv_turn.raw_utterance.replace( + f"[_{new_idx}_]", f"[{new_idx}]" + ) + conv_turn.raw_utterance.replace("[-1]", "") + conv_turn.cited_info = None + + def get_knowledge_base_summary(self): + return self.gen_summary_module(self) + + def reogranize(self): + # pre-processing + self.trim_empty_leaf_nodes() + self.merge_single_child_nodes() + # expand nodes + self.expand_node_module(knowledge_base=self) + # clean up + self.trim_empty_leaf_nodes() + self.merge_single_child_nodes() + self.update_all_info_path() + + def to_report(self): + return self.article_generation_module(knowledge_base=self) diff --git a/knowledge_storm/encoder.py b/knowledge_storm/encoder.py new file mode 100644 index 0000000..3d14e63 --- /dev/null +++ b/knowledge_storm/encoder.py @@ -0,0 +1,169 @@ +import requests +import os +from typing import List, Tuple, Union, Optional, Dict, Literal +import numpy as np + +from concurrent.futures import ThreadPoolExecutor, as_completed + + +class EmbeddingModel: + def __init__(): + pass + + def get_embedding(self, text: str) -> Tuple[np.ndarray, int]: + raise Exception("Not implemented") + + +class OpenAIEmbeddingModel(EmbeddingModel): + def __init__(self, model: str = "text-embedding-3-small", api_key: str = None): + if not api_key: + self.api_key = os.getenv("OPENAI_API_KEY") + + self.url = "https://api.openai.com/v1/embeddings" + self.headers = { + "Content-Type": "application/json", + "Authorization": f"Bearer {self.api_key}", + } + self.model = model + + def get_embedding(self, text: str) -> Tuple[np.ndarray, int]: + data = {"input": text, "model": "text-embedding-3-small"} + + response = requests.post(self.url, headers=self.headers, json=data) + if response.status_code == 200: + data = response.json() + embedding = np.array(data["data"][0]["embedding"]) + token = data["usage"]["prompt_tokens"] + return embedding, token + else: + response.raise_for_status() + + +class OpenAIEmbeddingModel(EmbeddingModel): + def __init__(self, model: str = "text-embedding-3-small", api_key: str = None): + if not api_key: + api_key = os.getenv("OPENAI_API_KEY") + + self.url = "https://api.openai.com/v1/embeddings" + self.headers = { + "Content-Type": "application/json", + "Authorization": f"Bearer {api_key}", + } + self.model = model + + def get_embedding(self, text: str) -> Tuple[np.ndarray, int]: + data = {"input": text, "model": self.model} + + response = requests.post(self.url, headers=self.headers, json=data) + if response.status_code == 200: + data = response.json() + embedding = np.array(data["data"][0]["embedding"]) + token = data["usage"]["prompt_tokens"] + return embedding, token + else: + response.raise_for_status() + + +class TogetherEmbeddingModel: + def __init__(self, model: str = "BAAI/bge-large-en-v1.5", api_key: str = None): + import together + + self.model = model + if not api_key: + api_key = os.getenv("TOGETHER_API_KEY") + self.together_client = together.Together(api_key=api_key) + + def get_embedding(self, text: str) -> Tuple[np.ndarray, int]: + response = self.together_client.embeddings.create(input=text, model=self.model) + return response.data[0].embedding, -1 + + +class AzureOpenAIEmbeddingModel: + def __init__(self, model: str = "text-embedding-3-small", api_key: str = None): + from openai import AzureOpenAI + + self.model = model + if not api_key: + api_key = os.getenv("AZURE_API_KEY") + + self.client = AzureOpenAI( + api_key=api_key, + api_version=os.getenv("AZURE_API_VERSION"), + azure_endpoint=os.getenv("AZURE_API_BASE"), + ) + + def get_embedding(self, text: str) -> Tuple[np.ndarray, int]: + response = self.client.embeddings.create(input=text, model=self.model) + + embedding = np.array(response.data[0].embedding) + token = response.usage.prompt_tokens + return embedding, token + + +def get_text_embeddings( + texts: Union[str, List[str]], + max_workers: int = 5, + embedding_cache: Optional[Dict[str, np.ndarray]] = None, +) -> Tuple[np.ndarray, int]: + """ + Get text embeddings using OpenAI's text-embedding-3-small model. + + Args: + texts (Union[str, List[str]]): A single text string or a list of text strings to embed. + max_workers (int): The maximum number of workers for parallel processing. + api_key (str): The API key for accessing OpenAI's services. + embedding_cache (Optional[Dict[str, np.ndarray]]): A cache to store previously computed embeddings. + + Returns: + Tuple[np.ndarray, int]: The 2D array of embeddings and the total token usage. + """ + embedding_model = None + encoder_type = os.getenv("ENCODER_API_TYPE") + if encoder_type and encoder_type == "openai": + embedding_model = OpenAIEmbeddingModel() + elif encoder_type and encoder_type == "azure": + embedding_model = AzureOpenAIEmbeddingModel() + elif encoder_type == encoder_type == "together": + embedding_model = TogetherEmbeddingModel() + else: + raise Exception( + "No valid encoder type is provided. Check /secrets.toml for the field ENCODER_API_TYPE" + ) + + def fetch_embedding(text: str) -> Tuple[str, np.ndarray, int]: + if embedding_cache is not None and text in embedding_cache: + return ( + text, + embedding_cache[text], + 0, + ) # Returning 0 tokens since no API call is made + embedding, token_usage = embedding_model.get_embedding(text) + return text, embedding, token_usage + + if isinstance(texts, str): + _, embedding, tokens = fetch_embedding(texts) + return np.array(embedding), tokens + + embeddings = [] + total_tokens = 0 + + with ThreadPoolExecutor(max_workers=max_workers) as executor: + futures = {executor.submit(fetch_embedding, text): text for text in texts} + + for future in as_completed(futures): + try: + text, embedding, tokens = future.result() + embeddings.append((text, embedding, tokens)) + total_tokens += tokens + except Exception as e: + print(f"An error occurred for text: {futures[future]}") + print(e) + + # Sort results to match the order of the input texts + embeddings.sort(key=lambda x: texts.index(x[0])) + if embedding_cache is not None: + for text, embedding, _ in embeddings: + embedding_cache[text] = embedding + embeddings = [result[1] for result in embeddings] + + return np.array(embeddings), total_tokens diff --git a/knowledge_storm/interface.py b/knowledge_storm/interface.py index f6c11bd..f50ebbe 100644 --- a/knowledge_storm/interface.py +++ b/knowledge_storm/interface.py @@ -1,27 +1,23 @@ +import concurrent.futures +import dspy import functools +import hashlib +import json import logging import time from abc import ABC, abstractmethod from collections import OrderedDict -from typing import Dict, List, Optional, Union +from typing import Dict, List, Optional, Union, TYPE_CHECKING + +from .utils import ArticleTextProcessing logging.basicConfig( level=logging.INFO, format="%(name)s : %(levelname)-8s : %(message)s" ) logger = logging.getLogger(__name__) - -class Information(ABC): - """Abstract base class to represent basic information. - - Attributes: - uuid (str): The unique identifier for the information. - meta (dict): The meta information associated with the information. - """ - - def __init__(self, uuid, meta={}): - self.uuid = uuid - self.meta = meta +if TYPE_CHECKING: + from .logging_wrapper import LoggingWrapper class InformationTable(ABC): @@ -42,6 +38,101 @@ def retrieve_information(**kwargs): pass +class Information: + """Class to represent detailed information. + + Inherits from Information to include a unique identifier (URL), and extends + it with a description, snippets, and title of the storm information. + + Attributes: + description (str): Brief description. + snippets (list): List of brief excerpts or snippets. + title (str): The title or headline of the information. + url (str): The unique URL (serving as UUID) of the information. + """ + + def __init__(self, url, description, snippets, title, meta=None): + """Initialize the Information object with detailed attributes. + + Args: + url (str): The unique URL serving as the identifier for the information. + description (str): Detailed description. + snippets (list): List of brief excerpts or snippet. + title (str): The title or headline of the information. + """ + self.description = description + self.snippets = snippets + self.title = title + self.url = url + self.meta = meta if meta is not None else {} + self.citation_uuid = -1 + + def __hash__(self): + return hash( + ( + self.url, + tuple(sorted(self.snippets)), + ) + ) + + def __eq__(self, other): + if not isinstance(other, Information): + return False + return ( + self.url == other.url + and set(self.snippets) == set(other.snippets) + and self._meta_str() == other._meta_str() + ) + + def __hash__(self): + return int( + self._md5_hash((self.url, tuple(sorted(self.snippets)), self._meta_str())), + 16, + ) + + def _meta_str(self): + """Generate a string representation of relevant meta information.""" + return f"Question: {self.meta.get('question', '')}, Query: {self.meta.get('query', '')}" + + def _md5_hash(self, value): + """Generate an MD5 hash for a given value.""" + if isinstance(value, (dict, list, tuple)): + value = json.dumps(value, sort_keys=True) + return hashlib.md5(str(value).encode("utf-8")).hexdigest() + + @classmethod + def from_dict(cls, info_dict): + """Create a Information object from a dictionary. + Usage: info = Information.from_dict(storm_info_dict) + + Args: + info_dict (dict): A dictionary containing keys 'url', 'description', + 'snippets', and 'title' corresponding to the object's attributes. + + Returns: + Information: An instance of Information. + """ + info = cls( + url=info_dict["url"], + description=info_dict["description"], + snippets=info_dict["snippets"], + title=info_dict["title"], + meta=info_dict.get("meta", None), + ) + info.citation_uuid = int(info_dict.get("citation_uuid", -1)) + return info + + def to_dict(self): + return { + "url": self.url, + "description": self.description, + "snippets": self.snippets, + "title": self.title, + "meta": self.meta, + "citation_uuid": self.citation_uuid, + } + + class ArticleSectionNode: """ The ArticleSectionNode is the dataclass for handling the section of the article. @@ -166,7 +257,7 @@ def prune_empty_nodes(self, node=None): return node -class Retriever(ABC): +class Retriever: """ An abstract base class for retriever modules. It provides a template for retrieving information based on a query. @@ -175,19 +266,14 @@ class Retriever(ABC): The retrieval model/search engine used for each part should be declared with a suffix '_rm' in the attribute name. """ - def __init__(self, search_top_k): - self.search_top_k = search_top_k - - def update_search_top_k(self, k): - self.search_top_k = k + def __init__(self, rm: dspy.Retrieve, max_thread: int = 1): + self.max_thread = max_thread + self.rm = rm def collect_and_reset_rm_usage(self): combined_usage = [] - for attr_name in self.__dict__: - if "_rm" in attr_name and hasattr( - getattr(self, attr_name), "get_usage_and_reset" - ): - combined_usage.append(getattr(self, attr_name).get_usage_and_reset()) + if hasattr(getattr(self, "rm"), "get_usage_and_reset"): + combined_usage.append(getattr(self, "rm").get_usage_and_reset()) name_to_usage = {} for usage in combined_usage: @@ -199,21 +285,38 @@ def collect_and_reset_rm_usage(self): return name_to_usage - @abstractmethod - def retrieve(self, query: Union[str, List[str]], **kwargs) -> List[Information]: - """ - Retrieves information based on a query. - - This method must be implemented by subclasses to specify how information is retrieved. - - Args: - query (Union[str, List[str]]): The query or list of queries to retrieve information for. - **kwargs: Additional keyword arguments that might be necessary for the retrieval process. - - Returns: - List[Information]: A list of Information objects retrieved based on the query. - """ - pass + def retrieve( + self, query: Union[str, List[str]], exclude_urls: List[str] = [] + ) -> List[Information]: + queries = query if isinstance(query, list) else [query] + to_return = [] + + def process_query(q): + retrieved_data_list = self.rm( + query_or_queries=[q], exclude_urls=exclude_urls + ) + local_to_return = [] + for data in retrieved_data_list: + for i in range(len(data["snippets"])): + # STORM generate the article with citations. We do not consider multi-hop citations. + # Remove citations in the source to avoid confusion. + data["snippets"][i] = ArticleTextProcessing.remove_citations( + data["snippets"][i] + ) + storm_info = Information.from_dict(data) + storm_info.meta["query"] = q + local_to_return.append(storm_info) + return local_to_return + + with concurrent.futures.ThreadPoolExecutor( + max_workers=self.max_thread + ) as executor: + results = list(executor.map(process_query, queries)) + + for result in results: + to_return.extend(result) + + return to_return class KnowledgeCurationModule(ABC): @@ -458,3 +561,27 @@ def reset(self): self.time = {} self.lm_cost = {} self.rm_cost = {} + + +class Agent(ABC): + from .dataclass import KnowledgeBase, ConversationTurn + + def __init__(self, topic: str, role_name: str, role_description: str): + self.topic = topic + self.role_name = role_name + self.role_description = role_description + + def get_role_description(self): + if self.role_description: + return f"{self.role_name}: {self.role_description}" + return self.role_name + + @abstractmethod + def generate_utterance( + self, + knowledge_base: KnowledgeBase, + conversation_history: List[ConversationTurn], + logging_wrapper: "LoggingWrapper", + **kwargs, + ): + pass diff --git a/knowledge_storm/lm.py b/knowledge_storm/lm.py index 2c0773d..0cae49b 100644 --- a/knowledge_storm/lm.py +++ b/knowledge_storm/lm.py @@ -24,7 +24,7 @@ class OpenAIModel(dspy.OpenAI): def __init__( self, - model: str = "gpt-3.5-turbo-instruct", + model: str = "gpt-4o-mini", api_key: Optional[str] = None, model_type: Literal["chat", "text"] = None, **kwargs, @@ -211,7 +211,7 @@ def __init__( self, api_base: Optional[str] = None, api_version: Optional[str] = None, - model: str = "gpt-3.5-turbo-instruct", + model: str = "gpt-4o-mini", api_key: Optional[str] = None, model_type: Literal["chat", "text"] = "chat", **kwargs, @@ -674,21 +674,28 @@ class TogetherClient(dspy.HFModel): def __init__( self, model, + api_key: Optional[str] = None, apply_tokenizer_chat_template=False, hf_tokenizer_name=None, + model_type: Literal["chat", "text"] = "chat", **kwargs, ): """Copied from dspy/dsp/modules/hf_client.py with the support of applying tokenizer chat template.""" super().__init__(model=model, is_client=True) self.session = requests.Session() - self.api_base = ( - "https://api.together.xyz/v1/completions" - if os.getenv("TOGETHER_API_BASE") is None - else os.getenv("TOGETHER_API_BASE") + self.api_key = api_key = ( + os.environ.get("TOGETHER_API_KEY") if api_key is None else api_key ) - self.token = os.getenv("TOGETHER_API_KEY") self.model = model + self.model_type = model_type + if os.getenv("TOGETHER_API_BASE") is None: + if self.model_type == "chat": + self.api_base = "https://api.together.xyz/v1/chat/completions" + else: + self.api_base = "https://api.together.xyz/v1/completions" + else: + self.api_base = os.getenv("TOGETHER_API_BASE") # self.use_inst_template = False # if any(keyword in self.model.lower() for keyword in ["inst", "instruct"]): @@ -705,12 +712,12 @@ def __init__( stop_default = "\n\n---" self.kwargs = { - "temperature": 0.0, - "max_tokens": 512, - "top_p": 1, - "top_k": 20, + "temperature": kwargs.get("temperature", 0.0), + "max_tokens": min(kwargs.get("max_tokens", 4096), 4096), + "top_p": kwargs.get("top_p", 1.0), + "top_k": kwargs.get("top_k", 1), "repetition_penalty": 1, - "n": 1, + "n": kwargs.pop("n", kwargs.pop("num_generations", 1)), "stop": stop_default if "stop" not in kwargs else kwargs["stop"], **kwargs, } @@ -745,9 +752,7 @@ def get_usage_and_reset(self): max_time=1000, on_backoff=backoff_hdlr, ) - def _generate(self, prompt, use_chat_api=False, **kwargs): - url = f"{self.api_base}" - + def _generate(self, prompt, **kwargs): kwargs = {**self.kwargs, **kwargs} stop = kwargs.get("stop") @@ -762,8 +767,7 @@ def _generate(self, prompt, use_chat_api=False, **kwargs): ) # prompt = f"[INST]{prompt}[/INST]" if self.use_inst_template else prompt - if use_chat_api: - url = f"{self.api_base}/chat/completions" + if self.model_type == "chat": messages = [ { "role": "system", @@ -793,13 +797,13 @@ def _generate(self, prompt, use_chat_api=False, **kwargs): "stop": stop, } - headers = {"Authorization": f"Bearer {self.token}"} + headers = {"Authorization": f"Bearer {self.api_key}"} - with self.session.post(url, headers=headers, json=body) as resp: + with self.session.post(self.api_base, headers=headers, json=body) as resp: resp_json = resp.json() # Log the token usage from the Together API response. self.log_usage(resp_json) - if use_chat_api: + if self.model_type == "chat": # completions = [resp_json['output'].get('choices', [])[0].get('message', {}).get('content', "")] completions = [ resp_json.get("choices", [])[0] diff --git a/knowledge_storm/logging_wrapper.py b/knowledge_storm/logging_wrapper.py new file mode 100644 index 0000000..48d7e29 --- /dev/null +++ b/knowledge_storm/logging_wrapper.py @@ -0,0 +1,212 @@ +from contextlib import contextmanager +import time +import pytz +from datetime import datetime + +# Define California timezone +CALIFORNIA_TZ = pytz.timezone("America/Los_Angeles") + + +class EventLog: + def __init__(self, event_name): + self.event_name = event_name + self.start_time = None + self.end_time = None + self.child_events = {} + + def record_start_time(self): + self.start_time = datetime.now( + pytz.utc + ) # Store in UTC for consistent timezone conversion + + def record_end_time(self): + self.end_time = datetime.now( + pytz.utc + ) # Store in UTC for consistent timezone conversion + + def get_total_time(self): + if self.start_time and self.end_time: + return (self.end_time - self.start_time).total_seconds() + return 0 + + def get_start_time(self): + if self.start_time: + # Format to milliseconds + return self.start_time.astimezone(CALIFORNIA_TZ).strftime( + "%Y-%m-%d %H:%M:%S.%f" + )[:-3] + return None + + def get_end_time(self): + if self.end_time: + # Format to milliseconds + return self.end_time.astimezone(CALIFORNIA_TZ).strftime( + "%Y-%m-%d %H:%M:%S.%f" + )[:-3] + return None + + def add_child_event(self, child_event): + self.child_events[child_event.event_name] = child_event + + def get_child_events(self): + return self.child_events + + +class LoggingWrapper: + def __init__(self, lm_config): + self.logging_dict = {} + self.lm_config = lm_config + self.current_pipeline_stage = None + self.event_stack = [] + self.pipeline_stage_active = False + + def _pipeline_stage_start(self, pipeline_stage: str): + if self.pipeline_stage_active: + raise RuntimeError( + "A pipeline stage is already active. End the current stage before starting a new one." + ) + + self.current_pipeline_stage = pipeline_stage + self.logging_dict[pipeline_stage] = { + "time_usage": {}, + "lm_usage": {}, + "lm_history": [], + "query_count": 0, + } + self.pipeline_stage_active = True + + def _event_start(self, event_name: str): + if not self.pipeline_stage_active: + raise RuntimeError("No pipeline stage is currently active.") + + if not self.event_stack and self.current_pipeline_stage: + # Top-level event (directly under the pipeline stage) + if ( + event_name + not in self.logging_dict[self.current_pipeline_stage]["time_usage"] + ): + event = EventLog(event_name=event_name) + event.record_start_time() + self.logging_dict[self.current_pipeline_stage]["time_usage"][ + event_name + ] = event + self.event_stack.append(event) + else: + self.logging_dict[self.current_pipeline_stage]["time_usage"][ + event_name + ].record_start_time() + elif self.event_stack: + # Nested event (under another event) + parent_event = self.event_stack[-1] + if event_name not in parent_event.get_child_events(): + event = EventLog(event_name=event_name) + event.record_start_time() + parent_event.add_child_event(event) + self.logging_dict[self.current_pipeline_stage]["time_usage"][ + event_name + ] = event + self.event_stack.append(event) + else: + parent_event.get_child_events()[event_name].record_start_time() + else: + raise RuntimeError( + "Cannot start an event without an active pipeline stage or parent event." + ) + + def _event_end(self, event_name: str): + if not self.pipeline_stage_active: + raise RuntimeError("No pipeline stage is currently active.") + + if not self.event_stack: + raise RuntimeError("No parent event is currently active.") + + if self.event_stack: + current_event_log = self.event_stack[-1] + if event_name in current_event_log.get_child_events(): + current_event_log.get_child_events()[event_name].record_end_time() + elif ( + event_name + in self.logging_dict[self.current_pipeline_stage]["time_usage"] + ): + self.logging_dict[self.current_pipeline_stage]["time_usage"][ + event_name + ].record_end_time() + else: + raise AssertionError( + f"Failure to record end time for event {event_name}. Start time is not recorded." + ) + if current_event_log.event_name == event_name: + self.event_stack.pop() + else: + raise RuntimeError("Cannot end an event without an active parent event.") + + def _pipeline_stage_end(self): + if not self.pipeline_stage_active: + raise RuntimeError("No pipeline stage is currently active to end.") + + self.logging_dict[self.current_pipeline_stage][ + "lm_usage" + ] = self.lm_config.collect_and_reset_lm_usage() + self.logging_dict[self.current_pipeline_stage][ + "lm_history" + ] = self.lm_config.collect_and_reset_lm_history() + self.pipeline_stage_active = False + + def add_query_count(self, count): + if not self.pipeline_stage_active: + raise RuntimeError( + "No pipeline stage is currently active to add query count." + ) + + self.logging_dict[self.current_pipeline_stage]["query_count"] += count + + @contextmanager + def log_event(self, event_name): + if not self.pipeline_stage_active: + raise RuntimeError("No pipeline stage is currently active.") + + self._event_start(event_name) + yield + self._event_end(event_name) + + @contextmanager + def log_pipeline_stage(self, pipeline_stage): + if self.pipeline_stage_active: + print( + "A pipeline stage is already active, ending the current stage safely." + ) + self._pipeline_stage_end() + + start_time = time.time() + try: + self._pipeline_stage_start(pipeline_stage) + yield + except Exception as e: + print(f"Error occurred during pipeline stage '{pipeline_stage}': {e}") + finally: + self.logging_dict[self.current_pipeline_stage]["total_wall_time"] = ( + time.time() - start_time + ) + self._pipeline_stage_end() + + def dump_logging_and_reset(self, reset_logging=True): + log_dump = {} + for pipeline_stage, pipeline_log in self.logging_dict.items(): + time_stamp_log = { + event_name: { + "total_time_seconds": event.get_total_time(), + "start_time": event.get_start_time(), + "end_time": event.get_end_time(), + } + for event_name, event in pipeline_log["time_usage"].items() + } + log_dump[pipeline_stage] = { + "time_usage": time_stamp_log, + "lm_usage": pipeline_log["lm_usage"], + "lm_history": pipeline_log["lm_history"], + "query_count": pipeline_log["query_count"], + "total_wall_time": pipeline_log["total_wall_time"], + } + if reset_logging: + self.logging_dict.clear() + return log_dump diff --git a/knowledge_storm/rm.py b/knowledge_storm/rm.py index 80b8a38..d023d4a 100644 --- a/knowledge_storm/rm.py +++ b/knowledge_storm/rm.py @@ -333,10 +333,77 @@ def forward(self, query_or_queries: Union[str, List[str]], exclude_urls: List[st return collected_results +class StanfordOvalArxivRM(dspy.Retrieve): + def __init__(self, endpoint, k=3): + super().__init__(k=k) + self.endpoint = endpoint + self.usage = 0 + + def get_usage_and_reset(self): + usage = self.usage + self.usage = 0 + + return {"CS224vArxivRM": usage} + + def _retrieve(self, query: str): + payload = {"query": query, "num_blocks": self.k} + + response = requests.post( + self.endpoint, json=payload, headers={"Content-Type": "application/json"} + ) + + # Check if the request was successful + if response.status_code == 200: + data = response.json()[0] + results = [] + for i in range(len(data["title"])): + result = { + "title": data["title"][i], + "url": data["title"][i], + "snippets": [data["text"][i]], + "description": "N/A", + "meta": {"section_title": data["full_section_title"][i]}, + } + results.append(result) + + return results + else: + raise Exception( + f"Error: Unable to retrieve results. Status code: {response.status_code}" + ) + + def forward( + self, query_or_queries: Union[str, List[str]], exclude_urls: List[str] = [] + ): + collected_results = [] + queries = ( + [query_or_queries] + if isinstance(query_or_queries, str) + else query_or_queries + ) + + for query in queries: + try: + results = self._retrieve(query) + collected_results.extend(results) + except Exception as e: + logging.error(f"Error occurs when searching query {query}: {e}") + return collected_results + + class SerperRM(dspy.Retrieve): """Retrieve information from custom queries using Serper.dev.""" - def __init__(self, serper_search_api_key=None, query_params=None): + def __init__( + self, + serper_search_api_key=None, + k=3, + query_params=None, + ENABLE_EXTRA_SNIPPET_EXTRACTION=False, + min_char_count: int = 150, + snippet_chunk_size: int = 1000, + webpage_helper_max_threads=10, + ): """Args: serper_search_api_key str: API key to run serper, can be found by creating an account on https://serper.dev/ query_params (dict or list of dict): parameters in dictionary or list of dictionaries that has a max size of 100 that will be used to query. @@ -355,9 +422,21 @@ def __init__(self, serper_search_api_key=None, query_params=None): qdr:m str: Date time range for past month. qdr:y str: Date time range for past year. """ - super().__init__() + super().__init__(k=k) self.usage = 0 - self.query_params = query_params + self.query_params = None + self.ENABLE_EXTRA_SNIPPET_EXTRACTION = ENABLE_EXTRA_SNIPPET_EXTRACTION + self.webpage_helper = WebPageHelper( + min_char_count=min_char_count, + snippet_chunk_size=snippet_chunk_size, + max_thread_num=webpage_helper_max_threads, + ) + + if query_params is None: + self.query_params = {"num": k, "autocorrect": True, "page": 1} + else: + self.query_params = query_params + self.query_params.update({"num": k}) self.serper_search_api_key = serper_search_api_key if not self.serper_search_api_key and not os.environ.get("SERPER_API_KEY"): raise RuntimeError( @@ -386,7 +465,7 @@ def serper_runner(self, query_params): if response == None: raise RuntimeError( - f"Error had occurred while running the search process.\n Error is {response.reason}, had failed with status code {response.status_code}" + f"Error had occured while running the search process.\n Error is {response.reason}, had failed with status code {response.status_code}" ) return response.json() @@ -435,34 +514,41 @@ def forward(self, query_or_queries: Union[str, List[str]], exclude_urls: List[st # Array of dictionaries that will be used by Storm to create the jsons collected_results = [] + if self.ENABLE_EXTRA_SNIPPET_EXTRACTION: + urls = [] + for result in self.results: + organic_results = result.get("organic", []) + for organic in organic_results: + url = organic.get("link") + if url: + urls.append(url) + valid_url_to_snippets = self.webpage_helper.urls_to_snippets(urls) + else: + valid_url_to_snippets = {} + for result in self.results: try: # An array of dictionaries that contains the snippets, title of the document and url that will be used. organic_results = result.get("organic") - knowledge_graph = result.get("knowledgeGraph") for organic in organic_results: - snippets = [] - snippets.append(organic.get("snippet")) - if knowledge_graph != None: - collected_results.append( - { - "snippets": snippets, - "title": organic.get("title"), - "url": organic.get("link"), - "description": knowledge_graph.get("description"), - } - ) - else: - # Common for knowledge graph to be None, set description to empty string - collected_results.append( - { - "snippets": snippets, - "title": organic.get("title"), - "url": organic.get("link"), - "description": "", - } + snippets = [organic.get("snippet")] + if self.ENABLE_EXTRA_SNIPPET_EXTRACTION: + snippets.extend( + valid_url_to_snippets.get(url, {}).get("snippets", []) ) + collected_results.append( + { + "snippets": snippets, + "title": organic.get("title"), + "url": organic.get("link"), + "description": ( + knowledge_graph.get("description") + if knowledge_graph is not None + else "" + ), + } + ) except: continue diff --git a/knowledge_storm/storm_wiki/engine.py b/knowledge_storm/storm_wiki/engine.py index de9f5f1..62887a2 100644 --- a/knowledge_storm/storm_wiki/engine.py +++ b/knowledge_storm/storm_wiki/engine.py @@ -12,10 +12,9 @@ from .modules.knowledge_curation import StormKnowledgeCurationModule from .modules.outline_generation import StormOutlineGenerationModule from .modules.persona_generator import StormPersonaGenerator -from .modules.retriever import StormRetriever from .modules.storm_dataclass import StormInformationTable, StormArticle -from ..interface import Engine, LMConfigs -from ..lm import OpenAIModel +from ..interface import Engine, LMConfigs, Retriever +from ..lm import OpenAIModel, AzureOpenAIModel from ..utils import FileIOHelper, makeStringRed, truncate_filename @@ -39,6 +38,7 @@ def __init__(self): def init_openai_model( self, openai_api_key: str, + azure_api_key: str, openai_type: Literal["openai", "azure"], api_base: Optional[str] = None, api_version: Optional[str] = None, @@ -46,19 +46,27 @@ def init_openai_model( top_p: Optional[float] = 0.9, ): """Legacy: Corresponding to the original setup in the NAACL'24 paper.""" + azure_kwargs = { + "api_key": azure_api_key, + "temperature": temperature, + "top_p": top_p, + "api_base": api_base, + "api_version": api_version, + } + openai_kwargs = { "api_key": openai_api_key, - "api_provider": openai_type, + "api_provider": "openai", "temperature": temperature, "top_p": top_p, "api_base": None, } if openai_type and openai_type == "openai": self.conv_simulator_lm = OpenAIModel( - model="gpt-3.5-turbo-instruct", max_tokens=500, **openai_kwargs + model="gpt-4o-mini-2024-07-18", max_tokens=500, **openai_kwargs ) self.question_asker_lm = OpenAIModel( - model="gpt-3.5-turbo", max_tokens=500, **openai_kwargs + model="gpt-4o-mini-2024-07-18", max_tokens=500, **openai_kwargs ) # 1/12/2024: Update gpt-4 to gpt-4-1106-preview. (Currently keep the original setup when using azure.) self.outline_gen_lm = OpenAIModel( @@ -70,6 +78,32 @@ def init_openai_model( self.article_polish_lm = OpenAIModel( model="gpt-4o-2024-05-13", max_tokens=4000, **openai_kwargs ) + elif openai_type and openai_type == "azure": + self.conv_simulator_lm = OpenAIModel( + model="gpt-4o-mini-2024-07-18", max_tokens=500, **openai_kwargs + ) + self.question_asker_lm = AzureOpenAIModel( + model="gpt-4o-mini-2024-07-18", + max_tokens=500, + **azure_kwargs, + model_type="chat", + ) + # use combination of openai and azure-openai as azure-openai does not support gpt-4 in standard deployment + self.outline_gen_lm = AzureOpenAIModel( + model="gpt-4o", max_tokens=400, **azure_kwargs, model_type="chat" + ) + self.article_gen_lm = AzureOpenAIModel( + model="gpt-4o-mini-2024-07-18", + max_tokens=700, + **azure_kwargs, + model_type="chat", + ) + self.article_polish_lm = AzureOpenAIModel( + model="gpt-4o-mini-2024-07-18", + max_tokens=4000, + **azure_kwargs, + model_type="chat", + ) else: logging.warning( "No valid OpenAI API provider is provided. Cannot use default LLM configurations." @@ -145,7 +179,7 @@ def __init__( self.args = args self.lm_configs = lm_configs - self.retriever = StormRetriever(rm=rm, k=self.args.retrieve_top_k) + self.retriever = Retriever(rm=rm, max_thread=self.args.max_thread_num) storm_persona_generator = StormPersonaGenerator( self.lm_configs.question_asker_lm ) diff --git a/knowledge_storm/storm_wiki/modules/article_generation.py b/knowledge_storm/storm_wiki/modules/article_generation.py index 2e71146..a23b788 100644 --- a/knowledge_storm/storm_wiki/modules/article_generation.py +++ b/knowledge_storm/storm_wiki/modules/article_generation.py @@ -7,8 +7,8 @@ import dspy from .callback import BaseCallbackHandler -from .storm_dataclass import StormInformationTable, StormArticle, StormInformation -from ...interface import ArticleGenerationModule +from .storm_dataclass import StormInformationTable, StormArticle +from ...interface import ArticleGenerationModule, Information from ...utils import ArticleTextProcessing @@ -33,7 +33,7 @@ def __init__( def generate_section( self, topic, section_name, information_table, section_outline, section_query ): - collected_info: List[StormInformation] = [] + collected_info: List[Information] = [] if information_table is not None: collected_info = information_table.retrieve_information( queries=section_query, search_top_k=self.retrieve_top_k @@ -143,11 +143,7 @@ def __init__(self, engine: Union[dspy.dsp.LM, dspy.dsp.HFModel]): self.engine = engine def forward( - self, - topic: str, - outline: str, - section: str, - collected_info: List[StormInformation], + self, topic: str, outline: str, section: str, collected_info: List[Information] ): info = "" for idx, storm_info in enumerate(collected_info): diff --git a/knowledge_storm/storm_wiki/modules/knowledge_curation.py b/knowledge_storm/storm_wiki/modules/knowledge_curation.py index bde2767..ca6377d 100644 --- a/knowledge_storm/storm_wiki/modules/knowledge_curation.py +++ b/knowledge_storm/storm_wiki/modules/knowledge_curation.py @@ -8,8 +8,8 @@ from .callback import BaseCallbackHandler from .persona_generator import StormPersonaGenerator -from .storm_dataclass import DialogueTurn, StormInformationTable, StormInformation -from ...interface import KnowledgeCurationModule, Retriever +from .storm_dataclass import DialogueTurn, StormInformationTable +from ...interface import KnowledgeCurationModule, Retriever, Information from ...utils import ArticleTextProcessing try: @@ -196,14 +196,13 @@ def __init__( super().__init__() self.generate_queries = dspy.Predict(QuestionToQuery) self.retriever = retriever - self.retriever.update_search_top_k(search_top_k) self.answer_question = dspy.Predict(AnswerQuestion) self.engine = engine self.max_search_queries = max_search_queries self.search_top_k = search_top_k def forward(self, topic: str, question: str, ground_truth_url: str): - with dspy.settings.context(lm=self.engine): + with dspy.settings.context(lm=self.engine, show_guidelines=False): # Identify: Break down question into queries. queries = self.generate_queries(topic=topic, question=question).queries queries = [ @@ -212,7 +211,7 @@ def forward(self, topic: str, question: str, ground_truth_url: str): ] queries = queries[: self.max_search_queries] # Search - searched_results: List[StormInformation] = self.retriever.retrieve( + searched_results: List[Information] = self.retriever.retrieve( list(set(queries)), exclude_urls=[ground_truth_url] ) if len(searched_results) > 0: diff --git a/knowledge_storm/storm_wiki/modules/retriever.py b/knowledge_storm/storm_wiki/modules/retriever.py index 85df63e..691382b 100644 --- a/knowledge_storm/storm_wiki/modules/retriever.py +++ b/knowledge_storm/storm_wiki/modules/retriever.py @@ -3,7 +3,6 @@ import dspy -from .storm_dataclass import StormInformation from ...interface import Retriever, Information from ...utils import ArticleTextProcessing @@ -232,26 +231,3 @@ def is_valid_wikipedia_source(url): return False return True - - -class StormRetriever(Retriever): - def __init__(self, rm: dspy.Retrieve, k=3): - super().__init__(search_top_k=k) - self._rm = rm - if hasattr(rm, "is_valid_source"): - rm.is_valid_source = is_valid_wikipedia_source - - def retrieve( - self, query: Union[str, List[str]], exclude_urls: List[str] = [] - ) -> List[Information]: - retrieved_data_list = self._rm( - query_or_queries=query, exclude_urls=exclude_urls - ) - for data in retrieved_data_list: - for i in range(len(data["snippets"])): - # STORM generate the article with citations. We do not consider multi-hop citations. - # Remove citations in the source to avoid confusion. - data["snippets"][i] = ArticleTextProcessing.remove_citations( - data["snippets"][i] - ) - return [StormInformation.from_dict(data) for data in retrieved_data_list] diff --git a/knowledge_storm/storm_wiki/modules/storm_dataclass.py b/knowledge_storm/storm_wiki/modules/storm_dataclass.py index 43826ec..75812d9 100644 --- a/knowledge_storm/storm_wiki/modules/storm_dataclass.py +++ b/knowledge_storm/storm_wiki/modules/storm_dataclass.py @@ -11,69 +11,13 @@ from ...utils import ArticleTextProcessing, FileIOHelper -class StormInformation(Information): - """Class to represent detailed information. - - Inherits from Information to include a unique identifier (URL), and extends - it with a description, snippets, and title of the storm information. - - Attributes: - description (str): Brief description. - snippets (list): List of brief excerpts or snippets. - title (str): The title or headline of the information. - url (str): The unique URL (serving as UUID) of the information. - """ - - def __init__(self, uuid, description, snippets, title): - """Initialize the StormInformation object with detailed attributes. - - Args: - uuid (str): The unique URL serving as the identifier for the information. - description (str): Detailed description. - snippets (list): List of brief excerpts or snippet. - title (str): The title or headline of the information. - """ - super().__init__(uuid=uuid, meta={}) - self.description = description - self.snippets = snippets - self.title = title - self.url = self.uuid - - @classmethod - def from_dict(cls, info_dict): - """Create a StormInformation object from a dictionary. - Usage: storm_info = StormInformation.from_dict(storm_info_dict) - - Args: - info_dict (dict): A dictionary containing keys 'uuid', 'description', - 'snippets', and 'title' corresponding to the object's attributes. - - Returns: - StormInformation: An instance of StormInformation. - """ - return cls( - info_dict["url"], - info_dict["description"], - info_dict["snippets"], - info_dict["title"], - ) - - def to_dict(self): - return { - "url": self.uuid, - "description": self.description, - "snippets": self.snippets, - "title": self.title, - } - - class DialogueTurn: def __init__( self, agent_utterance: str = None, user_utterance: str = None, search_queries: Optional[List[str]] = None, - search_results: Optional[List[Union[StormInformation, Dict]]] = None, + search_results: Optional[List[Union[Information, Dict]]] = None, ): self.agent_utterance = agent_utterance self.user_utterance = user_utterance @@ -83,7 +27,7 @@ def __init__( if self.search_results: for idx in range(len(self.search_results)): if type(self.search_results[idx]) == dict: - self.search_results[idx] = StormInformation.from_dict( + self.search_results[idx] = Information.from_dict( self.search_results[idx] ) @@ -91,7 +35,6 @@ def log(self): """ Returns a json object that contains all information inside `self` """ - return OrderedDict( { "agent_utterance": self.agent_utterance, @@ -115,14 +58,14 @@ class StormInformationTable(InformationTable): def __init__(self, conversations=List[Tuple[str, List[DialogueTurn]]]): super().__init__() self.conversations = conversations - self.url_to_info: Dict[str, StormInformation] = ( + self.url_to_info: Dict[str, Information] = ( StormInformationTable.construct_url_to_info(self.conversations) ) @staticmethod def construct_url_to_info( conversations: List[Tuple[str, List[DialogueTurn]]] - ) -> Dict[str, StormInformation]: + ) -> Dict[str, Information]: url_to_info = {} for persona, conv in conversations: @@ -177,7 +120,7 @@ def prepare_table_for_retrieval(self): def retrieve_information( self, queries: Union[List[str], str], search_top_k - ) -> List[StormInformation]: + ) -> List[Information]: selected_urls = [] selected_snippets = [] if type(queries) is str: @@ -231,13 +174,13 @@ def find_section( return None def _merge_new_info_to_references( - self, new_info_list: List[StormInformation], index_to_keep=None + self, new_info_list: List[Information], index_to_keep=None ) -> Dict[int, int]: """ Merges new storm information into existing references and updates the citation index mapping. Args: - new_info_list (List[StormInformation]): A list of dictionaries representing new storm information. + new_info_list (List[Information]): A list of dictionaries representing new storm information. index_to_keep (List[int]): A list of index of the new_info_list to keep. If none, keep all. Returns: @@ -308,7 +251,7 @@ def insert_or_create_section( def update_section( self, current_section_content: str, - current_section_info_list: List[StormInformation], + current_section_info_list: List[Information], parent_section_name: Optional[str] = None, ) -> Optional[ArticleSectionNode]: """ @@ -552,7 +495,7 @@ def from_string(cls, topic_name: str, article_text: str, references: dict): article = cls(topic_name=topic_name) article.insert_or_create_section(article_dict=article_dict) for url in list(references["url_to_info"]): - references["url_to_info"][url] = StormInformation.from_dict( + references["url_to_info"][url] = Information.from_dict( references["url_to_info"][url] ) article.reference = references From 6a6ae49ff96255b10376eb5c1d6d8e58b92e0934 Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Tue, 24 Sep 2024 21:39:40 -0700 Subject: [PATCH 03/19] update article polish dspy config to be more robust and compatible with more lm --- knowledge_storm/storm_wiki/modules/article_polish.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/knowledge_storm/storm_wiki/modules/article_polish.py b/knowledge_storm/storm_wiki/modules/article_polish.py index fb85b0f..85c8daa 100644 --- a/knowledge_storm/storm_wiki/modules/article_polish.py +++ b/knowledge_storm/storm_wiki/modules/article_polish.py @@ -85,14 +85,14 @@ def __init__( self.polish_page = dspy.Predict(PolishPage) def forward(self, topic: str, draft_page: str, polish_whole_page: bool = True): - with dspy.settings.context(lm=self.write_lead_engine): + with dspy.settings.context(lm=self.write_lead_engine, show_guidelines=False): lead_section = self.write_lead( topic=topic, draft_page=draft_page ).lead_section if "The lead section:" in lead_section: lead_section = lead_section.split("The lead section:")[1].strip() if polish_whole_page: - with dspy.settings.context(lm=self.polish_engine): + with dspy.settings.context(lm=self.polish_engine, show_guidelines=False): page = self.polish_page(draft_page=draft_page).page else: page = draft_page From bb9c89136c2821ab53744b762e2643b8f8565fb2 Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Tue, 24 Sep 2024 21:40:00 -0700 Subject: [PATCH 04/19] update storm question answering module to be more compatible with additional lm --- knowledge_storm/storm_wiki/modules/knowledge_curation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/knowledge_storm/storm_wiki/modules/knowledge_curation.py b/knowledge_storm/storm_wiki/modules/knowledge_curation.py index ca6377d..d6b8929 100644 --- a/knowledge_storm/storm_wiki/modules/knowledge_curation.py +++ b/knowledge_storm/storm_wiki/modules/knowledge_curation.py @@ -166,7 +166,7 @@ class QuestionToQuery(dspy.Signature): class AnswerQuestion(dspy.Signature): """You are an expert who can use information effectively. You are chatting with a Wikipedia writer who wants to write a Wikipedia page on topic you know. You have gathered the related information and will now use the information to form a response. - Make your response as informative as possible and make sure every sentence is supported by the gathered information. If [Gathered information] is not related to he [Topic] and [Question], output "Sorry, I don't have enough information to answer the question.". + Make your response as informative as possible, ensuring that every sentence is supported by the gathered information. If the [gathered information] is not directly related to the [topic] or [question], provide the most relevant answer based on the available information. If no appropriate answer can be formulated, respond with, “I cannot answer this question based on the available information,” and explain any limitations or gaps. """ topic = dspy.InputField(prefix="Topic you are discussing about:", format=str) From 9da20a8569a136c34dbbbead86293d1f6f773aab Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Tue, 24 Sep 2024 21:40:13 -0700 Subject: [PATCH 05/19] update in utils --- knowledge_storm/utils.py | 110 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 102 insertions(+), 8 deletions(-) diff --git a/knowledge_storm/utils.py b/knowledge_storm/utils.py index 1749609..2e3cbb6 100644 --- a/knowledge_storm/utils.py +++ b/knowledge_storm/utils.py @@ -4,7 +4,9 @@ import os import pickle import re +import regex import sys +import time from typing import List, Dict import httpx @@ -18,6 +20,8 @@ from tqdm import tqdm from trafilatura import extract +from .lm import OpenAIModel + logging.getLogger("httpx").setLevel(logging.WARNING) # Disable INFO logging for httpx. @@ -415,12 +419,14 @@ def deduplicate_group(match): @staticmethod def clean_up_citation(conv): for turn in conv.dlg_history: - turn.agent_utterance = turn.agent_utterance[ - : turn.agent_utterance.find("References:") - ] - turn.agent_utterance = turn.agent_utterance[ - : turn.agent_utterance.find("Sources:") - ] + if "References:" in turn.agent_utterance: + turn.agent_utterance = turn.agent_utterance[ + : turn.agent_utterance.find("References:") + ] + if "Sources:" in turn.agent_utterance: + turn.agent_utterance = turn.agent_utterance[ + : turn.agent_utterance.find("Sources:") + ] turn.agent_utterance = turn.agent_utterance.replace("Answer:", "").strip() try: max_ref_num = max( @@ -484,7 +490,8 @@ def clean_up_outline(outline, topic=""): outline = re.sub(r"#[#]? Summary.*?(?=##|$)", "", outline, flags=re.DOTALL) outline = re.sub(r"#[#]? Appendices.*?(?=##|$)", "", outline, flags=re.DOTALL) outline = re.sub(r"#[#]? Appendix.*?(?=##|$)", "", outline, flags=re.DOTALL) - + # clean up citation in outline + outline = re.sub(r"\[.*?\]", "", outline) return outline @staticmethod @@ -519,7 +526,8 @@ def clean_up_section(text): continue output_paragraphs.append(p) - return "\n\n".join(output_paragraphs) # Join with '\n\n' for markdown format. + # Join with '\n\n' for markdown format. + return "\n\n".join(output_paragraphs) @staticmethod def update_citation_index(s, citation_map): @@ -693,3 +701,89 @@ def urls_to_snippets(self, urls: List[str]) -> Dict: articles[u]["snippets"] = self.text_splitter.split_text(articles[u]["text"]) return articles + + +def user_input_appropriateness_check(user_input): + my_openai_model = OpenAIModel( + api_key=os.getenv("OPENAI_API_KEY"), + api_provider="openai", + model="gpt-4o-mini-2024-07-18", + max_tokens=10, + temperature=0.0, + top_p=0.9, + ) + + if len(user_input.split()) > 20: + return "The input is too long. Please make your input topic more concise!" + + if not re.match(r'^[a-zA-Z0-9\s\-"\,\.?\']*$', user_input): + return "The input contains invalid characters. The input should only contain a-z, A-Z, 0-9, space, -/\"/,./?/'." + + prompt = f"""Here is a topic input into a knowledge curation engine that can write a Wikipedia-like article for the topic. Please judge whether it is appropriate or not for the engine to curate information for this topic based on English search engine. The following types of inputs are inappropriate: +1. Inputs that may be related to illegal, harmful, violent, racist, or sexual purposes. +2. Inputs that are given using languages other than English. Currently, the engine can only support English. +3. Inputs that are related to personal experience or personal information. Currently, the engine can only use information from the search engine. +4. Inputs that are not aimed at topic research or inquiry. For example, asks requiring detailed execution, such as calculations, programming, or specific service searches fall outside the engine's scope of capabilities. +If the topic is appropriate for the engine to process, output "Yes."; otherwise, output "No. The input violates reason [1/2/3/4]". +User input: {user_input}""" + reject_reason_info = { + 1: "Sorry, this input may be related to sensitive topics. Please try another topic. " + "(Our input filtering uses OpenAI GPT-4o-mini, which may result in false positives. " + "We apologize for any inconvenience.)", + 2: "Sorry, the current engine can only support English. Please try another topic. " + "(Our input filtering uses OpenAI GPT-4o-mini, which may result in false positives. " + "We apologize for any inconvenience.)", + 3: "Sorry, the current engine cannot process topics related to personal experience. Please try another topic. " + "(Our input filtering uses OpenAI GPT-4o-mini, which may result in false positives. " + "We apologize for any inconvenience.)", + 4: "Sorry, STORM cannot follow arbitrary instruction. Please input a topic you want to learn about. " + "(Our input filtering uses OpenAI GPT-4o-mini, which may result in false positives. " + "We apologize for any inconvenience.)", + } + + try: + response = my_openai_model(prompt)[0].replace("[", "").replace("]", "") + if response.startswith("No"): + match = regex.search(r"reason\s(\d+)", response) + if match: + reject_reason = int(match.group(1)) + if reject_reason in reject_reason_info: + return reject_reason_info[reject_reason] + else: + return ( + "Sorry, the input is inappropriate. Please try another topic!" + ) + return "Sorry, the input is inappropriate. Please try another topic!" + + except Exception as e: + return "Sorry, the input is inappropriate. Please try another topic!" + return "Approved" + + +def purpose_appropriateness_check(user_input): + my_openai_model = OpenAIModel( + api_key=os.getenv("OPENAI_API_KEY"), + api_provider="openai", + model="gpt-4o-mini-2024-07-18", + max_tokens=10, + temperature=0.0, + top_p=0.9, + ) + + prompt = f""" + Here is a purpose input into a report generation engine that can create a long-form report on any topic of interest. + Please judge whether the provided purpose is valid for using this service. + Try to judge if given purpose is non-sense like random words or just try to get around the sanity check. + You should not make the rule too strict. + + If the purpose is valid, output "Yes."; otherwise, output "No" followed by reason. + User input: {user_input} + """ + try: + response = my_openai_model(prompt)[0].replace("[", "").replace("]", "") + if response.startswith("No"): + return "Please provide a more detailed explanation on your purpose of requesting this article." + + except Exception as e: + return "Please provide a more detailed explanation on your purpose of requesting this article." + return "Approved" From 354de564d0415f722369738b9f9b8246a2ace57b Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Tue, 24 Sep 2024 21:40:19 -0700 Subject: [PATCH 06/19] Update __init__.py --- knowledge_storm/__init__.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/knowledge_storm/__init__.py b/knowledge_storm/__init__.py index 5ce0f2c..5a9a53f 100644 --- a/knowledge_storm/__init__.py +++ b/knowledge_storm/__init__.py @@ -1,7 +1,10 @@ -from .storm_wiki.engine import ( - STORMWikiLMConfigs, - STORMWikiRunnerArguments, - STORMWikiRunner, -) - -__version__ = "0.2.8" +from .storm_wiki import * +from .collaborative_storm import * +from .api import * +from .encoder import * +from .interface import * +from .lm import * +from .rm import * +from .server import * +from .utils import * +from .dataclass import * From c69d5276ec9e6cb50dfabfcad33a868e79845b23 Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Tue, 24 Sep 2024 21:48:46 -0700 Subject: [PATCH 07/19] Dump up the version --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 076ea6d..7c4f106 100644 --- a/setup.py +++ b/setup.py @@ -16,7 +16,7 @@ setup( name="knowledge-storm", - version="0.2.8", + version="1.0.0", author="Yijia Shao, Yucheng Jiang", author_email="shaoyj@stanford.edu, yuchengj@stanford.edu", description="STORM: A language model-powered knowledge curation engine.", From 54409910f6efd432d9dbbbd8b0c27d0aec94534c Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Wed, 25 Sep 2024 00:31:26 -0700 Subject: [PATCH 08/19] restructure examples directory; remove dirty hack of relative import code --- examples/costorm_examples/run_costorm_gpt.py | 238 ++++++++++++++++++ examples/{ => storm_examples}/README.md | 12 +- .../process_kaggle_arxiv_abstract_dataset.py | 0 .../run_storm_wiki_claude.py | 0 .../run_storm_wiki_deepseek.py | 0 .../run_storm_wiki_gemini.py | 0 .../run_storm_wiki_gpt.py | 0 .../run_storm_wiki_gpt_with_VectorRM.py | 2 - .../run_storm_wiki_groq.py | 7 - .../run_storm_wiki_mistral.py | 0 .../run_storm_wiki_ollama.py | 1 - .../run_storm_wiki_ollama_with_searxng.py | 0 .../run_storm_wiki_serper.py | 0 13 files changed, 244 insertions(+), 16 deletions(-) create mode 100644 examples/costorm_examples/run_costorm_gpt.py rename examples/{ => storm_examples}/README.md (91%) rename examples/{ => storm_examples}/helper/process_kaggle_arxiv_abstract_dataset.py (100%) rename examples/{ => storm_examples}/run_storm_wiki_claude.py (100%) rename examples/{ => storm_examples}/run_storm_wiki_deepseek.py (100%) rename examples/{ => storm_examples}/run_storm_wiki_gemini.py (100%) rename examples/{ => storm_examples}/run_storm_wiki_gpt.py (100%) rename examples/{ => storm_examples}/run_storm_wiki_gpt_with_VectorRM.py (99%) rename examples/{ => storm_examples}/run_storm_wiki_groq.py (97%) rename examples/{ => storm_examples}/run_storm_wiki_mistral.py (100%) rename examples/{ => storm_examples}/run_storm_wiki_ollama.py (99%) rename examples/{ => storm_examples}/run_storm_wiki_ollama_with_searxng.py (100%) rename examples/{ => storm_examples}/run_storm_wiki_serper.py (100%) diff --git a/examples/costorm_examples/run_costorm_gpt.py b/examples/costorm_examples/run_costorm_gpt.py new file mode 100644 index 0000000..8fe6c7f --- /dev/null +++ b/examples/costorm_examples/run_costorm_gpt.py @@ -0,0 +1,238 @@ +""" +STORM Wiki pipeline powered by GPT-4o/4o-mini and Bing search engine. +You need to set up the following environment variables to run this script: + - OPENAI_API_KEY: OpenAI API key + - OPENAI_API_TYPE: OpenAI API type (e.g., 'openai' or 'azure') + - AZURE_API_BASE: Azure API base URL if using Azure API + - AZURE_API_VERSION: Azure API version if using Azure API + - BING_SEARCH_API_KEY: Biang search API key; BING_SEARCH_API_KEY: Bing Search API key, SERPER_API_KEY: Serper API key, BRAVE_API_KEY: Brave API key, or TAVILY_API_KEY: Tavily API key + +Output will be structured as below +args.output_dir/ + log.json # Log of information-seeking conversation + report.txt # Final article generated +""" + +import os +import json +from argparse import ArgumentParser +from knowledge_storm.collaborative_storm.engine import CollaborativeStormLMConfigs, RunnerArgument, CoStormRunner +from knowledge_storm.collaborative_storm.modules.callback import LocalConsolePrintCallBackHandler +from knowledge_storm.lm import OpenAIModel, AzureOpenAIModel +from knowledge_storm.logging_wrapper import LoggingWrapper +from knowledge_storm.rm import YouRM, BingSearch, BraveRM, SerperRM, DuckDuckGoSearchRM, TavilySearchRM, SearXNG +from knowledge_storm.utils import load_api_key + + +def main(args): + load_api_key(toml_file_path='secrets.toml') + lm_config: CollaborativeStormLMConfigs = CollaborativeStormLMConfigs() + openai_kwargs = { + "api_key": os.getenv("OPENAI_API_KEY"), + "api_provider": "openai", + "temperature": 1.0, + "top_p": 0.9, + "api_base": None, + } if os.getenv('OPENAI_API_TYPE') == 'openai' else { + "api_key": os.getenv("AZURE_API_KEY"), + "temperature": 1.0, + "top_p": 0.9, + "api_base": os.getenv("AZURE_API_BASE"), + "api_version": os.getenv("AZURE_API_VERSION"), + } + + ModelClass = OpenAIModel if os.getenv('OPENAI_API_TYPE') == 'openai' else AzureOpenAIModel + # If you are using Azure service, make sure the model name matches your own deployed model name. + # The default name here is only used for demonstration and may not match your case. + gpt_4o_mini_model_name = 'gpt-4o-mini' + gpt_4o_model_name = 'gpt-4o' + if os.getenv('OPENAI_API_TYPE') == 'azure': + openai_kwargs['api_base'] = os.getenv('AZURE_API_BASE') + openai_kwargs['api_version'] = os.getenv('AZURE_API_VERSION') + + # STORM is a LM system so different components can be powered by different models. + # For a good balance between cost and quality, you can choose a cheaper/faster model for conv_simulator_lm + # which is used to split queries, synthesize answers in the conversation. We recommend using stronger models + # for outline_gen_lm which is responsible for organizing the collected information, and article_gen_lm + # which is responsible for generating sections with citations. + question_answering_lm = ModelClass(model=gpt_4o_model_name, max_tokens=1000, **openai_kwargs) + discourse_manage_lm = ModelClass(model=gpt_4o_model_name, max_tokens=500, **openai_kwargs) + utterance_polishing_lm = ModelClass(model=gpt_4o_model_name, max_tokens=2000, **openai_kwargs) + warmstart_outline_gen_lm = ModelClass(model=gpt_4o_model_name, max_tokens=500, **openai_kwargs) + question_asking_lm = ModelClass(model=gpt_4o_model_name, max_tokens=300, **openai_kwargs) + knowledge_base_lm = ModelClass(model=gpt_4o_model_name, max_tokens=1000, **openai_kwargs) + + lm_config.set_question_answering_lm(question_answering_lm) + lm_config.set_discourse_manage_lm(discourse_manage_lm) + lm_config.set_utterance_polishing_lm(utterance_polishing_lm) + lm_config.set_warmstart_outline_gen_lm(warmstart_outline_gen_lm) + lm_config.set_question_asking_lm(question_asking_lm) + lm_config.set_knowledge_base_lm(knowledge_base_lm) + + topic = input('Topic: ') + runner_argument = RunnerArgument( + topic=topic, + retrieve_top_k=args.retrieve_top_k, + max_search_queries=args.max_search_queries, + total_conv_turn=args.total_conv_turn, + max_search_thread=args.max_search_thread, + max_search_queries_per_turn=args.max_search_queries_per_turn, + warmstart_max_num_experts=args.warmstart_max_num_experts, + warmstart_max_turn_per_experts=args.warmstart_max_turn_per_experts, + warmstart_max_thread=args.warmstart_max_thread, + max_thread_num=args.max_thread_num, + max_num_round_table_experts=args.max_num_round_table_experts, + moderator_override_N_consecutive_answering_turn=args.moderator_override_N_consecutive_answering_turn, + node_expansion_trigger_count=args.node_expansion_trigger_count) + logging_wrapper = LoggingWrapper(lm_config) + callback_handler = LocalConsolePrintCallBackHandler() if args.enable_log_print else None + + # Co-STORM is a knowledge curation system which consumes information from the retrieval module. + # Currently, the information source is the Internet and we use search engine API as the retrieval module. + match args.retriever: + case 'bing': + rm = BingSearch(bing_search_api=os.getenv('BING_SEARCH_API_KEY'), k=runner_argument.retrieve_top_k) + case 'you': + rm = YouRM(ydc_api_key=os.getenv('YDC_API_KEY'), k=runner_argument.retrieve_top_k) + case 'brave': + rm = BraveRM(brave_search_api_key=os.getenv('BRAVE_API_KEY'), k=runner_argument.retrieve_top_k) + case 'duckduckgo': + rm = DuckDuckGoSearchRM(k=runner_argument.retrieve_top_k, safe_search='On', region='us-en') + case 'serper': + rm = SerperRM(serper_search_api_key=os.getenv('SERPER_API_KEY'), query_params={'autocorrect': True, 'num': 10, 'page': 1}) + case 'tavily': + rm = TavilySearchRM(tavily_search_api_key=os.getenv('TAVILY_API_KEY'), k=runner_argument.retrieve_top_k, include_raw_content=True) + case 'searxng': + rm = SearXNG(searxng_api_key=os.getenv('SEARXNG_API_KEY'), k=runner_argument.retrieve_top_k) + case _: + raise ValueError(f'Invalid retriever: {args.retriever}. Choose either "bing", "you", "brave", "duckduckgo", "serper", "tavily", or "searxng"') + + costorm_runner = CoStormRunner(lm_config=lm_config, + runner_argument=runner_argument, + logging_wrapper=logging_wrapper, + rm=rm, + callback_handler=callback_handler) + + # warm start the system + costorm_runner.warm_start() + + # observing Co-STORM LLM agent utterance for 5 turns + for _ in range(1): + conv_turn = costorm_runner.step() + print(f"**{conv_turn.role}**: {conv_turn.utterance}\n") + + # active engaging by injecting your utterance + your_utterance = input('Your utterance: ') + costorm_runner.step(user_utterance=your_utterance) + + # continue observing + conv_turn = costorm_runner.step() + print(f"**{conv_turn.role}**: {conv_turn.utterance}\n") + + # generate report + costorm_runner.knowledge_base.reogranize() + article = costorm_runner.generate_report() + + # save results + os.makedirs(args.output_dir, exist_ok=True) + + # Save article + with open(os.path.join(args.output_dir, "report.md"), "w") as f: + f.write(article) + + # Save logging + log_dump = costorm_runner.dump_logging_and_reset() + with open(os.path.join(args.output_dir, "log.json"), "w") as f: + json.dump(log_dump, f, indent=2) + + +if __name__ == '__main__': + parser = ArgumentParser() + # global arguments + parser.add_argument('--output-dir', type=str, default='./results/co-storm', + help='Directory to store the outputs.') + parser.add_argument('--retriever', type=str, choices=['bing', 'you', 'brave', 'serper', 'duckduckgo', 'tavily', 'searxng'], + help='The search engine API to use for retrieving information.') + # hyperparameters for co-storm + parser.add_argument( + '--retrieve_top_k', + type=int, + default=10, + help='Retrieve top k results for each query in retriever.' + ) + parser.add_argument( + '--max_search_queries', + type=int, + default=2, + help='Maximum number of search queries to consider for each question.' + ) + parser.add_argument( + '--total_conv_turn', + type=int, + default=20, + help='Maximum number of turns in conversation.' + ) + parser.add_argument( + '--max_search_thread', + type=int, + default=5, + help='Maximum number of parallel threads for retriever.' + ) + parser.add_argument( + '--max_search_queries_per_turn', + type=int, + default=3, + help='Maximum number of search queries to consider in each turn.' + ) + parser.add_argument( + '--warmstart_max_num_experts', + type=int, + default=3, + help='Max number of experts in perspective-guided QA during warm start.' + ) + parser.add_argument( + '--warmstart_max_turn_per_experts', + type=int, + default=2, + help='Max number of turns per perspective during warm start.' + ) + parser.add_argument( + '--warmstart_max_thread', + type=int, + default=3, + help='Max number of threads for parallel perspective-guided QA during warm start.' + ) + parser.add_argument( + '--max_thread_num', + type=int, + default=10, + help=("Maximum number of threads to use. " + "Consider reducing it if you keep getting 'Exceed rate limit' errors when calling the LM API.") + ) + parser.add_argument( + '--max_num_round_table_experts', + type=int, + default=2, + help='Max number of active experts in round table discussion.' + ) + parser.add_argument( + '--moderator_override_N_consecutive_answering_turn', + type=int, + default=3, + help=('Number of consecutive expert answering turns before the moderator overrides the conversation.') + ) + parser.add_argument( + '--node_expansion_trigger_count', + type=int, + default=10, + help='Trigger node expansion for nodes that contain more than N snippets.' + ) + + # Boolean flags + parser.add_argument( + '--enable_log_print', + action='store_true', + help='If set, enable console log print.' + ) + + main(parser.parse_args()) \ No newline at end of file diff --git a/examples/README.md b/examples/storm_examples/README.md similarity index 91% rename from examples/README.md rename to examples/storm_examples/README.md index 6aa04a3..083bd4f 100644 --- a/examples/README.md +++ b/examples/storm_examples/README.md @@ -11,7 +11,7 @@ We host a number of example scripts for various customization of STORM (e.g., us 2. Run the following command under the root directory of the repository: ``` - python examples/run_storm_wiki_mistral.py \ + python examples/storm_examples/run_storm_wiki_mistral.py \ --url $URL \ --port $PORT \ --output-dir $OUTPUT_DIR \ @@ -50,7 +50,7 @@ By default, STORM is grounded on the Internet using the search engine, but it ca To create the vector store offline, run ``` - python examples/run_storm_wiki_gpt_with_VectorRM.py \ + python examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py \ --output-dir $OUTPUT_DIR \ --vector-db-mode offline \ --offline-vector-db-dir $OFFLINE_VECTOR_DB_DIR \ @@ -65,7 +65,7 @@ By default, STORM is grounded on the Internet using the search engine, but it ca To create the vector store online on a Qdrant server, run ``` - python examples/run_storm_wiki_gpt_with_VectorRM.py \ + python examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py \ --output-dir $OUTPUT_DIR \ --vector-db-mode online \ --online-vector-db-url $ONLINE_VECTOR_DB_URL \ @@ -83,12 +83,12 @@ By default, STORM is grounded on the Internet using the search engine, but it ca - Run the following command under the root directory to downsample the dataset by filtering papers with terms `[cs.CV]` and get a csv file that match the format mentioned above. ``` - python examples/helper/process_kaggle_arxiv_abstract_dataset.py --input-path $PATH_TO_THE_DOWNLOADED_FILE --output-path $PATH_TO_THE_PROCESSED_CSV + python examples/storm_examples/helper/process_kaggle_arxiv_abstract_dataset.py --input-path $PATH_TO_THE_DOWNLOADED_FILE --output-path $PATH_TO_THE_PROCESSED_CSV ``` - Run the following command to run STORM grounding on the processed dataset. You can input a topic related to computer vision (e.g., "The progress of multimodal models in computer vision") to see the generated article. (Note that the generated article may not include enough details since the quick test only use the abstracts of arxiv papers.) ``` - python examples/run_storm_wiki_gpt_with_VectorRM.py \ + python examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py \ --output-dir $OUTPUT_DIR \ --vector-db-mode offline \ --offline-vector-db-dir $OFFLINE_VECTOR_DB_DIR \ @@ -102,7 +102,7 @@ By default, STORM is grounded on the Internet using the search engine, but it ca - For a quicker run, you can also download the pre-embedded vector store directly from [here](https://drive.google.com/file/d/1bijFkw5BKU7bqcmXMhO-5hg2fdKAL9bf/view?usp=share_link). ``` - python examples/run_storm_wiki_gpt_with_VectorRM.py \ + python examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py \ --output-dir $OUTPUT_DIR \ --vector-db-mode offline \ --offline-vector-db-dir $DOWNLOADED_VECTOR_DB_DR \ diff --git a/examples/helper/process_kaggle_arxiv_abstract_dataset.py b/examples/storm_examples/helper/process_kaggle_arxiv_abstract_dataset.py similarity index 100% rename from examples/helper/process_kaggle_arxiv_abstract_dataset.py rename to examples/storm_examples/helper/process_kaggle_arxiv_abstract_dataset.py diff --git a/examples/run_storm_wiki_claude.py b/examples/storm_examples/run_storm_wiki_claude.py similarity index 100% rename from examples/run_storm_wiki_claude.py rename to examples/storm_examples/run_storm_wiki_claude.py diff --git a/examples/run_storm_wiki_deepseek.py b/examples/storm_examples/run_storm_wiki_deepseek.py similarity index 100% rename from examples/run_storm_wiki_deepseek.py rename to examples/storm_examples/run_storm_wiki_deepseek.py diff --git a/examples/run_storm_wiki_gemini.py b/examples/storm_examples/run_storm_wiki_gemini.py similarity index 100% rename from examples/run_storm_wiki_gemini.py rename to examples/storm_examples/run_storm_wiki_gemini.py diff --git a/examples/run_storm_wiki_gpt.py b/examples/storm_examples/run_storm_wiki_gpt.py similarity index 100% rename from examples/run_storm_wiki_gpt.py rename to examples/storm_examples/run_storm_wiki_gpt.py diff --git a/examples/run_storm_wiki_gpt_with_VectorRM.py b/examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py similarity index 99% rename from examples/run_storm_wiki_gpt_with_VectorRM.py rename to examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py index 12a46e4..8fa4d0d 100644 --- a/examples/run_storm_wiki_gpt_with_VectorRM.py +++ b/examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py @@ -27,10 +27,8 @@ """ import os -import sys from argparse import ArgumentParser -sys.path.append('./') from knowledge_storm import STORMWikiRunnerArguments, STORMWikiRunner, STORMWikiLMConfigs from knowledge_storm.rm import VectorRM from knowledge_storm.lm import OpenAIModel, AzureOpenAIModel diff --git a/examples/run_storm_wiki_groq.py b/examples/storm_examples/run_storm_wiki_groq.py similarity index 97% rename from examples/run_storm_wiki_groq.py rename to examples/storm_examples/run_storm_wiki_groq.py index 55419c2..0dcaadb 100644 --- a/examples/run_storm_wiki_groq.py +++ b/examples/storm_examples/run_storm_wiki_groq.py @@ -18,17 +18,10 @@ """ import os -import sys import re -import logging from argparse import ArgumentParser from knowledge_storm import STORMWikiRunnerArguments, STORMWikiRunner, STORMWikiLMConfigs -# Get the absolute path to the directory containing lm.py -lm_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'knowledge_storm')) - -# Add this path to sys.path -sys.path.insert(0, lm_path) # Now import lm directly import lm diff --git a/examples/run_storm_wiki_mistral.py b/examples/storm_examples/run_storm_wiki_mistral.py similarity index 100% rename from examples/run_storm_wiki_mistral.py rename to examples/storm_examples/run_storm_wiki_mistral.py diff --git a/examples/run_storm_wiki_ollama.py b/examples/storm_examples/run_storm_wiki_ollama.py similarity index 99% rename from examples/run_storm_wiki_ollama.py rename to examples/storm_examples/run_storm_wiki_ollama.py index 519467b..465e065 100644 --- a/examples/run_storm_wiki_ollama.py +++ b/examples/storm_examples/run_storm_wiki_ollama.py @@ -21,7 +21,6 @@ from dspy import Example -sys.path.append('./src') from knowledge_storm.lm import OllamaClient from knowledge_storm.rm import YouRM, BingSearch, BraveRM, SerperRM, DuckDuckGoSearchRM, TavilySearchRM, SearXNG from knowledge_storm import STORMWikiRunnerArguments, STORMWikiRunner, STORMWikiLMConfigs diff --git a/examples/run_storm_wiki_ollama_with_searxng.py b/examples/storm_examples/run_storm_wiki_ollama_with_searxng.py similarity index 100% rename from examples/run_storm_wiki_ollama_with_searxng.py rename to examples/storm_examples/run_storm_wiki_ollama_with_searxng.py diff --git a/examples/run_storm_wiki_serper.py b/examples/storm_examples/run_storm_wiki_serper.py similarity index 100% rename from examples/run_storm_wiki_serper.py rename to examples/storm_examples/run_storm_wiki_serper.py From cba21849153a826487ea1a8700f2daa1b1654da0 Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Wed, 25 Sep 2024 00:31:59 -0700 Subject: [PATCH 09/19] remove frontend code --- knowledge_storm/__init__.py | 2 - .../collaborative_storm/__init__.py | 2 - knowledge_storm/collaborative_storm/engine.py | 8 -- .../modules/collaborative_storm_utils.py | 119 ------------------ 4 files changed, 131 deletions(-) diff --git a/knowledge_storm/__init__.py b/knowledge_storm/__init__.py index 5a9a53f..d28f041 100644 --- a/knowledge_storm/__init__.py +++ b/knowledge_storm/__init__.py @@ -1,10 +1,8 @@ from .storm_wiki import * from .collaborative_storm import * -from .api import * from .encoder import * from .interface import * from .lm import * from .rm import * -from .server import * from .utils import * from .dataclass import * diff --git a/knowledge_storm/collaborative_storm/__init__.py b/knowledge_storm/collaborative_storm/__init__.py index 62e6bfb..b85715b 100644 --- a/knowledge_storm/collaborative_storm/__init__.py +++ b/knowledge_storm/collaborative_storm/__init__.py @@ -1,4 +1,2 @@ from .modules import * from .engine import * -from .demo_runner import * -from .baseline import * diff --git a/knowledge_storm/collaborative_storm/engine.py b/knowledge_storm/collaborative_storm/engine.py index e8c6092..8e50d21 100644 --- a/knowledge_storm/collaborative_storm/engine.py +++ b/knowledge_storm/collaborative_storm/engine.py @@ -609,14 +609,6 @@ def generate_report(self) -> str: def dump_logging_and_reset(self): return self.logging_wrapper.dump_logging_and_reset() - def get_next_turn_experts_for_frontend_render(self): - turn_policy = self.discourse_manager.get_next_turn_policy( - conversation_history=self.conversation_history, - simulate_user=False, - dry_run=True, - ) - return turn_policy.agent.role_name - def step( self, user_utterance: str = "", diff --git a/knowledge_storm/collaborative_storm/modules/collaborative_storm_utils.py b/knowledge_storm/collaborative_storm/modules/collaborative_storm_utils.py index 661c49f..d337de6 100644 --- a/knowledge_storm/collaborative_storm/modules/collaborative_storm_utils.py +++ b/knowledge_storm/collaborative_storm/modules/collaborative_storm_utils.py @@ -240,125 +240,6 @@ def load_api_key(toml_file_path): os.environ[key] = str(value) -def construct_frontend_display_data( - knowledge_base, - conv_turn, - is_warm_start: bool = False, - next_turn_role: Optional[str] = None, -): - def to_dict(node): - if node is None: - return None - data = { - "node_name": node.name, - "node_uuid": " -> ".join(node.get_path_from_root()), - "content": list(node.content), - "child_node": [], - } - for child in node.children: - child_data = to_dict(child) - if child_data is not None: - data["child_node"].append(child_data) - return data - - def split_paragraph(paragraph): - # Regular expression to match sentences with citations - sentence_pattern = re.compile(r"([^.?!]*[.?!])(\s*\[\d+\])*") - citation_pattern = re.compile(r"\[(\d+)\]") - - # Check if there are any sentence separators in the paragraph - if not re.search(r"[.?!]", paragraph): - # If no separators, consider the whole paragraph as a single sentence - citations = list(map(int, citation_pattern.findall(paragraph))) - sentence = citation_pattern.sub("", paragraph).strip() - return [(sentence, citations)] - - sentences = [] - - for match in sentence_pattern.finditer(paragraph): - sentence_with_citations = match.group(0).strip() - sentence = match.group(1).strip() - citations = list( - map(int, citation_pattern.findall(sentence_with_citations)) - ) - - # Remove citations from the sentence - sentence = citation_pattern.sub("", sentence).strip() - - sentences.append((sentence, citations)) - - return sentences - - # get mind map - mind_map = to_dict(knowledge_base.root) - # get last turn utterance - role = conv_turn.role - utterance = str(conv_turn.utterance) - sentences_w_citations = split_paragraph(utterance) - - # get cited info - cited_info = {} - for citation_idx, info in knowledge_base.info_uuid_to_info_dict.items(): - cited_info[citation_idx] = { - "description": info.description, - "snippets": info.snippets, - "url": info.url, - "title": info.title, - "placement": info.meta.get("placement", ""), - } - evaluation_questions = None - if conv_turn.role != "Guest": - evaluation_questions = [ - { - "question": "Does this new utterance help steer the discourse towards a new and interesting direction?", - "type": "multiple_choice", - "choices": ["Yes", "No"], - "id": 1, - }, - { - "question": "Has the mind map reasonably managing the discourse so far?", - "type": "multiple_choice", - "choices": ["Yes", "No"], - "id": 2, - }, - { - "question": "(Optional) Any comments?", - "type": "freeform", - "choices": [], - "id": 3, - }, - ] - to_return = { - "mind_map": mind_map, - "conversation_turn": { - "role": role, - "content": sentences_w_citations, - "is_warm_start": is_warm_start, - }, - "cited_info": cited_info, - "eval": evaluation_questions, - "next_turn_role": next_turn_role, - } - return to_return - - -def construct_article_frontend_display_data(knowledge_base, article: str): - cited_info = { - key: value.to_dict() - for key, value in knowledge_base.info_uuid_to_info_dict.items() - } - data = {"article": article, "cited_info": cited_info} - return data - - -def construct_round_table_conversation_databackup(round_table_conversation): - round_tabld_dump = round_table_conversation.to_dict() - log_dump = round_table_conversation.logging_wrapper.dump_logging_and_reset( - reset_logging=False - ) - return {"round_tabld_dump": round_tabld_dump, "log_dump": log_dump} - - def _get_answer_question_module_instance( lm_config: LMConfigs, runner_argument: "RunnerArgument", From 2a117d13d16469c6bbacc29ca0e1f556078f700e Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Wed, 25 Sep 2024 00:32:45 -0700 Subject: [PATCH 10/19] add class and function documentations --- knowledge_storm/collaborative_storm/engine.py | 65 +++++++++++++- .../collaborative_storm/modules/callback.py | 89 +------------------ .../modules/co_storm_agents.py | 34 +++++++ .../modules/grounded_question_generation.py | 8 ++ .../modules/warmstart_hierarchical_chat.py | 10 +++ knowledge_storm/dataclass.py | 22 ++++- knowledge_storm/interface.py | 21 +++++ knowledge_storm/rm.py | 2 +- .../storm_wiki/modules/article_polish.py | 2 + 9 files changed, 160 insertions(+), 93 deletions(-) diff --git a/knowledge_storm/collaborative_storm/engine.py b/knowledge_storm/collaborative_storm/engine.py index 8e50d21..2a68a3d 100644 --- a/knowledge_storm/collaborative_storm/engine.py +++ b/knowledge_storm/collaborative_storm/engine.py @@ -21,9 +21,9 @@ class CollaborativeStormLMConfigs(LMConfigs): - """Configurations for LLM used in different parts of STORM. + """Configurations for LLM used in different parts of Co-STORM. - Given that different parts in STORM framework have different complexity, we use different LLM configurations + Given that different parts in Co-STORM framework have different complexity, we use different LLM configurations to achieve a balance between quality and efficiency. If no specific configuration is provided, we use the default setup in the paper. """ @@ -292,6 +292,23 @@ def from_dict(cls, data): @dataclass class TurnPolicySpec: + """ + Represents the policy specifications for determining the behavior of a conversation turn. + + Attributes: + should_reorganize_knowledge_base (bool): + A flag that indicates whether the knowledge base should be reorganized after the current turn. + + should_update_experts_list (bool): + A flag that indicates whether the list of experts should be updated based on the conversation context. + + should_polish_utterance (bool): + A flag that indicates whether the generated utterance should be polished (e.g., refined or rephrased) before it is used in the conversation. + + agent (Agent): + The `Agent` responsible for generating utterances or responses during the conversation turn. + This agent interacts with the knowledge base and the conversation history to produce responses. + """ should_reorganize_knowledge_base: bool = False should_update_experts_list: bool = False should_polish_utterance: bool = False @@ -553,6 +570,14 @@ def from_dict(cls, data): return costorm_runner def warm_start(self): + """ + Warm start co-storm system to conduct background information search in order to build shared conceptual space with user. + This stage is a mini-STORM, spawning multiple LLM agent with different perspective and perform multi-round conversation. + The knowledge base (i.e. mind map) will be initialize using the collected information. + + It will also generate a first draft of report and use it to produce an engaging and concise conversation presented to the + user to catch up with system's knowledge about the topic. + """ with self.logging_wrapper.log_pipeline_stage( pipeline_stage=f"warm start stage" ): @@ -600,6 +625,13 @@ def warm_start(self): ) def generate_report(self) -> str: + """ + Generate report leveraging organized collected information in the knowledge base (i.e. mind map). + The article generation follows the paradigm in STORM paper, where it considers mind map nodes as section names, and generate the report section by section. + + Returns: + str: A string representing the report, with "#" "##" indicating hierarchical sections and [1][2] indicating references. + """ with self.logging_wrapper.log_pipeline_stage("report generation stage"): with self.logging_wrapper.log_event( "report generation stage: generate report" @@ -615,6 +647,35 @@ def step( simulate_user: bool = False, simulate_user_intent: str = "", ) -> ConversationTurn: + """ + Yields a single turn in the conversation flow. + + This method take a user input when user choose to inject an utterance or generates the next system utterance based on the current conversation history and defined discourse policies. + It handles updating the conversation history, managing expert lists, and interacting with the knowledge base. + Additionally, it logs each stage of the conversation for monitoring and debugging purposes. + + Args: + user_utterance (str, optional): The input provided by the user. If provided, this utterance is added directly to the conversation history and returns with no further action. + simulate_user (bool, optional): This is designed for automatic experiments using a LLM agent to simulate user actions. Flag indicating whether to simulate user behavior. When set to `True`, the system will generate user intents based on predefined simulation logic. Defaults to `False`. + simulate_user_intent (str, optional): This is designed for automatic experiments using a LLM agent to simulate user actions. Specifies the intent to simulate for the user. This is used when `simulate_user` is `True` to guide the simulated user's responses, + + Returns: + ConversationTurn: An object representing the latest turn in the conversation. + + Workflow: + 1. User Utterance Handling + - If `user_utterance` is provided, it is appended to the `conversation_history` + + 2. System Utterance Generation + - If no `user_utterance` is provided, the method proceeds to generate the next system utterance. + - Determines the next turn policy by consulting the `discourse_manager` with the current conversation history. + - Generates a new utterance using the agent defined in the turn policy, leveraging the `knowledge_base` and `conversation_history`. + - If the turn policy indicates that the experts list should be updated, it updates the expert list based on the latest utterances. + + 4. Knowledge Base Update + - Inserts the new turn into the `knowledge_base`, optionally allowing the creation of new nodes or inserting under the root based on the `rag_only_baseline_mode` flag. + - If the turn policy specifies, it reorganizes the `knowledge_base` to maintain optimal structure and relevance. + """ last_conv_turn = self.conversation_history[-1] cur_turn_name = f"conv turn: {len(self.conversation_history) + 1}" with self.logging_wrapper.log_pipeline_stage( diff --git a/knowledge_storm/collaborative_storm/modules/callback.py b/knowledge_storm/collaborative_storm/modules/callback.py index 339c7e3..9d61012 100644 --- a/knowledge_storm/collaborative_storm/modules/callback.py +++ b/knowledge_storm/collaborative_storm/modules/callback.py @@ -3,7 +3,7 @@ class BaseCallbackHandler: - """Base callback handler to manage callbacks from the STORM pipeline.""" + """Base callback handler to manage callbacks from the Co-STORM pipeline.""" def on_turn_policy_planning_start(self, **kwargs): """Run when the turn policy planning begins, before deciding the direction or goal for the next conversation turn.""" @@ -58,94 +58,7 @@ def on_warmstart_update(self, message, **kwargs): pass -class CoStormDemoCallBackHandler(BaseCallbackHandler): - from ...api import BackendAPI - - def __init__(self, backend_api: BackendAPI, conversation_id: int): - self.backend_api = backend_api - self.conversation_id = conversation_id - - def on_turn_policy_planning_start(self, **kwargs): - """Run when the turn policy planning begins, before deciding the direction or goal for the next conversation turn.""" - # self.backend_api.update_conversation_status( - # self.conversation_id, - # "active", - # "Start planning next expert; inspect mind map; inspect system state.", - # ) - # skip this part due to message sync latency in the frontend UI, which introduce more confusion. - pass - - def on_expert_action_planning_start(self, **kwargs): - """Run when the expert action planning begins, preparing to determine the actions that each expert should take.""" - self.backend_api.update_conversation_status( - self.conversation_id, - "active", - "Reviewing discourse history; Deciding utterance intent.", - ) - - def on_expert_information_collection_start(self, **kwargs): - """Run when the expert information collection ends, after gathering all necessary data from selected sources.""" - self.backend_api.update_conversation_status( - self.conversation_id, - "active", - "Start searching and browsing collected information; drafting utterance", - ) - - def on_expert_information_collection_end(self, info: List[Information], **kwargs): - """Run when the expert information collection ends, after gathering all necessary data from selected sources.""" - if info: - urls = [i.url for i in info] - information_string = "\n".join([f"Finish browsing {url}" for url in urls]) - self.backend_api.update_conversation_status( - self.conversation_id, "active", information_string - ) - - def on_expert_utterance_generation_end(self, **kwargs): - """Run when the expert utterance generation ends, before creating responses or statements from each expert.""" - self.backend_api.update_conversation_status( - self.conversation_id, - "active", - "Finish generating utterance from collected information.", - ) - - def on_expert_utterance_polishing_start(self, **kwargs): - """Run when the expert utterance polishing begins, to refine and improve the clarity and coherence of generated content.""" - self.backend_api.update_conversation_status( - self.conversation_id, "active", "Start polishing utterance." - ) - - def on_mindmap_insert_start(self, **kwargs): - """Run when the process of inserting new information into the mindmap starts.""" - self.backend_api.update_conversation_status( - self.conversation_id, "active", "Start inserting information into mind map." - ) - - def on_mindmap_insert_end(self, **kwargs): - """Run when the process of inserting new information into the mindmap ends.""" - self.backend_api.update_conversation_status(self.conversation_id, "active", "") - - def on_mindmap_reorg_start(self, **kwargs): - """Run when the reorganization of the mindmap begins, to restructure and optimize the flow of information.""" - self.backend_api.update_conversation_status( - self.conversation_id, "active", "Start re-organizing mind map." - ) - - def on_expert_list_update_start(self, **kwargs): - """Run when the expert list update starts, to modify or refresh the list of active experts.""" - self.backend_api.update_conversation_status( - self.conversation_id, "active", "Start updating expert candidates." - ) - - def on_warmstart_update(self, message, **kwargs): - """Run when the warm start process has update.""" - self.backend_api.update_conversation_status( - self.conversation_id, "warmup", message - ) - - class LocalConsolePrintCallBackHandler(BaseCallbackHandler): - from ...api import BackendAPI - def __init__(self): pass diff --git a/knowledge_storm/collaborative_storm/modules/co_storm_agents.py b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py index 045bb32..3fbe122 100644 --- a/knowledge_storm/collaborative_storm/modules/co_storm_agents.py +++ b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py @@ -22,6 +22,22 @@ class CoStormExpert(Agent): + """ + Represents an expert agent in the Co-STORM framework. + The `CoStormExpert` is a specialized type of `Agent` that is tasked with participating in roundtable discussions within the Co-STORM system. + The expert uses language models to generate action plans, answer questions, and polish its utterances based on the current conversation history and knowledge base. + It interacts with modules for action planning and question answering grounding on provided retrieval models. + + Args: + topic (str): The conversation topic that the expert specializes in. + role_name (str): The perspective of the expert's role (e.g. AI enthusiast, drug discovery expert, etc.) + role_description (str): A description of the perspective of the experts + lm_config (LMConfigs): Configuration for the language models + runner_argument (RunnerArgument): Co-STORM runner argument + logging_wrapper (LoggingWrapper): An instance of `LoggingWrapper` to log events. + rm (Optional[dspy.Retrieve], optional): A retrieval module used for fetching external knowledge or context. + callback_handler (BaseCallbackHandler, optional): Handles log message printing + """ def __init__( self, topic: str, @@ -91,6 +107,11 @@ def generate_utterance( class SimulatedUser(Agent): + """ + Simulated Users is a special type of Agent in Co-STORM that simulate real user interaction behavior or automatic experiments. + + For more information, please refer to Section 3.4 of Co-STORM paper: https://www.arxiv.org/pdf/2408.15232 + """ def __init__( self, topic: str, @@ -133,6 +154,14 @@ def generate_utterance( class Moderator(Agent): + """ + The moderator's role in the Co-STORM framework is to inject new perspectives into the conversation to avoid stagnation, repetition, or overly niche discussions. + This is achieved by generating questions based on unused, uncited snippets of information retrieved since the last moderator's turn. + The selected information is reranked according to its relevance to the conversation topic and its dissimilarity to the original question. + The resulting top-ranked snippets are used to generate an informed question to be presented to the conversation participants. + + For more information, please refer to Section 3.5 of Co-STORM paper: https://www.arxiv.org/pdf/2408.15232 + """ def __init__( self, topic: str, @@ -285,6 +314,11 @@ def generate_utterance( class PureRAGAgent(Agent): + """ + PureRAGAgent only handles grounded question generation by retrieving information from retriever based on the query. + It does not utilize any other information besides query itself. + It's designed for Co-STORM paper baseline comparison. + """ def __init__( self, topic: str, diff --git a/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py b/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py index f09339d..8f810d9 100644 --- a/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py +++ b/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py @@ -1,3 +1,11 @@ +""" +This module handles question generation within the Co-STORM framework, specifically designed to support the Moderator role. + +The Moderator generates insightful, thought-provoking questions that introduce new directions into the conversation. +By leveraging uncited or unused snippets of information retrieved during the discussion, the Moderator ensures the conversation remains dynamic and avoids repetitive or overly niche topics. + +For more detailed information, refer to Section 3.5 of the Co-STORM paper: https://www.arxiv.org/pdf/2408.15232. +""" import dspy from typing import List, Union diff --git a/knowledge_storm/collaborative_storm/modules/warmstart_hierarchical_chat.py b/knowledge_storm/collaborative_storm/modules/warmstart_hierarchical_chat.py index a6351aa..3357cbc 100644 --- a/knowledge_storm/collaborative_storm/modules/warmstart_hierarchical_chat.py +++ b/knowledge_storm/collaborative_storm/modules/warmstart_hierarchical_chat.py @@ -1,3 +1,13 @@ +""" +Warm starts the Co-STORM system by conducting a background information search to establish a shared conceptual space with the user. + +This stage functions as a mini-STORM, where multiple LLM agents are spawned with different perspectives to engage in multi-round conversations. +The knowledge base (represented as a mind map) is initialized using the information gathered during these exchanges. + +Additionally, the system generates a first draft of the report, which is then used to create a concise and engaging conversation. +The synthesized conversation is presented to the user to help them quickly catch up on the system's current knowledge about the topic. +""" + import dspy import concurrent.futures from threading import Lock diff --git a/knowledge_storm/dataclass.py b/knowledge_storm/dataclass.py index 1ec1a8c..153b961 100644 --- a/knowledge_storm/dataclass.py +++ b/knowledge_storm/dataclass.py @@ -290,10 +290,19 @@ def helper(cls, data, parent_node=None): class KnowledgeBase: """ - Class representing the knowledge base. + Represents the dynamic, hierarchical mind map used in Co-STORM to track and organize discourse. + The knowledge base serves as a shared conceptual space between the user and the system, allowing for effective collaboration by reducing the user's cognitive load and ensuring that the discourse is easy to follow. + + The knowledge base is structured as a tree (or mind map) that dynamically organizes collected information and concepts as the conversation progresses. + + The mind map consists of concepts (nodes) and edges that represent parent-child relationships among topics. Each concept is linked to retrieved information, + which is placed under the most appropriate concept based on its associated question and semantic similarity. + + For more details, please refer to Section 3.2 of Co-STORM paper: https://www.arxiv.org/pdf/2408.15232 Attributes: - root (KnowledgeNode): The root node of the knowledge base. + root (KnowledgeNode): The root node of the hierarchical knowledge base, representing the top-level concept. + """ def __init__( @@ -817,6 +826,15 @@ def get_knowledge_base_summary(self): return self.gen_summary_module(self) def reogranize(self): + """ + Reorganizes the knowledge base through two main processes: top-down expansion and bottom-up cleaning. + + The reorganization process ensures that the knowledge base remains well-structured and relevant as new information is added. It consists of the following steps: + 1.Top-Down Expansion: Expands nodes that have accumulated significant amounts of information by creating subtopics, + ensuring that each concept remains specific and manageable. + 2.Bottom-Up Cleaning: Cleans the knowledge base by removing empty leaf nodes (nodes with no supporting information) + and merging nodes that have only a single child, simplifying the structure and maintaining clarity. + """ # pre-processing self.trim_empty_leaf_nodes() self.merge_single_child_nodes() diff --git a/knowledge_storm/interface.py b/knowledge_storm/interface.py index f50ebbe..f5727d5 100644 --- a/knowledge_storm/interface.py +++ b/knowledge_storm/interface.py @@ -564,6 +564,27 @@ def reset(self): class Agent(ABC): + """ + Interface for STORM and Co-STORM LLM agent + + This class must be implemented by any subclass of `Agent` to define how the agent generates an utterance. + The generated utterance can be influenced by the conversation history, knowledge base, and any additional parameters passed via `kwargs`. + The implementation should align with the specific role and perspective of the agent, as defined by the agent's topic, role name, and role description. + + Args: + knowledge_base (KnowledgeBase): The current knowledge base (e.g., mind map in Co-STORM) that contains the accumulated information relevant to the conversation. + conversation_history (List[ConversationTurn]): A list of past conversation turns, providing context for generating the next utterance. + The agent can refer to this history to maintain continuity and relevance in the conversation. + logging_wrapper (LoggingWrapper): A wrapper used for logging important events during the utterance generation process. + **kwargs: Additional arguments that can be passed to the method for more specialized utterance generation behavior depending on the agent's specific implementation. + + Returns: + ConversationTurn: A new conversation turn generated by the agent, containing the agent's response, including the role, utterance type, and relevant information from the knowledge base. + + Notes: + - Subclasses of `Agent` should define the exact strategy for generating the utterance, which could involve interacting with a language model, retrieving relevant knowledge, or following specific conversational policies. + - The agent's role, perspective, and the knowledge base content will influence how the utterance is formulated. + """ from .dataclass import KnowledgeBase, ConversationTurn def __init__(self, topic: str, role_name: str, role_description: str): diff --git a/knowledge_storm/rm.py b/knowledge_storm/rm.py index d023d4a..c177b8f 100644 --- a/knowledge_storm/rm.py +++ b/knowledge_storm/rm.py @@ -465,7 +465,7 @@ def serper_runner(self, query_params): if response == None: raise RuntimeError( - f"Error had occured while running the search process.\n Error is {response.reason}, had failed with status code {response.status_code}" + f"Error had occurred while running the search process.\n Error is {response.reason}, had failed with status code {response.status_code}" ) return response.json() diff --git a/knowledge_storm/storm_wiki/modules/article_polish.py b/knowledge_storm/storm_wiki/modules/article_polish.py index 85c8daa..171054d 100644 --- a/knowledge_storm/storm_wiki/modules/article_polish.py +++ b/knowledge_storm/storm_wiki/modules/article_polish.py @@ -85,6 +85,7 @@ def __init__( self.polish_page = dspy.Predict(PolishPage) def forward(self, topic: str, draft_page: str, polish_whole_page: bool = True): + # NOTE: Change show_guidelines to false to make the generation more robust to different LM families. with dspy.settings.context(lm=self.write_lead_engine, show_guidelines=False): lead_section = self.write_lead( topic=topic, draft_page=draft_page @@ -92,6 +93,7 @@ def forward(self, topic: str, draft_page: str, polish_whole_page: bool = True): if "The lead section:" in lead_section: lead_section = lead_section.split("The lead section:")[1].strip() if polish_whole_page: + # NOTE: Change show_guidelines to false to make the generation more robust to different LM families. with dspy.settings.context(lm=self.polish_engine, show_guidelines=False): page = self.polish_page(draft_page=draft_page).page else: From fe035b2aa0160e2fc26903b51364dae83fd8403c Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Wed, 25 Sep 2024 00:33:05 -0700 Subject: [PATCH 11/19] some dependency requires python>=3.10 modify the requirement in setup.py --- setup.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 7c4f106..d7bd6cf 100644 --- a/setup.py +++ b/setup.py @@ -30,10 +30,9 @@ "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", ], - python_requires=">=3.9", + python_requires=">=3.10", install_requires=requirements, ) From 0f16ecee8c4eeef4704ce81bf9c1b6a3ab97b32c Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Wed, 25 Sep 2024 00:34:04 -0700 Subject: [PATCH 12/19] add version hint back --- knowledge_storm/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/knowledge_storm/__init__.py b/knowledge_storm/__init__.py index d28f041..7a55e52 100644 --- a/knowledge_storm/__init__.py +++ b/knowledge_storm/__init__.py @@ -6,3 +6,5 @@ from .rm import * from .utils import * from .dataclass import * + +__version__ = "1.0.0" \ No newline at end of file From 0734f7fb86159ca5b31fc2bfbf4cc7b5ad2651fc Mon Sep 17 00:00:00 2001 From: Yucheng-Jiang <51142637+Yucheng-Jiang@users.noreply.github.com> Date: Wed, 25 Sep 2024 00:54:09 -0700 Subject: [PATCH 13/19] Update README --- README.md | 205 ++++++++++++++++++++++++++++------- assets/co-storm-workflow.jpg | Bin 0 -> 785868 bytes 2 files changed, 166 insertions(+), 39 deletions(-) create mode 100644 assets/co-storm-workflow.jpg diff --git a/README.md b/README.md index be17ef3..8b03be2 100644 --- a/README.md +++ b/README.md @@ -5,11 +5,14 @@ # STORM: Synthesis of Topic Outlines through Retrieval and Multi-perspective Question Asking

-| Research preview | Paper | Website | +| Research preview | STORM Paper| Co-STORM Paper | Website |

- **Latest News** 🔥 +- [2024/09] Release Co-STORM codebase and intergrated into knowledge-storm python package. + +- [2024/09] Introduce collaborative STORM (Co-STORM) to support human-AI collaborative knowledge curation! [Co-STORM Paper](https://www.arxiv.org/abs/2408.15232) accepted to 2024 EMNLP. + - [2024/07] You can now install our package with `pip install knowledge-storm`! - [2024/07] We add `VectorRM` to support grounding on user-provided documents, complementing existing support of search engines (`YouRM`, `BingSearch`). (check out [#58](https://github.com/stanford-oval/storm/pull/58)) - [2024/07] We release demo light for developers a minimal user interface built with streamlit framework in Python, handy for local development and demo hosting (checkout [#54](https://github.com/stanford-oval/storm/pull/54)) @@ -24,17 +27,20 @@

-STORM is a LLM system that writes Wikipedia-like articles from scratch based on Internet search. +STORM is a LLM system that writes Wikipedia-like articles from scratch based on Internet search. Co-STORM further enhanced its feature by enabling human to collaborative LLM system to support more aligned and preferred information seeking and knowledge curation. While the system cannot produce publication-ready articles that often require a significant number of edits, experienced Wikipedia editors have found it helpful in their pre-writing stage. -**Try out our [live research preview](https://storm.genie.stanford.edu/) to see how STORM can help your knowledge exploration journey and please provide feedback to help us improve the system 🙏!** +**More than 70,000 people have tried our [live research preview](https://storm.genie.stanford.edu/). Try it out to see how STORM can help your knowledge exploration journey and please provide feedback to help us improve the system 🙏!** + +## How STORM / Co-STORM works -## How STORM works +### STORM STORM breaks down generating long articles with citations into two steps: + 1. **Pre-writing stage**: The system conducts Internet-based research to collect references and generates an outline. 2. **Writing stage**: The system uses the outline and references to generate the full-length article with citations.

@@ -47,7 +53,21 @@ STORM identifies the core of automating the research process as automatically co Based on the separation of the two stages, STORM is implemented in a highly modular way using [dspy](https://github.com/stanfordnlp/dspy). +### CO-STORM + +Co-STORM proposes collaborative discourse protocol which implements conversation turn policy management controlling smooth collaboration among +- **Co-STORM LLM experts**: This type of agent generate answers grounded on external knowledge sources and/or raise follow up questions based on discourse history. +- **Moderator**: This agent generate thought provoking questions taking inspiring from collection information provided by Co-STORM LLM experts. +- **Human user**: Human user will take the initiative to either (1) observe the discourse to gain deeper understanding of the topic, or (2) actively engaging in the conversation by injecting utterances to steer the discussion focus + +

+ +

+ +Co-STORM also maintains a dynamic updated **mind map**, which organize collected information into hirarchical concept structure, aiming to build a shared conceptual space between the human user and the system while reducing the mental load when having long in depth discourse. + +Co-STORM is also implemented in a highly modular way using [dspy](https://github.com/stanfordnlp/dspy). ## Installation @@ -70,9 +90,20 @@ You could also install the source code which allows you to modify the behavior o ## API -The STORM knowledge curation engine is defined as a simple Python `STORMWikiRunner` class. -As STORM is working in the information curation layer, you need to set up the information retrieval module and language model module to create a `STORMWikiRunner` instance. Here is an example of using You.com search engine and OpenAI models. +Currently, our package support: + +- `OpenAIModel`, `AzureOpenAIModel`, `ClaudeModel`, `VLLMClient`, `TGIClient`, `TogetherClient`, `OllamaClient`, `GoogleModel`, `DeepSeekModel`, `GroqModel` as language model components +- `YouRM`, `BingSearch`, `VectorRM`, `SerperRM`, `BraveRM`, `SearXNG`, `DuckDuckGoSearchRM`, `TavilySearchRM`, `GoogleSearch` as retrieval module components + +:star2: **PRs for integrating more language models into [knowledge_storm/lm.py](knowledge_storm/lm.py) and search engines/retrievers into [knowledge_storm/rm.py](knowledge_storm/rm.py) are highly appreciated!** + +Both STORM and Co-STORM are working in the information curation layer, you need to set up the information retrieval module and language model module to create their `Runner` classes respectively. + +### STORM + +The STORM knowledge curation engine is defined as a simple Python `STORMWikiRunner` class. Here is an example of using You.com search engine and OpenAI models. + ```python import os from knowledge_storm import STORMWikiRunnerArguments, STORMWikiRunner, STORMWikiLMConfigs @@ -101,12 +132,6 @@ rm = YouRM(ydc_api_key=os.getenv('YDC_API_KEY'), k=engine_args.search_top_k) runner = STORMWikiRunner(engine_args, lm_configs, rm) ``` -Currently, our package support: -- `OpenAIModel`, `AzureOpenAIModel`, `ClaudeModel`, `VLLMClient`, `TGIClient`, `TogetherClient`, `OllamaClient`, `GoogleModel`, `DeepSeekModel`, `GroqModel` as language model components -- `YouRM`, `BingSearch`, `VectorRM`, `SerperRM`, `BraveRM`, `SearXNG`, `DuckDuckGoSearchRM`, `TavilySearchRM`, `GoogleSearch` as retrieval module components - -:star2: **PRs for integrating more language models into [knowledge_storm/lm.py](knowledge_storm/lm.py) and search engines/retrievers into [knowledge_storm/rm.py](knowledge_storm/rm.py) are highly appreciated!** - The `STORMWikiRunner` instance can be evoked with the simple `run` method: ```python topic = input('Topic: ') @@ -125,41 +150,126 @@ runner.summary() - `do_generate_article`: if True, generate an article for the topic based on the outline and the collected information; otherwise, load the results. - `do_polish_article`: if True, polish the article by adding a summarization section and (optionally) removing duplicate content; otherwise, load the results. +### Co-STORM + +The Co-STORM knowledge curation engine is defined as a simple Python `STORMWikiRunner` class. Here is an example of using Bing search engine and OpenAI models. + +```python +from knowledge_storm.collaborative_storm.engine import CollaborativeStormLMConfigs, RunnerArgument, CoStormRunner +from knowledge_storm.lm import OpenAIModel +from knowledge_storm.logging_wrapper import LoggingWrapper +from knowledge_storm.rm import BingSearch + +# Co-STORM adopts the same multi LM system paradigm as STORM +lm_config: CollaborativeStormLMConfigs = CollaborativeStormLMConfigs() +openai_kwargs = { + "api_key": os.getenv("OPENAI_API_KEY"), + "api_provider": "openai", + "temperature": 1.0, + "top_p": 0.9, + "api_base": None, +} +question_answering_lm = OpenAIModel(model=gpt_4o_model_name, max_tokens=1000, **openai_kwargs) +discourse_manage_lm = OpenAIModel(model=gpt_4o_model_name, max_tokens=500, **openai_kwargs) +utterance_polishing_lm = OpenAIModel(model=gpt_4o_model_name, max_tokens=2000, **openai_kwargs) +warmstart_outline_gen_lm = OpenAIModel(model=gpt_4o_model_name, max_tokens=500, **openai_kwargs) +question_asking_lm = OpenAIModel(model=gpt_4o_model_name, max_tokens=300, **openai_kwargs) +knowledge_base_lm = OpenAIModel(model=gpt_4o_model_name, max_tokens=1000, **openai_kwargs) + +lm_config.set_question_answering_lm(question_answering_lm) +lm_config.set_discourse_manage_lm(discourse_manage_lm) +lm_config.set_utterance_polishing_lm(utterance_polishing_lm) +lm_config.set_warmstart_outline_gen_lm(warmstart_outline_gen_lm) +lm_config.set_question_asking_lm(question_asking_lm) +lm_config.set_knowledge_base_lm(knowledge_base_lm) + +# Check out the CoSTORM's RunnerArguments class for more configurations. +topic = input('Topic: ') +runner_argument = RunnerArgument(topic=topic, ...) +logging_wrapper = LoggingWrapper(lm_config) +bing_rm = BingSearch(bing_search_api_key=os.environ.get("BING_SEARCH_API_KEY"), + k=runner_argument.retrieve_top_k) +costorm_runner = CoStormRunner(lm_config=lm_config, + runner_argument=runner_argument, + logging_wrapper=logging_wrapper, + rm=bing_rm) +``` + +The `CoStormRunner` instance can be evoked with the `warmstart()` and `step(...)` methods. + +```python +# warm start the system to build shared conceptual space between Co-STORM and users +costorm_runner.warm_start() + +# step through the collaborative discourse +# running either of code below in any order for as many times as you would like +# Either by observing the conversation via running +conv_turn = costorm_runner.step() +# Or by actively engaging in the conversation to inject your utterance via running +costorm_runner.step(user_utterance="YOUR UTTERANCE HERE") + +# generate report +costorm_runner.knowledge_base.reogranize() +article = costorm_runner.generate_report() +print(article) +``` + + ## Quick Start with Example Scripts -We provide scripts in our [examples folder](examples) as a quick start to run STORM with different configurations. +We provide scripts in our [examples folder](examples) as a quick start to run STORM and Co-STORM with different configurations. + +We suggest using `secrets.toml` to set up the API keys. Create a file `secrets.toml` under the root directory and add the following content: + +```shell +# Set up OpenAI API key. +OPENAI_API_KEY="your_openai_api_key" +# If you are using the API service provided by OpenAI, include the following line: +OPENAI_API_TYPE="openai" +# If you are using the API service provided by Microsoft Azure, include the following lines: +OPENAI_API_TYPE="azure" +AZURE_API_BASE="your_azure_api_base_url" +AZURE_API_VERSION="your_azure_api_version" +# Set up You.com search API key. +YDC_API_KEY="your_youcom_api_key" +``` + +### STORM examples **To run STORM with `gpt` family models with default configurations:** -1. We suggest using `secrets.toml` to set up the API keys. Create a file `secrets.toml` under the root directory and add the following content: - ```shell - # Set up OpenAI API key. - OPENAI_API_KEY="your_openai_api_key" - # If you are using the API service provided by OpenAI, include the following line: - OPENAI_API_TYPE="openai" - # If you are using the API service provided by Microsoft Azure, include the following lines: - OPENAI_API_TYPE="azure" - AZURE_API_BASE="your_azure_api_base_url" - AZURE_API_VERSION="your_azure_api_version" - # Set up You.com search API key. - YDC_API_KEY="your_youcom_api_key" - ``` -2. Run the following command. - ``` - python examples/run_storm_wiki_gpt.py \ - --output-dir $OUTPUT_DIR \ - --retriever you \ - --do-research \ - --do-generate-outline \ - --do-generate-article \ - --do-polish-article - ``` + +Run the following command. +```bash +python examples/storm_examples/run_storm_wiki_gpt.py \ + --output-dir $OUTPUT_DIR \ + --retriever you \ + --do-research \ + --do-generate-outline \ + --do-generate-article \ + --do-polish-article +``` **To run STORM using your favorite language models or grounding on your own corpus:** Check out [examples/README.md](examples/README.md). +### Co-STORM examples + +To run Co-STORM with `gpt` family models with default configurations, + +1. Add `BING_SEARCH_API_KEY="xxx"`to `secrets.toml` +2. Run the following command + +```bash +python examples/costorm_examples/run_costorm_gpt.py \ + --output-dir $OUTPUT_DIR \ + --retriever bing +``` + ## Customization of the Pipeline +### STORM + If you have installed the source code, you can customize STORM based on your own use case. STORM engine consists of 4 modules: 1. Knowledge Curation Module: Collects a broad coverage of information about the given topic. @@ -169,12 +279,19 @@ If you have installed the source code, you can customize STORM based on your own The interface for each module is defined in `knowledge_storm/interface.py`, while their implementations are instantiated in `knowledge_storm/storm_wiki/modules/*`. These modules can be customized according to your specific requirements (e.g., generating sections in bullet point format instead of full paragraphs). +### Co-STORM + +If you have installed the source code, you can customize Co-STORM based on your own use case + +1. Co-STORM introduces multiple LLM agent types (i.e. CoSTORM experts and Moderator). LLM agent interface is defined in `knowledge_storm/interface.py` , while its implementation are instantiated in `knowledge_storm/collaborative_storm/modules/co_storm_agents.py`. Different LLM agent policy can be customized. +2. Co-STORM introduces collaborative discourse protocol and the core function is turn policy management. We provide an example implementation of turn policy management through DiscourseManager in `knowledge_storm/collaborative_storm/engine.py`. It can be customized and further improved. -## Replicate NAACL2024 result -Please switch to the branch `NAACL-2024-code-backup` [here](https://github.com/stanford-oval/storm/tree/NAACL-2024-code-backup). +## Replicate Replicate STORM & Co-STORM paper result +For STORM paper experiments, please switch to the branch `NAACL-2024-code-backup` [here](https://github.com/stanford-oval/storm/tree/NAACL-2024-code-backup). +For Co-STORM paper experiments, please switch to the branch `EMNLP-2024-code-backup` (place holder right now, will be updated soon). ## Roadmap & Contributions Our team is actively working on: @@ -193,6 +310,16 @@ We are very grateful to [Michelle Lam](https://michelle123lam.github.io/) for de ## Citation Please cite our paper if you use this code or part of it in your work: ```bibtex +@misc{jiang2024unknownunknowns, + title={Into the Unknown Unknowns: Engaged Human Learning through Participation in Language Model Agent Conversations}, + author={Yucheng Jiang and Yijia Shao and Dekun Ma and Sina J. Semnani and Monica S. Lam}, + year={2024}, + eprint={2408.15232}, + archivePrefix={arXiv}, + primaryClass={cs.CL}, + url={https://arxiv.org/abs/2408.15232}, +} + @inproceedings{shao2024assisting, title={{Assisting in Writing Wikipedia-like Articles From Scratch with Large Language Models}}, author={Yijia Shao and Yucheng Jiang and Theodore A. Kanell and Peter Xu and Omar Khattab and Monica S. Lam}, diff --git a/assets/co-storm-workflow.jpg b/assets/co-storm-workflow.jpg new file mode 100644 index 0000000000000000000000000000000000000000..23b8092685316a2c98c9a701ba8ab774af07b4a8 GIT binary patch literal 785868 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�h#f?1#vX@0Q1|7r~xnpl{6N?n~G#KUzb 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ⅆZ;>NH^PKP1^Rbi_BH5qMUF>iVeL3T0<`* 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 z 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Ξ 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

    SjtmMm-U0TJ`>dBt)j&&W?8+ zcs+NGo*;-7g(UNV@VT4q5Kbf6sgW{nqOx9bSn^rdv)7NDe9n~2uDonvJ;f!I+PEpJ zWn~9{T6UkZ>PuJKT6-fY$*E17ady3*4YwPlos^$Q$y%mG7yUe|8$uO6fy5XgUx6AF zlKJrnwbhRsAa-)j?8lR~jLQwy54>f)l4;XpE;-&$N%oS60i=^2zujUvaoJ`_0Mbez z`==zh@g)c+b-1DP{7q^y7f(%4UF_y_HLS+GHKC>%9ECSBX*j*#)vZt+bi4!}_A*`? zOMZWf018E;*xkA~CVwz5xv{mqVY1Tk--^#)&uzC($k#C*4z-Zf|6qCsJ-L;r^p5YV z8iEHej0s|h;=7*I%@v#^x5nZY=e8Q>Bx#VZ5T-q)pSD?^GLMBPgi@b~>&YnUNnwzK4Da@_nYmijNhmDG)dZ{7cY* zwD7@$j{vHf|Ftfc{VVq~b?cL%rHk$&p9CH&;G8DHZ;xT?AO6cZ`TuoJNe8lD4`lXz zzAm~Ye|*wxZ~FlV{%L`D=Mmc1$p83a0E96DT?*MlXQBq+*I@?OzSTQ*S)88U8K;IR zm0jPL3M@!f4GS7r~7QrGIYBw%K@o1a7*GPi+>C77&Tms4p! zFzKO5N=i|x6smD^y7%n{ap8I5qj7@_-~79g=Z9FxhH&p;$|`LehO%$vrd%G|L6#=- z-GN`?a6jE2$rXiFk2rPL)BLC@j}HOPzbF%e7zX!|AFqQpN(tbV33kqy9eW&gD>#Tr zoIFDDEHhR4_0xCnf9*9+Y}(NRMLyL0Ar6T*-#|noS-d-RVYXqiR)cZEhV8O%H(YX# z98UJUc`@%l;pH_jazNpYYS3eNH_4Tfk1`mxKDW}8K!cpr>U9iGj0_Atm$h7S#v&( ztIqGHADnFW{l5060pt6h3O0XOBXjdF0Z+j$d@P@7vN{0H*4+5&Nt>o; zX>NmK=)to@S*?~!36>o4v%Tf9WOEgyQ2_oj*zLVgET@8?OB#hgnJLIvG#Itq%+fso zCIT#J#dv&+pf_l?85PtgUPq8!$N(jxOvS3WotJS0=8A4Ua;)cRBIz=qDPaU88wU?* zDkLNi1RETAVyKl>c$oChk}v#^Hj7`fVpMQWcqoR;*4h%Yvm{r|5)!j$_yjU5d|_Ai z;@i?thG+TZ9ZGl6sCyCseXORj*1(6X!I8CwxcxXx816$|EfD;X7SV$ilP&c#Cv&<| z8xOONPTO>=`8M03W!=LjMH#TcN5tq838?Xem%1Y10amI%MWr_*;j?U~*9LvQ0Hj^8 zPxoUL5B**KG;PhxMTr+(iIUyjULn97Yve45Pn8cwU4gH##SA3*WN3xb$H_IKmh98W zp68V|zdw7%(3Yz~5xcC&2cVb32kn@MZ-w$faryFCt<{u(L-9rJ;y@?4SKog!e_!Bz zZz3KcdX(DwWtoc1eD000&z5;B(AYk>eQ^cGPb`Kxl)@g&{^2$1wG*mIRkS+Q&rn

    n*Jj?UH91?`t@?ke0(p7+8e;!Huo+HrOqkOUyc#GU>c`ct~y-vbFx^)n4=vOo`2jvKfh1Ao$WhpwYdj-lS#_o1 zL7jEqb>mwx7FqKZ!&?bGo4f8JEoZF1VOJ`Ft*s8bWRK-LMK^a#vG1X%8&@8t2lB;; z-x|>J2>_}b@!9L(c)Pnv<{fEj_?FI^90?8D0yqA) zC-&Kv9I!qalt4w9Qne1T1mysEg>2NSeBY%OwPQ4UGJRAT=&3ZR(hw)uk$rr9Qn#5Y zs4k-@qc~VTyymYaNQDLAH!v@|o`WKXy8xpnOR)P2!6XUn)%@TEy-#nmRwp0%iu?2x z%0z^?IA05Qy7uMzPZT@ga2aR`7WjTBc6DihbPEGdI$07C|NL9lZ9V3eu9cbKtgfRQ z`B{vm!4>`}DgpC_H-96yf!W$4_6U@tA%i9!>4q&u!;}61m0;OP^c}Z3tJYYRmulQW zhK-eN0;cwZ!Bu;>Y zk11$gV0fXHr7Vl=ee$b6GeBwEGz>{annc#H_Z%*Q2eUxTRew?pdcpxRFGc6}$#3pn zCZInLFQ(JQ9kwhlQM!`7YV_?6sRs50hP>a(Jm$o$k=KrOLQ+byk$XEwsnO8cx|V8m zW;y*m1!F{cJQ?l$r38m_bD+}s=siRejf{ualmc!FL;%;|jX((<#v5Z-E$x3yHXPg+ zj{O}7zhmStc+fe0q`v=*^DLN=7+u1-hm)_MI3$($0 zZtT)uBxfm(Cf*LSBxg{4LHJ!iB9qQ{2PXj+prTRi0TPtmIn@ar1_gMX9!x*myN_;~PJb%(tiV7CLiQ0IUW2<5)x8L*rEr*OubZ757^XPHvg zpOYzOYukr|QnG3KaZJrv8JSq{-OGKi_kcLRdEXwBi*v?o*OtIkvMw(C?IJ(4&3WNDWhB`b@{vvc$a2AY(ZE-5shf-6P<~CuK zCyn>U?oqP3Cvx*V&+50{6H|Nib@S2mO@mzPPph{J(yr?9`uU(<>OM6(wJ=@h8p@OTo_%0Uz~1 z-aK3}ap&P&1K^_?|N5wp^ai0aq4B>2tl!qqwwgSewH-xP{sf{4vqr=ifYh!B;Ds1X zoFDd~oqA(SC)PZnQiCnqDj`|R)q>R}ieu)UUs1|;8^p%a_wXwGAjV|_s4J7(0weJ6 zO6UyqTJ3MyCmMPyM=^y6@DwGqte@P-eD*Z$rGBF1HEJ>bBmW*GMwek>?>_da@@jMS zUjB{A$|6fM)tbK4uVMQ~W1TOju%$Toc(^P9oU{=*7axeA4sq4QxmC(i zOL&^07w(s9+{{_@yLIow6~wa}X$w5&o&Uv#Dw)(xiSNOVhqR<`Y;#;X5dXD^hP^6(S|!;Nf17<10o1O6Z{AafGIg(LI694(q}g${Z+jODFDKU!41!~9`AU-Nl!P7458`# zIQcs)*Sihg1l~&$v40&s@AtH7(yU7r!$4p<#=$UInPG+a*T%C1C#YKIOy_5=yh(0P z)s;g2F(`#`fy5VD{h{urCf=uauA+1S8}Kn)LGqHmA!|WEgJi)AeQJgYTZ3B7>^4BW zX9QC9o<$Bxu+RXpp*^np?Y-qK?MGzf-(YuvjWbNlQgGPJliG8BTy5V=18`ltT-uGauqx_W+YedoX!>LP`B);jg4Q%<$Q*7{LE z>cLF_QB3Fy$dKsE`&?8ePzG2j-+%A~J?GbAfA(wOv<6^(P67ihqV>|h_yRL9?v5q= zXHw4jE1VWUF6{JIJnNY?gm|?J810J!j3_Hm%d!v~c=?OpK zI$_7Km!aqWAqxqQKbJ`qsq#Y%RO5xr3Gc`H56^L}0AxR+dO7DWHFuN~eE8d6`HyNS zlBjr%I9&A^GT^sPBL8RZKM6YN|8peS{~prs|0G1(f2qjLyVo$r)o}nNk<>!<6J-Gj zU;hs_{bd~EPC1IN#NUGUE12=-t8#Sx9qc}O&_J#c+ONhFv8I`^R5$)mJf=iL_9d_* z-ED|oZmHO|eu8pP>&NT|slnG1J_?HtSw!gm)UhI7O6qI#Fldr6AyX?cB8hfA#jgST zwGC66M9}a@qoNlVFpZ;2@AxLhJ6nR31gUPmacS1afbfCd18e6ZW~es+w}okFqYr!V z!-G`OuYdRT7QIR0W-}1mkXr`f@Uup|LY<^*|4`F{O>B7|J^EUz$)O| z|B&I!!SzU=^PTi_pjuAtlx=kIuM7V!^51T3ZabTx+`bu1WD$c9fT8PtlmB*W4gdAl zr1o(j8?f$SM_|FPtc*2xu7k?X4pGaMon$h~O$dTdYAzR7Pi#_^wqK748&!DJ+SqIz zL49>~(n#KItN=UkvJ<*^fLecpWRu+1m8*_7+n$I&mM^OEUAvSE$_vjXeFKQk6nfzc z$cJz7f!4-z-j5|_3l;gGkpwDmv_re-K1AG2Foa{JWC4Ua%$?k{A307nCSct#}&sZ`T9gDFj5s2g&^O%A2@i zV#{2!&z-)RXHD)n*0c?CdkQ|{1ax*7U+x{xk*?Wej*J)qI*QxaK6QcFfCZR>C%Iru z@up^}EwvXqg*0;+vBsO)9W2kXzF8H9zzeez-g);z&Nn~7e+}&BHMH`qp5DeCn1=0% zRH17!(6X(0mWA;xOvtH67kJ99AU|t%WV@=Lrg1GhRN&dCL?ywu z7_#4nMvzn_#vBrtA=M)$l~5b<+H!?h>GW(-ufuyEd3)nsQqp6xj zl+pdgO7{Gl;iRPj&BRN?LRlzf)OrbsK>*9JKZi#0Xrc{W46}QK#$_z5>|~V#$FqKm ztQ|ZSA!6tE+5PPw(JOBiJ~FN(ym(t0d< zpKNdcnK46->c`dGsJjA81Eei#3 z-j3OCxml%*ta2;k5nt z(mzDTo($?Aqku{*D@+(;urbhz)f_mMRo0H7%)Oz}rf2(B;PHUs$Oylvq%NnD0B!ow z&VK6#h?VfX0jM*(BU8VhzWCkRb^-aS%;G-4Tr4 zszkKppMMo=`7F?qBI#o0ik75EEjvxD^1C-C5Kv)?MFIZQ0m*>Bz!hMS2P%Q+unUz# z8ckXU!(?)nQ4dFHv`KfN<~B&?P7zo&WfWN_!u5Yj;QZA^F>UFpYY2JX-jd4R3YQcN zzUByXagPdBiLN_@@QEtPZPaU{*7_!BQk<0R0C(>E>Cj-tXtTiicvi%gbNWRjAc`dZFHt1a z6}Yo^B#0i!4iJmIxHnVbV%=foR(N<{@Te1yRm{wX_|Y;uv46-0J8FN}vyg@GmK8lH z2G*F-f@xy=LQ2=;dWs%erC$QbQD?>vs!eFl zxl8d>aB$aMc()qZwK`7y+H|-K{_bW_EgHe$nx;nFe|Rci|1F(dykv3RW@!Iclqsh+ zsgLKj+qEZ9$MC}m$Ypr9GTaT!LYe>?-lZt)Ns>R>n`TWuH#nf2ab<9;sOJ0E52CHK z#t|HX3cl^+-Ri;s6eRe-?ZQ!EKXZL0{InP7lCks5sSCGE357vB?;F@w$nyEYMwmtg zd{{Zonp;<*$+j3=Kj-X*w;MxJ*Eky`j7ZdT*sw1E+opD7*$Rvg`+lqxY9&+{s$R(Y zs_*LndZN@hz*}M@hBlaE!6MDv8<<9613Mi?q8j8YN&o=}96MKKe`k*M;;37h?c%^} ze~#%5YeO!1gA9%+UHE%b*_di=cyB0her(!sg`yQ zJa?Ae(+hs5)q+JM^pq60ThyLxxI~95!MmTT3&GU!soCa>w8~nQXlu<-UssBWUyD9w zE98X^J6?CAjAYLOg%^M3A(j`#HX*#ftib!B7izm!3j4$YJ^AK}UB(61AO-d(w(tJr zS?L}WIEQ5iEpZSxOuBp%Ecmv`-KwRYp2ZR$g(QJiSpfziO&#tZN`exWCAL}Rc zEb8YYTFtsUF;70sR}3-nl*|qh>kCk~QR{Ev4Lg1Cq;pV`It#(JE!!B&5Sc?xcQ8hH zY2YcQYQ)+-V5KXNOt)`v2PUuogD7?3Y(WSCQ4x&M-qCi-%@|u`oGd`4{Zq$&XP4d6 zjr-w*R={LTlUa%`eXVR{ZS3XOR`c$`2pRRB0+bwlJyUtR5iPY4yJL>M`q8&+Z8;># z*v(6_IJ6|_Hnm{h@N+$ZA35j8o8Wycrh1dWW!T(DR7aE4SWCi;y9N#~av9Pj@TXlhdy@9$h>HJ{9RB0QO}x~7 zd>DZJ=EwJ9+ItOT@GiQTnLaaIwgS_NXwmCm9$y;v_ZKABLh|XA%^O47`;-v`=0jj2 z=V5R#JEVRGA(`^p%0|~2XkI{`z}j-n{aZa&G~mJlB9_;ZBY2O}%H4v(i;N9*^sYOm zyb>eRpuF*F{MDl}IY0$6;@|uApDLpr|Nk@E|Mw)P{u5=i{~m!Yb98Vw@=R|h1+~`& z^!Ez-fj;a1_^W_%yvt9AC!3|a;om2;SaM!YCtwDSwM`Rn)e(4(Xcg>LTz6f4-p6TVpuaG=~B008tW#}FI0NuvtG zkBe?lvLz4nn6!41K%ySS4M%?G$zbH<*rF7Agg}eu2RdPin1xE>VBF{AntNx|f_d%dkD6`*X)$b; z)`5QPp)yhOGQREN)5$IswLl=&t)?ym^8ipr&M20jZK!0fvHqN^MNRT{H(DDF?{7%_ zu-N`qtN*oL_rp-)_ZO_<+-@sJp#3TMg+0NP__0fpAY6m5@MWDv3Y-U3pt&bcnHH8T z?es1wduIJfyzLVBWvNEHJ^p4>4sH$4A6r@c3xHj!23{flke{^O!;SaU4SjOTJn;Jz z8Nb}e&sdmo=|m1hVBX3^c^)phmQnB;J>g%5Lr0&UzZ*1VMoj$fQV1VFHJe9tU3Z5w z%OOA^I%ulKV`j5_OHH_|fnb%sfk32lVn}ZSW7J5DDwEir)Dj3FPlyEddy|ufP?rPc zCOYglo3*DKeH09e=XD3S<7(av@>ChEJ~eKp-5ohTJZQNG)XS2?N6!?AzY*uVljiTj zC+tLxq5u_F6b*3le@pS)*lU9n$L$d99KhGMjUW6+5Ek<)SHq;MtX6XJPECybNArvymy-&tO;qC$o&3BL=yWEiLDxl%jV_!PKR zuTd5tg>vcjXTG|?R}@ECC|MjpC7U}wp>_M${6+MSs7u||z15r{akxl~H-QDdf#?N; zU`Ab7v)3{r0tG0B*X0>VEK|bT)}^7z54E@r)qA zM$V0S?c#uh?FtW83YaAyMDO(em{J#5byo%@1#*^5ofyb+J!H%^c&pkTx)n2GQ$d}^ z{^k!wjB$iK3JQ;0YlKITSay*Or}65_?g;cKlL0g-52WL^FI%DO<*Z99Z!g3ht*wzA z(w%;3mBudsyk6l^h#uVEmXVQDISNO*O+gO;VFGW$yVAb3^JAbSGdVB%dVX}!k|mro zq zc;VL~#Q1PNX@1v+>AEmlcXrF_bntre19(pZK3U}-GUy`wms0U^PbBxm?# z(n`+G{_9N$k2{|dW^3hhos~hEp}@Cf3G>IX7Jb$H+N+i!KTJJ8FL?M+;UGyM&W@KC z8sT&4;e$vTm|^hxAuT>=;ZXHS#ji)Vrb~_{EDtJ6fAp{xC(4Y((vQB6zP766_t$Q} zThacRq5`TlG;_Hy$r(pHGw`;Yu;F=|K~OO`pUv(at1)RBZlNlZqbb@D(aBpqEhO-p zBRUo4FtO15cEERlHih>Mi(J?E08E7@maq1MgKP0^u?ic}pV)24HeVuT0a4ZZOjAb5paT?#@Qm|Uw(bQH|sP>I<{!yZR$a-eHrRsc% zxd#&&`3)ZP4?p?Xv5BhLd*lP`I5ge;=r%+RAdy-kJX&F{Z%)+VZ@r{|aZ&gT9WeQ{C! z@klC~a1#pER@^>Tm*a7FdJn3nAxy^5n13j+WPhsuT zj4V;2K;elEpl~w=r>rr4?z+9#YzA;nGYIH8Y;bdD*CUMeigRSM&I-lEzgDn0+C=b9 z(-q$AI9}%gu=KouX>V5s~2ffNE+tF2iY`B%wqV4z|^Sr2~)*?<U40+3iy2!a|$tvXfJ*w=THs#1fm^0RM+`KmX8+-00G2Oaf zp0t%#c*8dWtOa+2BxbMGtnF{HR>yT1l!r9;E8_}rbYjL>!#P~^gn@5%hT9Kn4r%Lw z(&q;Q=vE4^>TIxE(ufiM1@g!q zQ28?cxJMz~-51Z?S7)^==6&mXQ+7r#&xGL6{f8d%ml|u}A*fYOg&L2di62O=KcHwF znEFr^Xt^$~+03eo|D4^%DDNFrR(+Hq99wI+FlxnEr(e7IWy9i*66gZ}a)c~``%n$p zU*HF8JawaJZ~C?2;x!x5@|V?)zN4(&4=z2e(`$_25KsO>c8{+fW3;&gK;Tosbo*Vm zLcIPVGl;tDQMb!huXq;)T|R zr?5r#U&*SaQ$VsRQA&MVkm|z&A(sS>yOh-J{EB5BlhU)l^3ylhs1;HPH_Jmb0xNZT zQH$xJLI9oQJI}*)lP|SV=6aX!l9>lh-V>(axsIp2U?hz-vyi?wtM<|T>aKyLyo*mUwwH6H+^7)S}FBgPyY{OMz7I})!MrLA{M&d~m;Unldv z;<5(MD@Xtk6>0uM_Tw8#$c6M$0({c8TBa87+n!#A3C5*xA@*Gg!zV$E$Kp*^6myH| zG4~t$aNOuO1<4|AMe*xCADR?d&(_x0fRYT&-`S$e%P|6SF&_k8L-aoEz83IFnbegC zRN4u6tR$Ev)57z9-QSjyz$}c5##?T}Biq0|5`Mb_g9CQgk3G9a{fq@V8r&YHjnQKi z4j8uD%EXKP?$Netb}ky#?f_Im;Kf2<0+1wtuLndw5$GUne;4A)=qjRe)DjyJC2e+B4ru$KI*Y$&J8n}RpB-O;ll!!c{A?7x|B44x(d_t-QX3|k2_cu zo0Hu+`op3-u0K0lcf7T(s&A`(D2?&?)J-x3oTy{`gRRXryddq+kT9IYXl-&=J{nj> z?_3`!G|3QK60d)D#h2?rQSdW0=pGm^*4W|)0BDZB{GtQ+(XnA5xRKT)p1vNz)P zFD{_r6Kj{%c?o(G>URw{ZaOjbm$(gVAKk+FDm{7WA4pzr;LlGfni@@otNJr?=@4*% z6j&R0w{XBh!LuO}2gZ$p=hX#Ky{nY?%25yQ2#OiyzDll7lji?*^PQN$urTQG{vQc5^tQ0ujTTGBirOnQy&Ym+1HP{# z?Eu{H6+Pr2oF<(27np;@4GeDd<#SK}{*&t|ik=)X&F7|!GI0B`T*H4wkNiGLW>ZOt zVjUq(Ecjh{0>_I9ckiv}Yj|H7K$aG$>53#1Zr8n!2p1bit=FpG8vj5D?$jeG+m`I#_7uYFWG8Xg&F^|y3H#)8@ z^4*@6eaW{v3;jGq_lMZ#)sn5W`q=w5W$d#{>p7UQYoxKRyZFqDTZ;s@Heh6OL0xRm zN(`U4^fbw)BX*UuD0#WxIV)XPV)F6_?QVx5fy^&G3=a7I0s=o4P@0|t%qyn%(?|*a zxfG3Swn3O{fkAwg2^C#gBm@27?WfmtX*r_4(r>JT>(w(aphg!0ZeUuNG;~8ONy1-0 zT{h3_(ERQ4uO{~H#3J0d^|v}ht|3@woxQqgAV3wD7`8VLK-!f+pl<~)U}1vy>*Ue$Ot22No2lSu6lC|ByKu#oS)! zRVM77XZ{&ka}VxUtyLQ-FX6v$QREt5UMQ?6?qd=8hu1)^6d-lpMgdZX4`BBY=w<*s z=m?2a&iT1|2fI}0Zq>qFJh?C6aI876?~rOPd?+fi6dUM-K`d3{p3JIqlfHBPLxxbj z4vc}d<<1w^L2)_XYvn&)t@ISf4mf5g(a&TlUDLgme1+l)<<$-(E)i=2V+5?M5)dYg zOLc^LGuW2oPb}-VB#Ig23Qak^_T6+e$qrW25uQZpg8!eg7qeOE7iBhB)Pli1d^#G8 z7luT7bg_ke2@$qRU3!{*ux6h~%#rQrBu&5U6G$&B@GQ`{Q5X%9V?VT7-15k&9Y%z^Hae<)$ zYcwJ7M>AU!o~x^~miBHe_n(f1aI((dWjjlq5xIl33?J#D0;sgj``5SvP)U5kvjl+c zQf9}fb>dH+ms{1tHuohx{)3E%6{`Hy(hr^H6ge+G2ky)6+BqPD*HOKv1;`0G$iI(AeGC4Bpqmy5nA2TL9SJ zxIo#OwyY<RA7Z>Lw$N~Or5h_>BXr2GeJI%fqXu8sIz<3{oaU?2_+s=S2egY3 z?^NQ>^z)oPZsTHZN}%O>`Oqo*lvZ|TlO7*?(3hB;e`bC(=hZ8)Xe%%@;LtoC4HZ=c5d-Mh&R`ed~>n0FbJvdW2P-hc?(%>AMI zeHa*%_zYeryXUHB>3ofw$xua$OM6L=)?(drS-m$V$E2&Y$4aUX$xT`YH_WAUao~gd z&ylaXm|(J3xwFQ-!Uy3MtDz;VQUUJ*BlDH?qZOq;4K1HRWQc`-kSTDC5kov5Gd^bB zh+{8Y4sVO5wwgTE#?tNQL@j-bP|;$U z_%>_xy<%I3>V3@JOP9>BJ1HEg;b6a3Spr0-F zJL|TY^x_JolkqT_;*-?hT?I&M=CJOOvR~jP=U1D^1W^4NK~`%2;xG9y`?*)j)ml%_ zlC@E&8@xoBSfZUlHAKY6j8u@nZn#Mq1)OtHF8FP4;HtKeW*e*-(DGp6-b*sHZ-kzC z!xGkmLd>qDAtkt0b%(#4_b>u2rO z4QT9^FWB()pr`^6+#z$g%lHdy;kr(Y_;2r9*v8V#4GZ+yTf0?t*|ImaJ0p6lO46rA z_f$-*e%c_#Ok92fbHxQAas4RH@Y^s*3lLl6R>zR80ii;J0nN(u?d{oZYmR%@a4IU>iy5C%P{55gPM?_-`%B%SCSutDPlt-!D}t) z?_Emn9YEe8G5XaA2!kw`1`4Tf?t3Q@V8mpx`^5Iw=3^S_R!dVesE;EV^~VeueJ0LV zgb({3e9zrSg`C3&Ab`0i!$22ScH!Sn*BE#3W$SeA(6<4ecE5vKvlLR7mwQH3bKh6o z;;>WQXMznkkhdd=MXGuic6esoB8I)!PzoKeDmvX5e;_6Mi3_yfDatA3m_Hwi^HC8< zpiU_g9H|%S9^O0OLW5GmuTH4T;8oU9F%lATD3*}O-!7f0ix23Ee$CDv^4mT#hPZ`N z_-dy#hx%!3B1hL2vvfCsw_i@6apMpnjZV%9Y-V*%lYtU$Tw|U#Ny)69o}LAo*Go_C zy&mM_2aM4*1!|Uga^`i?*VNV3n15=bZGPn3e9Xm>o~G(*q8aOSW~xC6)Kj9&U=L^2 zh4Etjr(J5;{B|^$>lgcox4$Pa>ARvy_okeS`c{<5{kysug$fc!n>QH6{-mNV0o9zG zYy$HLZZmgN{#B`7;JSB$d~i0irDn9HU^boqwT%0*iF+gOUkKzz=qOx(wlhSJvp^Ol~vc5TUN>yj{!wB zyeKjOwJ|)Czhpd1Bp~Ghx+39~kA|Gx?K5 z!$(2QI(^k~CWH_qdUQJlZD4&J?yye01^slZsVP-$k2d)6!vcePjvsGR&lHcPqm&_d z@j*g5@-loLm^VAgup(MvnyQNj0q3kcSKO8&yEP^8+iJb$Iu*sW?fWb82RmxgqoyY^ zKRR+;wvhV{7xxIh#LsXS1XGC6;2;>2OwhzU92dyho7a3Pu@dv`?#uTwx?iKbWrWPL zp}ghvG_CePF*dG{GzV|oiB!Mwlgp*Q;vX{ld97f&mDw_XUtj;w&==Uu*kJ)n)Ac5* z&y#P~Gm>f}ZoCBW{1mB}yl$gpB=f<6-I~U1b>)7;wtcj(mzU5R+M^)x3EGok{!fba zz#l$KXXvd?kiL3l&b03N-61-1GB^+DYwqp?(=+ew00?`R6fBIGL82hsCB8RGL}LMF z0iKl+2ew*%waJAgLqGnMzHFLp{q?WueMhBQ{)lvq6I2qYwz&^M0~4R_aKe;sf>OP@ zgnrHpdVDl?`&Es}{cL~BwwSai2=cnqZ!+z~Pds>6X?36Y#&@rzt z;Lx?tWIJ7#V9NN{7j6VOlzCsIb`bmZn52F_F=86r?JwPZ&}_g|V_2A??9WYFEBOAq{PPV{c#_A% zqyfF<-fGr!pvp>7gD0*ZauCR-!WnGc?<|E>bo<%#cnbQ|Eia7SUDi_7_iZ)*CVj^y zQ-p?$({Hh<@4k6mdg}$b-UTEC+Q+AWx4h7{-hGkvY6Az^&x1Z)K6-?{A9J(CZ`7B$ zM1Z0`G-N3~t#I&vR|<_2b2yksIe_8`G>YbGf`eYmmAj?5ctoW?U?Af>Lfit@(9#&#Eu>>#6az^xP%4B2Di0lnUJ2 z6*~oi+e;C8fmbBA)WoZv6O@Q0a#9OBxG&>fTp^U`&YgZ_w4Fp-Z6j!ry)qmJ@qRr- z_V6DvKZ8(u+)>Zx^z_zXM)RL2K7!3SNj!W7@Mo8>xr2+B4*cReg5To913TX#n*sfaF@joNiQ=Zb;F(;%1cr%yWlR`TV?Fj%`Q! z=TVlUPx%L5#go&Pdb>=veDq_6zUzEl1L|7N)e)d(Pzo%x@WC-aiwNnhsCX%}X%Zn2 zi&m<1Xlc$suknw@(NC0p)unaxS|lr2M^Dzde1Os6Rj>vd3XGfTX!g3n35*fSP1Oc3bcCr26T*m z_vlv_8-|ouF;cM9+4;GyXHq1(EFU8yR^u#j%v=80UI{VZ-VbhI-(R?}fcLV)p3ZRh zanTWrj@|Yh!{RG5xPx0`q2@4EpP}?R)d$bi?_3)8*82~~s2|Kd-A+M|NW*YCk_1c~ z3xq!aBQZe-%h!rN5aK?NZs0Yy%7MnV)P{v}yN?Ke9lL%@DbYc)Jst>&8|pBnkp$sS zdv;P&0WZP2sF{1nr>NLf5uw&2jhnxnP3eTX^KIVyLo&gDv_KMsSGGDaTorIZ3abX6 zZSh!ebrz-hgC*@Em)=I4)vHuj*-8v+(%UaV4|=ka>YQH3Umv zHB=;sckp`NdISA*U|PA^DjItI!!qf(wY$#|G=FVNmAV9Pu7fd)DZ+DBuJtyV$zy(v zx{nCZL3!+-OSd^$>I1EI%F4iiT*>QoU>5j#t)1d*t`6P}^qAiq~ue|hA^+F}PZr!-7H815u4Z4zCZ`KB?!b|)ymv4}dlZjzaq-&>cp&N&Z zD9WyzZyelcgRgt-Mj5EQb?H74(8F&oqC&c9$!`y-(J9p3jqB&f?ES~Zx;_EbF&$Nd z3q6=Lz7=yOJC>l3lNyI!(ROPfGL2q+O(8V7%^a!wcWh>fHFj4_`)BMw}mAB@t&6f zFDf5VbYUg3V-Bl}u1NFDE&7dIPoMCO4!yOy;TxgLfv)~r;)DMf{j01omsd^7>b5hz z;13zQj|a|eiiL5QFWOUak4rtFU{66I%l*@uYm~|oN=Bj%7WZOH*NZ{ZAixc(w^X}< ztXFsyfLLr_|GcVDga3sd>XNn5@)g|ctv2+M9YIMGinu(q_}L!H`&7hI#5j4BpYjPd z5I@0y(4FF93T6b|Oah(*zM{uUi}<~f^&opuPGv6j7wJi`56O`OA!uv-uCCZZ3UUp9 z09>&%^*I2Hcaxe&^__AV=(rIZJxg_be!b-aE6V4EL@VK>e1fTF{h1+OGHYuqlAF`xAMqwiGgIX`xC~#yz z!skHs-`^g?>^d6Z>oEr{4^!wGUKA>V-?&ixaWY+{cmA@jr;~<6!;8Q> zuU$i&=K_-%QRgw^!nkB0%>v}Gnz9icnwaLz)e3BS!`r-oz4n7kf^E7IveQ(1UP;^? z=6<78m;FWmC7)Lt_`fMjYJ%6hWq>K|_Ur4OII&fF^D0fFDLG0ED~7v$*W6-w>VaoJs}MPyV%y7kCrbRe7eml2$kHH>P0R(m=N>f z9&|Jtr4iv`t1wHv7J8|I+nD(A#oVD2?o2g;V(e6)IqlF}Ty&U|JKOh4_y~RpTaOkV zWLRuABBlVUco~~L%4V4iOC9D_Zev@!BIzG8D=VFLM!tl+X-ipkSl=*yMTBC_H@$n; zV%w0>9nytM7JDQ~Y*vMXeTiGpk#@c8ldlC~%_4O&n%?wh2ASQW?EFfg3?voI!4qRZ zy4H%lJckwsW@eHG6s+=6I{Ux#r)U=om^WEEf4PR1P0;=Q<;8e3aYbtSHR&4ULSYw4 z*~Rip{Wc~pRaK`V#QO1!ebe+w3iN5NNz#GyZO5piyDChTM{OvZERHWj)eBM!gCxV9 z4LC7zQJ9q03!#U1+g3@SiCN+wGEDV^u)MMT;^gY{Uet@q@97_j9ULx{yHU)z*E(KTs*z4bQf*! zi_FbfxHCMDk9k7!?2qD>3IHr_G;EY$;utOS?pd9dsJQ)iE4`5M;k;je&oFIi8qeG zn%dtb08|gIhEs)Dft!Jv!*rEnBGq(9dbdJ0SrB=_T`z%rX>O)_Pawr$9uk!+l1u%{ z-rChbAwIj0&u%odWN*7l9(;ki4euT4CR+1q>u5f@kWm74viPsw!h#}X5es(51HO2q zIkLx$1X6x))#m<$&I$?_JGfrA>U9kJMbF}&@#tGnwFohSz>HNe!V4F{^zfaV5@CJ7 z3VC&_NiWSv(A+Q;C2FWWiyw32kND52gUDQOt(_zAx>O2D5N3tRjspg{`S|PFn!+G# z(zC+CAeZrg9cb=|kkU|KYf7SmQQNCVxPDes)2!L}f@NQghF21g?}uxj;_sAy@F627 zGkL-O$Y$~N+~y#Gd6V?$0#^wDFk*N9A$yel=Yj!(0AY*}XDWw_&7=WtBvBbM-j)hy zF`9pI){ASzw-*waiAVs1qGs~YX4pw0HjlA8^bbv+Yvrct;W6()@&;?FVzm<%l>#VY zZuYcgrx3i$dW&3h9%w^z-z`xkDw8SKOZSw2690DplRzW{iK5dgJut;G>l2IA@2o7j z@lj&--gVGzCBGDcS zX9_9z|Gf5PJ+A4v@ImZKlpl(vS=EcZ#^+&1TvBew|I1Er5Q4n`97t z0PH*mIwUD`cN!-5580a@m@!}tFF?c_lK>(j$^ky?MJz+@+XI>OWTzD(7IpO2C=ra4 z0$PkkT((bE-VJUb$}SjefJ#HWIye5wI&T;noV0VHp1!fCC%NOLa7W{)fIPV)C0b)8 zo_DWo`j48zgDJ1Zl;^u*+%z2dZoh>CQ$-4ry@G?EUoMZ(6Ij1S7&U}z5!*U^y(^&S zZ@65(fGAh9>+6B2DYri-v!3<1BxT5{CMNP)@}>0p7MEL!x=1r^JeWgH=d|o`WB~^iId;%~Xf$H5c>MO>j5wGX<$c6iyV1JlBu| zfao!6m;x!#PY89x=nEiH?#r1DX0l$ekXe3vqal9i$Y{%pQ75vIX49XsBHtHzVUUKZ zNA#PiUfMA92TCMDC8t8SMF3fQAUYEO1N5<^0XpC*X>~(N8_$6HGez1B(pRQSOMP5% zq@*a6(Wk5pgAJX{!TsZZ$Zk8}f&KUV1a+>US6zTwFSX-soP>`iJ2*z6H3u(vECKHZtKV9KJp@E#DL=bU$~K>ScCCHBSK^eA&SXTvNg#TVeGqP z$-d1XvSh|O%;NX%`#tA-KFjw$=X36J?)&k(@7o{qhifj^HP`!kzu&Lz`FcJ%J>XZ7 zE!dU2ST^h;E7-zc54^?(RvGeP$@Od6-Or7*Jf0(!P_+u!>F-E+)IdoW?G+<(dH`2O z;g+TuIN~>{{#HP>sK)H4zSk|bf76B3|L2sQChr3s9 z4g7r1bzC^mAoG@Zn8@d>qp;0r=?y&gIBYTtz6YU&5_t+jOjTWeb3#N@%A+!9m7cHI zs_V}_kl^92oP3sbvM&979=3?K^ z%(HfvKMihjX!6|hw%YHes)I`iK|VJ!PBvhk@9IJU!dilUR}g$}Nr73zI9q?opjTeO zltIiCTZH#3B5tyRrg_H>PbPFW|!MP&fcEo2`K|Rv)%PTp>Uk;6j!Qe!)fX z;(-c8_r%}1vq6dCmClsR`2z}fc%PP_l#jcn0)T@iqbxB zEVI55w{P9vQS_l>1jD1pkIs3WSUSxBsX4J-`ip)PngncJtqe`r%9m@QR^%wqj!gCA z3AgL%-&hSud|vx}tF+&x6n5hE9oj7u>4S3jT;{Puy&G3Z`s9;89+*=!^cG%@yrASg z9U+&c>GFJdz@T}TGpL4prXg!nygDW0=?4>hiH`K@Y9pEeDrj`RBlzb~AvH~+d^5Li zQ_qdtrC7Z&W$`lQ*^@FlDfcd3TzqXiJR-MmpyNU z%3ZMf5vzwPHIli#6mK9*$;joWJ6|IsSna%xkC2nQh;W>Q4mRtO90+ZjIA{>XWC?$8rbfWEKMG<1=itm2i zbID5UraabRMV8QgP7@!}LJFME$~HGcpQIfl6=wTBFj5LlDi}S|+wgSL{!=)QQvIVQ z`v?14Y)xX}-nqGw7wJqdK@LI~&qfFz*OHBSg}Ng@6ocDbI;0XbORTv!&iZYt4?mbY zap#HMm*RLI%Ewn3?#-~nwV2Fz83}dG-v^$6qGZy<9xrV8c2Yx>v^9}EbgKVNqD!aB z<hHw3)AWM)iftTq@62vId~?ivmu|pbw6JNj2w=#$lq;mrNYhvHn9r zLCN=6v8&}JW~*F$=AyCph51eb>eJoPBncLhqDb=l`i9=+5297 zf5k6iarlRyyi>F2C^hGe`EP&CW%}H$)!c&dSke4T6zK7jU3*D(xaE-IE(Vgk!BgFC zMc?b={rw!?+Cm$xVsQp~r?@(F#o~0|r$h+fisTw%L?V2bY0Myd-aH}T1%0}?>DT$V zV!G>ou2Z6q3tPfs{K3x3CzKi85ph%Vy?6uVfjM;^@iSWLT|pYZTI7%d6i=co`Uz0u zg!46|T-fq64T%~HsY*;bUduPIihaEzYwI=Mp|_`_Tr7}TjPjHSl;qBk)e#qn4qXwHGw;ziDv#sj z1%R|0VLOl2Rn`1c@u#w4M-S0r5&irFAur<09@^-R#HVZn9%vg(yU4f9`C3QUV?ApkUU6TTkJQ!Eibugv zoI!9__b$1uVV|6xPP?l!?)Oyp*0ThLN`E_nOKR^%2cZpq13x61-G@eS+DlNJFG8Al zO;?35^jXj8K2H>5XV&}AdW}cdTAECQMQz=#J&Fl0mM0x^1euwZyT#ZDk<-Q92T)%N zN(5wUTU+dm3quU9O50Q$7{O%{RyPrdJm}7bIN5F2d+XDYpFeLTyURNW zQfE4rlVU&W3aXlkNg6f!GwS&$J-!?B66*vVvc$obba9`pS@Bx=-PTU|T{m;g&o=ts zv2P+ow#~JWFHL(noMyNgcyq-HMbLwV4u}9M4DBb?hXG17xSv)goI23GyHX}Jrx$`Qe{$P9f)@JNR=S}aH z=-6Zf zH{&xd>FAPUEG{K=__t*ios#^rueIwlVlOpCjhVn!(rKq%QB7ozKwMKn=Pgte*WqdF zwKDW4Oij++c$S+<&Cp>8;MU?73bKU0f zyua+)DYu7df*eZ;tE&nMLC9Ng!X@TlLwOteBt5dsoQj`W{b#42N^I9|R`)HZI#iag ztQhHwn2kt;b)ZjkEJ;HfFbi-vhKG_|ve^RNW zuj9e0F2lR~(kO0GNxRh(GP~V@x%>v_3MI4QONK8L*Kn6 zoKj5nd{xqdo#pQLp22j*3=dK0$R-FIk}6OVx$Pp)b<|lOAK<<6<>Dtk3-wnH7UGEt zwa7uZt>C<1}Cj;TYU*#Pm-worlg;-X@a$n`{|&W5Xob5F-o`PqEUQMBxpt&d~jL zHH6TS$dh5XnVGDc#izd)2?Uw$?{D{Z1sQ(FS@)zkWki+qTk0FwEmim7r=~&fPoP{% zEuO9#*Hh{*mxMN{x?J*PX;6v%u48bvZSj(h02A+8SDhimWr7WHjOp=umjIm9c{fPg z)#F{G>p`MrvrxuGi($#i4%aVRDrY1Tm3+Q7URZI>O#Tc44+$qiMDJvFeU;%gk`Io2 zY-I|?-o9T2dChH=qtk<}wj+NgmH3@+)^}DzkifLDj}$;wA|+6?3H8l3a%Is!GE_?W z`MtT!;WDbFGQ@(2ldR<*+S=+R_A9vjjF573YAI72zz@{PLlEu+t>yaV@UzCw6wWJbf31Bl{`V@X2msz zx8C+Xmii*`wpbwmzrR9rV<+P#in^jH*7xz~1I~Wg!RggWooK@kC#q87+XGS^B8$(c zO?ez$Gc^i?U6V{d@tnImO_~7RK#`otr%56(I*P&v7t0GYug-?9?_<_qOpYf$JfYA4 zfn3ea47n;@iv_%2Op`H7XA0yay`~=GCU_p-nC|mzin91&bfHP^R_r1B!Pks8ONb#d zCJ>FOjHkgt&i_d^asf~-W&fcvAy}zNB-a9=CjCjQpl?WD+qP$7f#ZzW$%do;4{hC* zVBW$9rrl-*Ap@huM&9zb3tXVG6k%!t;MXW>7Q!^9`dIf-e27fuPb|CMyC{gZANs_i z_VP}KNi@%vHiSExjztF})(wgwEo!XzE-un6PQDS#OHwr>y3TZd&v;gn(D=N-<5c@2 zSJ~=QA}j9}JK9bKDR^vBd92QGu9nrf4`tS%AtP4(ivD@a9Hi{VQxCVRKj&SMlV7&t zsyW4IdXX`lB^Nd<7I+a`Jg_*6GaL@XB?C$Hr3=e?L8>k8ljTLy-?i_vR2+A>XZkfi zlI4{b1IIa~wPQS1h}?d)Rh&w_J`>QoN3kPL5E_cQ-ugcHCVMmPM}5~}V_hFx9)}n4 zA&~u(kQ35h=Q3h-p@PUUY!LzgPcb#Fn)Md@ooUCv&R832kJesH;yi8^SUAa?dHZ}E zBp}j&(F;~M+mvS*g{Ci7zdTndB2J(`CIQNR4~)mg~q?Qio{ARexpnj(n!R z1iS}=fuIQEwdOdK<+&ZC$^ozF`u5UL83mU7E1kI0~j1v^2b6}vuy7T!Bh*9w+tZQ;xD)uW!9UYL|T%^0lGX`aReRKP?5 z$ZT>Tyqf-phzb$pp&ui(Z+h64rbKRBD+v57)6?o~R~(*@oE*O2TtRmvPCp>&?^05v zZmew{nwfMK9x~2G8kw?|uSwDq^KiQDava{4q+x&0Dj?a00g>7k?9?j8rTac+YO@YQ zkKmz(XdI!OCHZ7Wsa))#s3ZO+i_llpDq1ElTG%QvcLGBH^YYd#K>BdLqkR?OORDK5 z&6*G}VaxbCUab1c!k5U-iP!h&I)=<#JsBkGu%DSNwo$S5p6(qa=*X;9Lpic}G(d~e zQi=36D4t5KNmUHzs7-UuFo-$q(|YV&?~5Im()QS&W-@-mR4!YL4*nKS2fIB1$_7Q% z2|2^0lWv%GS3eJrJQtx?6Ha|4f}5w9KD}f)z*-2xRoz>xe0EL9j){+>=pvC9G=9Qt zOi6%8T|=jspFTzTw!nLFDGQUt)7Kry+0zq6G6tio@EhIYQujWZX>gHd$aEA9YI>zB zG@2&ryV=AAgsaI6d}ZDomQHhB-x*4cY|YP|-bzlTqfErk35!g3B@jiSEA+Cqb1#ovpoPYy)Qh9QhO z?c$Akg_K<0Xt4^EM_lxZzZJ+EI?%*Zcojm9{-x>iEg8@$)sh(y{M4ipr%H3&Y$fo~ z#G}%!^^EOh-Gw91jx-D9Hdh9GS49h6t<`06-#}BJ(Aa3-*c|hGTiuFdIGu=FC*~_W zjv9Oo(g}5lJtP)+iVqUl=1~$T2K_LXv1k?1U$_+jG_GVd1by@ByoZ^d0?nPg2BD}d z!V9lMm)5MR-elc;oY?>D(@KW zo#`vPcI6hsaq&yTfqU*1=1Qo^`db5OpA&i}LDh6bkT4s-9mgpes$O~1%)7VDdt7?R3mX9xE0ywLVU=3=CDF^@>>iIQz4=D1 z+2JL6TwK0KVryrWw#}?IA6H7?y7u_G=o5S%E0T%}gmoUtF1g+mHkN#5OE;P} z9rr7VAU2?>X%~4n2rB}cL_=46CQ96?kt(olPb_B8kEF2)Qe^}rT-f&|es2suhM(kr zo#?gRl>Y9Jgt?1YoJ(?=w?M>+%hD|)n%seYy;qVOOHXXA zP5w%EiY`~XPDNSJuoD`hr=ahyv3Wj0Gq(7YT@GlJ#(hB*Nl^EX1B7GE7${^UtZzGj z&8yZMeSmW4t*=78QJ>Ns#bSHC0^=Esyu<#*twf)hma#`^fpo*4g{*!_##v}wr@p}2 zvxlHR2BcNF628wG_Z=f1e5U@bDMyC;3g6)AXvGufA^TVhYmIf){pj8hS2u2eD)$EY zB2hU9aH?Vid~Y_S*kCi;WY<|;3o6CGUpI^KIda3E%R6CoXd95KnjI~PiK7W1TaX7p z|Nb>%QWKC@suuIzy2-b(UHVz~QPW@!?4hV4rHKf43Y|~x_$aA%DXZ_;H@U=l z?YO>&qB_ApHp+g>4m~af+Y9k z=xl}@XW5#c&5Q6M&4M93xr2r5q;Y`5IpCUkAAM zPjRzLXJ=OD`EO>iurOQg;c#uS35@d}$Tk`6?lrs~6M?;r9#oxdUM#|o=`~f;Rrf3D zn;91=A6s`?ddpGQBNKg;!}5I4;?qxYz5)WX8m+|UNd)W=;*7*&FSsBnxc;o{G`A(( zV$Q?jT-n#Iz*f~!i&5ROJJOHs8O?+DGR54_cp7#7nB6q{(8R`RLfK-gN-V&wBBjt5 zGOumDjgyz|aL|*Sxehtr@j(3Y`=uINDoV>2-Gq9SBHz^RDm7vTG%pb< z)VP%jSlId*#et+REc;%(R;?LUo_%X@Hib@Fmi>$2&@9cknb<{Z{DE3?i?_)Hr8=f0 z8`6LTC|}yegc=l)lA8Dnol`#3SIDYd`Y5)wd1J=(tyJq+r2o0mHufrnAoXdr0KkI= z=TnRcZ%Z)q8sY#HMDX*Wp>RqHNPw%U$NqRUr#$J;q z6xPyH33FhK`sl-H`C3cHzmQ(WKThAv#K`zA4`4_8YagrZs7eo=4r^!|G7znq%^xWg&%Zrpn;6uIhO>AqP90*mD{Gu_E=i>4pJnf3I z_ey@4NT;G55mS!6-MM$69tuk4^;HL``+by$`Ox3fC$nPqd_KNu+yH%pJokecFHe$0 zEt$IKcRI*o>QT%uHuHm@EQ&tBtBB5!wWflfF-s-SJbnnPlFE(Xgs@~n4nX!)u@p`} zw%t@a26MV@$~SW4PDaFcWtb3lG8w+&0prIm41+4N!5-`b7s3dQIRVg$o+A3ws@|j4 zCZ#vUD+*D9?ZG7Wou0o^`CNmOB&~}F;Dr+nr(YX)6#n>fj<)ERkXJ~7h*!1)t`9H9 z=EY20ONMQyt51&hVQ5{`ymsvlB=7?)$_v$wM$bLKP9d<@ex^uflpDOxh>(Qre*WDt zpzlJ;p;{%0+0;i$P^x&`uL}G#)QUm%VZfn$9S|j76rw^%U0#eawabTWMnCAh{#v5q zt-hxq|8WWll+2i26(}c(OC!fQb@MGV(i-DN`JjO}w+2jMIKAlyeE>@CxX_8@qSeDz z0-%D}g~X~INcI!yO=m1K>SpgWZEQlYU}npHWt|v2Af10cMG|ppjb#UNP~C9Y`9Jjz z-|F#rG!Z(2bfy{2Z`hwu<2XOhrV#<5y!jgpbSwfuE98mX8*cqcbwX_|ZhO;KblEEO z`bx5hxAi>cUPv+5JvWM25l~ttNx9cQ7n1#w)3X^D)(T7rkVXvkAURT{rMg=drY zI0qOhLnsM^$A7ql%SKa#dL=5BsR&J>IO2UMa&Xe|Wh(PE5KpDSh?#%5z`#-zk3VRY zKFaP0+X9*t%Ooo-;o8JD7bq)$sAWp~5C4xD5t7^>(k_a8L9G(e;S+>%)MPex?HI6^ zLEth?F@N}fc&Vb%(iG*1`l}tt>=cX}`=^0~{_zsnyLU22nzuOoci+bD+t^(jzgu3r zYh!n(+O->hGr+rc6&2GH$$H47BS{vf%hzWv;wN60X zK%Ea?9Bj||tP%0i&5j|%4x1j?R?l9WOf<@@JfqiB z3`>eFY*pV2p*u(4{VtB-CEC%*aw3*70Y){rtM)nWLsdNdbB^_y^eDUlC- z-@eCATsfH~KhQ7pX4of8BYKb>Khs>}{$yN&nuwH(&9oYImfcW(u@tSY3yIM25m6pJ znt5SVn&V{r(Sc=N1Si=JS)V3EePavf_jUU&&raHCJ95y+EqigZFncs&?ywBYnyv|- zQSJUcA#<5Zj?8zzIIoTMO;u>rXJFYqy8utkRrVp{V}$Gm_&zJ&qKkzhRw`zRE8|U~ z@CwmBSz)H=pj#bG0s=LIpu_eJ!VsQ7sBFRJ*TDTRA#C;#cqj$Cw4C=RMG-j7fc}W0v!hVJH5+qLE zLn+Lkb|6!VsQTVtU9;WNVSqN#4MysO8s`jZlpB_lO|_6xAYu2%uL)~i;n=myIFRjs z8ACgz-Iwdl{{Gre3Cp$E{>{pV{5tcWu+Z7~S1Ha(9p1-6MDX z$X!43e;9jwlkOT(-54T`34*>bz!2!f=CvaHSz7R?LyV6gS*uAF4_#7-^tQdT{c8K^ z!n3&mdQego0ZR7hy@<1)NTRs*H=ls28K>yyXwmWl#T89uiswTDr^(9IqWdee^Id~3 zlW#U_utO6U2;V=`l@54?#hdkIh_W4O9K2e1VzIj}Hj{n%I3@`Y1+$YRnzC_lJ}qL= zMr<{lgVg+mY+V(6*)20@I<*cz?=8`lYAChWNN244i!u#koOk-&%EjXs3~YMN!yln} z-hZdY0HWR%gx0qyUyA6IxqW4#gYo&&Z>K-Ior-7dx0h1595VHtmpltsru9LK3?IXs zy21)@vH`T(+`%HlH_n$|W)*)DWfG0*)`4(|UpmKdGeIYXm&ZD-qhf6|VX8v?`j?en zqoUxez2ASyo%i2(6BV2l`)M>k|FqQk7SSN7P9!JE13$6k07Ca2$Y&7r714n)puKA%GcF0OUVW0NBuowMI5h zBdI{#SPz z4x{y=go|SW(fhnGLgQba=2RNGzB#8ercTMdc<#V_*evSewFwC25PpIr%^xgU=u4rS zw7#%GZ4y2EyxX!N-;e8qVDb)RjL~CWy0aRJ>;xUpF-z@JWcdhavCF8hN3C+Rr}C1p zMe#E(f%=0L6kiT~t?x!|etrMr5|&$;__6(g}XR@bS{`7!KsLMkDis_bmO-e1&VdOefT!^7i8 zN>8VUU&xSLgIuq=c|BY4Rn%PXbVT@0AC*0Jh>cSSYnCeAgIleb+ZieGmduUnUF<-T z)}9Iw7;_1}W*|S72%|UyrfI_=EG^tD1Vzxb1DK7xQOVqmxS#TlBFzAmQLpf82CZGL zlm>G_4@y(grks*koB$w>ygDpNtPr3$On>qiEgc(Gf8{R%-GS_HC942LhZF%rW0paY zzCj5c=pq!A3j=yrCgT7|B+BfQk#=#?J-{vJi~7^WKnClNceKH2iS$_44>cD8*vFr) z1`=3*yrq8#kH4-D`|bnmzJY(4w7XMicM2}Ihv9h<4uWz>`q+`SPP?}jBRcHw?qpuu9?0s}(sTW(7&j=H z5upj&`SxGV1noI<>_(Eu+7~Hksphgi=+rTRjnhIuE@Y%Cej5t89HlC1x%7j~v;|Pm$a>$?p2w6VxL$M|Aqh_8MyeAEAD&88LPo8$C+ZL+n-1 zyJ6!W?_>@(>|S7Z40h+i?poO04|ey&UAyrAif!!czWgz$b@;=AK{M4dz**{=t~I|w zrd!8nEgrKopZ89;?2VVO3G8GRRpyRo1a|d$I zY%yj-E@lU!aRN1w1q7{Og`TJ_Vla&=K{Dz(P}>UoPGN6a{@p!6gY`CSE*>=lXv;oH zZ)lVGwE+Q|0BpGj6#^ZsfKf<*^A8zMk(>>)okp)BnWlVxcgtUJ?*QnUE_MaD$)mhv zQR>r7z`7O*-TVQoi}~&2c+`J*V7P^)Cw~6zEhRx$cy-LS*u)mlPyES3jioh$$D3_p zC$FJ#+P{06Gq}Ms5|oKYq_N-KlLu8lp-ts-r(jT;y*SK1q~>w_PWLa z-_Q+dDAd>AnDFfRqmAbdeX^OG9zxBM(4P(8wvBLxd?dT(vuv0MwL`g<3upD`e};bV z*Gg15)MS><6vTd*a8AuE8evLJpwUz8dT)Ouq8{h>%$pujVwH^R*%n`HSF`1-opt%C zIi`=)ss)_SB=MMLOH0=F){^B=8_9ToTaKjb^A|opZoRQA`-ou@H$bmyIdjHNKJ327 zWf))cawji3Yrev}>W#Teih7;(p!135`|gU4$7K}Wd3tF?W^r2ZhX04I&UKrTg1Pa7 zJ@37`I3~`&b?Vo#Py7B|D^%c_m!r=S6aRSQ`HJ_c=|6l@#tZKyCJG@GtgQ5p)M@R% zY&{lZo6D^6jdTjLfaV8)kvA|QImB_CWsWC%sK%jZx=Bo}LHiT*!oPAH`}~4_rpbWA zehPLr$7A;HOPv`+Yb#X;9}LI~!`a;$c;f5D}sm6m!^>E-<=$@`|@ z4XZX?z(}8(d@+g8AZ*fDTw$a!YusR(`6f(t2ZCEdv0&$P`mxJ1WdJG#EIkHiMr9Tn zpi)YAAoztfZ5oebEo@t2Tm*1?>SymjgfstqB;`LFd+`k{t+27E7w2assweL4qMId@~GihB^V{4ltyDJn}uvb_VUS3T*fQA&>Sr z%7sR=L=io~0MLFj0N9Ht+$97zaBTu`%M_kr6tM#K#{*~52hTW;QhowsTtWfVEa{>a z!0$<%pjbl*8`u!|nwSfGb7f=)@)XkzB^jX^0LlpM3)~b&Wi-Vt=1)hW?|2{hHFDV9 zf!iIp-5J+3x4Tq#_qhK*7zeM+x2RfkB&*?r!ue{hfr2A;!D22hC*cp?+E2}SEWuwx z37Hzq0OI)%Bk14^WO9;f*t|Ozy$r)dL=q(g+I}Q<1BNfJZr(m}&fX+NRVEqobBzPE z9xNkGwWb+|eS)j13Rh{rDe2-rSTlcxi}AM6*9x~QI}l#~5~KpH7fLY9sXkZ-X!KwX zFF%i+y84y5GX8S3lgOQZ*o$_%lj7DbXHK3vc{8=(m1w|yGCT4ciqK8lgEk~;YV$`S z6h&jMn$YphOSD8UaoDmo@WyJhOdV!);JM5)@MKB_X%4*)QX#SL{u8MXI*XN+Uc=%P z8qKq`wDeM(xr1$N(-Vb`jzI`rt3;smY8fCE;~ANR24dcJQ;zV?MlBycW?{+kVesdn zbDxruHttM$si#z5r@qsWrD#(zw6mDSLc-fL}gp6u^vPDZ24h0 zLg7%&&GM8J*w-+6)XiV=eT<%YcjvrmlEgjlPC2J!9lw7hzC2W7>>$el?xbeVw3aY*&@Px*lXw$Ip36?ZyxcU~rd4CgoH*3G1yMH)Z_UsU+FXTcX zdp*#2-^~F0TQ=h#&iif#U^fS}n*-X-0qy32|B-s$%>w>!&jPl=_n~Snst?Vpgfm4^ z*xt?EI|J!-^x}KXtv+Nf8_k5U-=>FWVfQ2D5NAlOxEZ2$y|wp*<%bsY{TK5;lnV|i z8u00i4E1rH5j@!M6N6-+93rJ=x4tDU)NZ@w9Sn>)xzsJktv;1@;$u_5w?~+!m?$&@ z642Jv!ZeOL0r|Ln^B&{A%0KTjbQ|bB^pBo$^yA;7V-MMSV9R@RsIG|llI5L-(agMW z(5m%pJ6b_?$uw%8hNQ306s$gq6>kE-i1Wi z{K$e;LVuV8Q;v6pIH`2QQwDbVtyWHGry1qu}7H7^lc#FL{pnC}*+eqy244gReI_ z;&cq(^M5t#gO@=mDPaxpZQ|1%$mOFLP<{%sN3|B*06Ioyptkn4zZ6b?64hW6HmA;G zbmJu>kI}jRJ+s; zSRX&Y3W+-R<5k-CN=+I|{SHKY3x^>K$zs<+H>%sHNjs3~5gKsR2TMTp?}v<65ox~} zQSfJ8VhmveKm z4`a3bf4%CCzWYJ3pLW7u!@K zbN_9VC4m$xL+B0!)R7}l>+P4odd5g^viyQ5+-Y)a4Dvg=#A9Uha4zJ(X;njazWyJ% zrLM#*f#y^3bRs{k@)pp+e3I7+g!-T>F4tijynV1WC5$;0WGtrpG>+~-1|s3xM!XMI zDBPknedlIcT}2ozwB#dcKb)wc{m*tuvo1I<7NkLjx+bHxdNd?RoBG`)#~>xoe9Awc ztCzAFA96@Ie~49*sYJXfc1@Odg((Q-jvgfA`SK1t#bLrL?p1!WjeWD`bM}t6U107& z;kh^AlaL4gW&>?)ZGr~pr#Zhya2wh>6*Oi<9DnlrX_%4b>-swGJFZ_c!}#aoz1&;{ zU5VH91rR+g#27(zqnN}^)}2`JgV!AjSa(UKv-8i2>&N$P85c?Er1^=@9Md^HegB!l zskJDvrf+2|k{K_8A|zk$`P)Z&R$hoU04gf=Xc2U%h%#|0G#>BiE9!p+(PQV5aQ%tS ze5m5+`-0UIHHTlZ=tqgp4gc-`r5mt!CZevxim>~EpZ^V(5(kVB4J(E38dnHvE7Pd=ubicF=m+e~S zH927?qTO~DUp4=@>8lZ3kzzo7PotxVkW$krhlx9oC(&p;ii6d=^pR_Jijrmdl@rMh zQ9`FTD`Hngm^ucHnYS$x>T0!kt^p7X&+o7+zyAKcnUVf+c?+}A2$=tENC`j#9aLA| zn5bOrx{UzhbqvMe_??O!NMR5eKs!bTey}0kfhsXnxg;2 z|1%T98HrT(FZlc3{C7}}%fEqgbO9(w@*kj_9Em-Fa@}yg1<+P)1RccITRi>Y7t<)r z{PxnY#h3Aw?So`}7ly*vpTZ*ROK?`$9YB02tdd>VCG3=T?0YPC`F;qASWHJRw!1$^XzOZ>+@KVGp5!$qMxR1 zBZJtaqsI&l|F}4%i4q$@JCNsSgvJi!{Wd@CvCGCVmJ4-9eoJ?=etCO29W{5UH1qRG z%*S<@>${AIhF_rgzvTH!&l(Od(DY;Qj?}uHkp83aji(AM*3j4^PkLBp4{U7fpic2k&b3RWv931p8Yp_S7Fr$(m zH?X8lR;8Ht4O}Go5Sg_5z0PRNyz-Gsl8^p;B;GzMnrs4AbBgU(FlY8jVz{W8NTnOJ zFFTOEYP!T2qn_#h0*YE`W5Lm97gk=rd{OY6$+q@hPmlpSq~CpUjJSH4nt@~nMNc8u z;%35n+B>(+5vwa7UueBrIXB(5Cx|`K^0dI-g!K=LOCA$*n3vTI$bR%5l#?peU5})R zsV?w%E#vMPXEADlmb&hs%iVQxG%JVcV6?*COUT&t6V4+cJZAM!D9n}0I;p+HItd%1 z?Lg|v&Q^6r?@en*@wRCl`p_qD|M5ygOJiHHLrg~{2a}?Tt!`CJ`CLZCEfz_P7^#dn zfs?3-Qm!{6mEkQ>Y{SlR#e7|7TWEKme10JrevoiRLO`ULZo$)(P1>Y)y-K0WqQ}uP zPncx)Dad}tKEm`sbah7-r&U)2>`65<$q*;JEJC^XEu&kJO{JZzHCh{S>2~a`^N;s8 z6n%UL5z&Wu7n|`CR`K#d)zYL3_03pzr8^~6^w(B3x_tK8#yvDvG&q5~!RzI4_)*LI z{y?zX|IdH^)nzg6GlR|ptd!>tL<&LyMd~0;6fm`ou#Zt?L(Oq%e(h7O2O z!rXyqug?S}#&mIJ(56Sd3-b>1427#g*~e^4dIOw zcOdt3NEhzAY*QM0L6m%;}=gL~_vuEdyVqrUwn}CCxJ%}bn;u@IR zfh-;0Ky&Kh$2Pr%>_!a_-1Ko@%PY_HN;H=c^@B{_J@TUPu51@cb~>qUWO7kD_BPz+ zcI{*v;}ffxtE_hOE*t)noh1oL02EAb{^N!6y*n26_a<#0y0{1!XarurURk14m6^VU zCF`PUk83cHur+=mvo)#5D}|?61yWp0qrckmJzTwdkM0F zM__lB`FuZLCPEjNrt)$yj)bTRxD)$5^S7ZbI)~G~J@xn~Ck zSjM$CR?CnjHUd5lTV09SSO_gC8{M;&1G7?n{_?_Na9*j6VKRCsG!Sfe;87 z-%%WaZ>J2~Ho9-aNi@Ur*P)_+In*&6?c}SZa7An=jp=h`4=&{K_v4v8*6Dh-w)^KL zK8?vlo{ehT*M?VrnaN*&;5H`0=vR zxPr|vMMHrf*A+(R;+=%9^s8`LTjuyKjb)Za*_#vWjvAkn$A&^;vQd+<6M#qRAhK=w z^+J;D1KR$6H_y+;qaTL^(#ym3d{}zVVlqPL1CKZP4Mkk-nXRTcQ>#&cWj%2GD7toB znP~KBUTvd$uzPN zax3>bUU5{=w8H+L2Rt+p%c#MHrSOhbvz0wwTb)EHoTtW2V+KE{DZ7RJtU$e|&XPw5 z*60ZnlbdxD!5cm)sJdlVCz?Q6pS`)8aUJ91D|5;@0af=D_WIdxryQR!>MIRvKz*=D zCbOS^@B4FMLp$-O|6F61U(RQKY{jGDYkTV4d65@dwrXW-M*Yl&01}aQ8X-ku!=Xuf zG#OIFME$l4Hiq>~rx?b4u2SAGo3U>#ScZnjb1{;1cf2`(9NVvyrPSLAbr zRsKZA&7laUhJ)=l`cOqb)r|b#9JkF=A5Zo?aw`C@%M#-aIk3LXnC>zx5uxZ0;~=@w z*skgIiJBL@FR(X%ouWL~dXy`l{hbmqrZI*jfmy^7*>PXeCzn`jQp`fuPu*R}p7-;r z7_k}|rF$_peZInBEO0@5@%_2lTIgP|E(K{~r07#b{z-#!4YE2X{+kTWE-}c=yR6a_ zHY#)U^ufKOeucTlPD63{lnR)Um;3O@q)0F^4j@i7KI0vFD=ptxl+5(`oM>muKk?>W z)ouSWqdkw@eB$7c`>CU5fn8v(T%ktFQnbVaY4YWF>~4ip72C^-#SR|ijcmDudUDBR zok>7x%ZO}DITSp#N#V6KA!+)&t4?sm3$A6QeOF>TdVX&>!^&f(sKwZiIcFfxbVQG0 z^{{u)B#GI@_H0^*h)k~<|Kw+Vs5zl2%IBTacGmeQvenRqUUrSi)Rp`jD|5suKzB5BvB zU?SFkG?pf340ri^9shBVZ_Yk8rrRWirmp5NiGG4ERtZ7M(T4aRg@7!K@J%m4#%gP$ z=`EwrvhQ6pn=}?9JXTi8-+m=JNSy#gJFsE*vev?rcD;aj;D=%Z%RPMCL4EHjYFzpe zcPE#8Y68rmQ`&$UBtv8MO`&7#YG4!jzIyEzR?X*ZgMa2NRb6*zTy>{F{`d0KsKZ;P zT@KW6ngR&UHmJ#!+*2=eC{zp8^V#$EudpNesQc2`^rSmUbNH$OJhUNZ4@H9TW;R+w zbisRgZ`duSmmUvB%sc}6t}1+4>NcXgtp?FY9!Aw3rX8KHrYAimif&jD!!{y{NirT}j*`ocK5~1- z?or*B+y<|^jxu!4$fX9{@{MhqdKyasSrG2xlBE*9T#)X~A}`)6mpCF3Xu#3JR31q; zUIv@Y5=u)gpw*%|lv0m=S8Zn{y9(jQeP5_OsF%yWJvUb$l%K_+ebuG8n!b#}t-bM@ zbpH+FEXY+nrkuH%Q<8tLI@ZhmP;~jhbO=gr$=gtMHeSZK+%4bZnff&v3lujdS_dFj zUBbSG=fW0;ZJs)$n_Fm=qua|$`|>lQd``;T%iXIhwy9`6G%8d63}m--;DhnC`$?WSCaoS=`o=U2_$2xj{D^gJkJ7vPqTXSDtrlh0NEtMLXD&F&S=fd(^S4q!IuKy?&EV4w@XJA66cVi7gVr>T#k5e9ghgJyDR8n ze@$x0Ppq?i7@APk*@xm@zLcW)V$!nL{T|xY^CQ2=g%|fX0vA>}?wy#uExm|}hKbMw zXkXIUgPY-eO2-wej?S;B?#qfEw@h?NHrC};zVN<&I{b?ceWarpJ*gK=V0Mtsd4|{n zOuh}^Z3TWt03bbNd;zj47KCML)CO!@6Q!-Zc*foC2P}Moa1}dbh`VS3r-+Hjsg(Iu zy{V!orvwz2sW7{G3AJ-~yryHecd(69Xbn0rYF0pDrDj*}L-z3TCt>$h>hTrIrIsyu zV-6+`+;f}j+TRxQVeP={^fPoH_hCR6!cFKP{UmQ$4dwtsmlXfnf;812qSE`i&%8wP zap{Klrct8vZE=%FrrKxaOd{DY{1$JAqkZFoKru?7MTf%i@;5%61;D@zcx`o-jT+` zNz!b1Qt(DHNt&?G%-`cQPWLH#*s{E`Gqy=?o&D&B4f1NYWyYcA*Dx!pDcOtGu><+o z^%!L@&oe*l9$XA#9rHzgk?3AtEXXLUP_gX3`Ls)GRbsWMq&{gZZuYxy;PiUgdC3C# zzU}5o_ob&~4PO&P#npOj5(dBn;;b|RP z?KEbPSr+g1+JV?HZqmZbFg-#v8`y0$K=d17I4H1+KGbchp9}lG9f*^a#PgJp)K6p` z6FG1F)qtK?YnXHx?i#B0wpn(B96PnKxNF{7%49Pwr031g0>ilj5i}GGXNIbEOv(=b z^}Ql`{tobLT)}kBut}kUnBf0o@6E%ZjKjatK_yGJvddJq?3FF+B-xTgG4`os5825w zB}?`YikO6KX=3c#*cE9Ck+F>-gkgpn53_Whe((FcuJiuhbDi^^>pItU&L8Iw%jFs0 z{d+H;`*YtpNpB+M@CwSwY4V+L%u6R{7_=}KO^pbl@Y z!Y?raavk$|l$EUH$Yr={OcYKb`PZJSLE=z zuf&c;M*(&0-MDxI8K5!vZ4;U|kzkS3XnsXmLA^@+aL_vzmii0YgBLekooISYJQlM@ zQVbBpKI*vCR6tYtrS4+t*YqZyyC^G9@!Uzg&;#9P5$JwgCVq-87#r|pUhc_KgBtqL z{ItnC#~DMz<;di;#y81HxaO^3zym8ql5J~hOC%1OrmV=>B`?XiI7?L7XdjY{4=zZy z_1<*$T0`2P$ac_uE!;8Wk8j|1mT5Io5t~@>BrTA!%z;|DzYudb^eSSoV3pKb6FaJ- z!2HJNVos2m^vlQ!t$jawXRB)@xXy$q7r|{}qN~pA{ zSJzbZ228j=$X}!tKG+dJmg?V)N_9DNu>LI^$1Tv|yS`plN#EH233@1seHC+bMC}pD~RJjOSYTBM`w}sOOFEP&<-I3^-;*WLS-G z1y(M&&h<&7GhdY1jT=i?pxPix?1x|ML{xxH+tF3X;e%F(qg??gQ4u`DP;OsM$Mi2R z)$})y_xLGvJnK`_!HH(EnCwd0p8jB>hPuo6z|>?;A~_mS$MB$5<1V56Oe_s}u(xaO z8yx1hl0ISbqNzanrOkCGZBm*T5DaQh8w4I_#dsafL3Ub#_vu4>w~3?hYxM=fja`i$ z7JgTM`o(|SZ&v9LFdKdrmbJw`-0)#aZE|(X_UF&yB5#9|N~@E#we{-tBZ`MIE`D`? z`SOF{B~fYe;b=BcL@LN_x-WL#Uqg{!;Hn#f)NN+%z4z2+Ol}cST6dF$zrC5~y0E zrfmM?6XGOBHk+xC=XL*37-n`q-QP_hZ^xRNu$!~(roD9WB3*@%7L6dl5*Eld77J{2 zwyEn?!wAh-3W@B?_zU4fDjVcC z?D@kyTHnRS(e1zqrpAJ<+)+KaR$PZMacDxrSDPCi_$zG8wY=s@qJz8P&#jx!KEC^0 z#@8*WxQ2RymFPM_k0G~GGJ6qxJ?LLmr&Dfvk5 zDfGok;;z)Gg9ab=+E^cC&t>N6h+ra`G_$zy1SS-1#CS{|?>Xi!`1_-@dz!1^Nz&|# zG~LL0DO1)DH!+ZnSA<&3SCWr76Z^9myM}20Sd+pj}=CQm|&$8J8r0>OR##;Ei zSxYHJ$Y<#=0XN>3m`}|EFY)q2fJ1NFqz#);92jr*y`tp9PN4N@1bvwPL7tM zX*gECHXSItF_PGU+564q=3_qD(w1j*-5*F^5s}u?9%LEf zr9hdS*0fV}_3x`+RXf}nt(A^-<~L27@~G0>?~f2!D(2%$Q_P>f+7AfMiI^5tSn3=dXU@ zq~?yO($@3|_X73jEN5?An0M0rHgX&O2|>Pz!lS^`z~lw6gzH(v!dg|L%ci5tKxb!J zxb?-y=sUS!IIz@OY%2k(;4A=6fc^t$tf525;UpTlVi2^%u9tg+h?7i>3wBOQH`slh z`xHI7cf+K`S|Zpfmpet1PI|=B&A0^K!-{Abz%!C|0hl7r;S%rPqZFn55+eHy3exUg z2^En#E3=WFeSyJoQbD`$TKS0ry&NiNNyo*-;)*#K#d;j%1>#hODsOu2a!1^94^tKdbREed00KAp7UbX{sXK3{N1PqSlQ#N|z5`LMH3{Y)<-Zp%j^~rToaAF<}hp z$XMuoDq8qKV;==B>N?})UkHfSi7`Jd@N}I9+PlRJ&_svjiSlgb%6FNf`5D``j5DA6 zic(Ta^&bgR5cCtOMByX@1?F7WNkEO_*$?{xJ*LMuX^prRXJS9F%s)T(>1khc;TiP@ ziidU2@fc8zWlJkBRwzpSem}zGETIX_`&yPYr@kkZeB_E$$$zN)s`z5RiQylw30_Cq z_9e=Z1Y)PqNPn#8#HsHgwI(tJ`1MKS0?|@`BdHRF?t>?YOi2R@lrEq;2;~AVi+A(9 z=+~FElH$rHIP=yN=H!DHDFKbjEd?faEHBJ9r3ax8WLt5-ndbf&UpumAzf}T0eZ-;y zc(^iT{UN<|2itJy(}U_Ll{Nmj-?N_|=G=O_?ICYuQMz{o%MByELp21X7xo)K894?b zR_fuBr&C1#1o{kkv}jj5 znp5I(?Dn;$Y-Oy2Nldc3?L*GI)mbD9mhc>bX@1-x>?u5WQk8ieEp+|ywuD5}iB-j{(O57**CU8l zMGz`78}?yKW4wH2Ad)#{?svukcI7Gs&n@=;?c`V< zK%ZdgM6}A>7PtDUZZ>97H7PH9Pr$5BRw~)yM}DXT&%WNh$$(zoG)WeKM6ggzh8|O0 zu=yG=??rsMm_66ry`s&MVQVLHJL>iy!QF8Bi6rK=QerqG3N)X8_2N6&nH>8|*5nx` zM`tjF_wL8&^8rN5Yf`JejfJ>#H`64}I|t(QYcPtbo1U?@aJH7YF}W>Z^ocXVQwE!WA!D^P$ejGo4GZ>&>#xL&;3;S?bnOtCsb3Xf2>n6E)R#w+FZvgPe z(v`yR=vBTkKb@!H@{vvJ1(&Cn6wHehY~_J=I|yuRYpQE1pi=KOH#eJPn@it*`t*s? z=OGB>h`AmM0%ZW^Gsl(14l;$OWWEliY=tJq8J)-%3yt5Mk$2^AxLWSK6?>e)1GiIY2BlrQE+1elmDx0?N=7Fffz3 zBnp6mFfOZJM`Q}D9`>PYhzbY=NRglcyJ4Ph|3Z}2HX3e?6s%S5>|p-vEqSJc7Y>>R zDi7CEiZC%|vmmKg-%i~3r3x`+U4C$;KSk(Dx^ZtyD`(5hM#~A=wtycyLj?W&Zhdy9 zXyel7m)cO5d|1keNZnJ|v+eR*<{^;vodoygnHful_?l zM*P|n^A!BpMY}PH(1?{xS zGxNWGqlQ%R!GxsEr3xnm-I=1Uqu1PB=yb)jrK5#wqKvPm>uZF{rArY?Jc_FUhr!LY z0zG%6==#^S1#rNRo}%%``y^z`IMyL{2ze}I0XQp1a;Jby z*1_L?@XOyoLeBKS^xd$QtkMsS_k*bscM|Gf#|^;43?CptB>q0`2b7AW$aPx@`Y!Nx zh*m^c3`h!%S4_O~SFaTKYC%0)0FS$ucKF%V6u6Sskv{)*?p^bmH?4PzULFJn1RkE{ zpZjNiT}U#$Eb3x^??P73p`fE1h?8qjkaVzFL{w!5l7{l;wKJxS$)CwHE+e6S!TuzT z?y%%j2}=UkzeoiM$#}4spW^XdK>*V111)T@V;(GynERPO9De7MgJXoN~1I@Q63!C4`BLfAq+o6@~lF)Jdinn&8r@gIoR%T6o zp214>g>cM?H?<)#EXF5nUnay#GruBsa<-Ee{w!PuNw(>+Gw@xI(|wq=4M2O+g1xk$ zhnBqc?mqh^ciq-ZT6X!!4!IfH4%6Ce`BN)DJmnE86(w~b`5(B61(MLDJZ{wjr7kTl ztT!Ng!DDo|!9OpYjX6u#X4tecDspsU@?SDoz9Dd{bZG?HDe;%z0~l$%5Appha~53U zxn?tec19cEc2NEg38@E>5FHQ+VNQY1=9}r57LZpGz{ShR&Lr^y${WbTLyUd$2N3x4 zq84A%|JSrN0=JDv5}Ip4tb_sBBd=;9djg!8u`pFG&i@94ATQm5@6teD9sGOe5aZ9{ z9flVTgoFNIQI3e1I~*MK6GMo zdCUcXlkNh75A>nrr^ufB;_pkrf2Z{=e5?G=mj7eLP9w;UlN;5}yfoxjSgG}YN3q)0 z_t^fSSieCO>%WaV1irfuh9mw$m|WK%Zot8(Iv{u=Xi8TEp&_ZzDX_QxhJZD2%?vl` zxc?5RIe-h|<%E9v@8R#vwSSnJ3%Gwp{$0{7(7h95*pgCwBs*r;ppj9GCDb5UyW}l- z6T9TA!1q$i2B^l&7JKBXt%^EzsOA)xU8}Ac|LlfviTys6_b_v_jsmJgt76?6-*nb> zv-0F8gKOV@IyeL!m3n4+1e^M4(zw{Tka7F2_(rks?@R)`7sRemX29_!edLvv4l=IS zTRpWZz^}2scanPKveTwrHruIiLUJj8)%Izqe1V3`_aVn@j29yX+!@eU{?xRNpq`%x z?E{V4*j)HZ1zi9GBaas3Jp_X(rcofYG}(9ncd?C?4f;Q$vch-8X&g)(_9)g1iO(V8 z61&cO!N||N+wLO3KsB|d#xmzG#Oqzup5w@IXztS<>ELkJYzt6}6 zGYS4egg*O+wx@cNRApfgz3;0?H}1aJi?lnnh3purxJq|pyg~Zl(m)Wle5~t8Gz$W?E|0BqA$zWLv8^HM(1W1sdJ^loW|~+!;V<1{aWPdy zIrNyuo9MxcvYTZuymsJ85{iC;qtfsDONBNwzi$Kb74#Q>A^q4rbreGf57!6Hg^uR9 zZK@>My?nw~NzLM2X(@M&qK_~nPB%_x97`zC`7Qa+_KJ$Y^;2IT4NX0EgmNxObJj=G zhWA@F0+2z`UuuDxePam@##+(`V9h(iKhDE$cdAh(pEy(IrZzK`XZOCPn*F&Mriu(@ zYj}G&eqMo|khL4<^tk0W`ZZHGb{c`fZZ5^}q*9Cq6yNQF55AUf6>R)DBg93VWYbJc4Wk^2^1xNvVs}$qxM(BvK}4 z-m!2b;!JCn)AhEfFy7U^lOJ{-anh_#hsz$SqE%LKeL^)MSYiIiX)HCB!b?95;t?Ij za&&2B@!^7)Kku3_BNA@GFGkqJNs#R7pN|eLv1$B!LHpt3*%y(7QWT3!ZrmB8#kU@A zk04Y2=F-KF;Op$Yuy|}8Hm$>@JoYP=wV{aB#mOSW>kgJoQ|>UQzDNsFqD~H++2uSB z?aYk8`OrZSBR!xp=xs@@n|)H1?s|O3qQk+85*jdfWvxZ&1uk6t zVtZ%tbZN}PK&&0j+?gx)72l1-zN0z(l(@3vsCdwhOD#S%*}#Ak7y5L6O~2bL?xkJ~ z-Z2dl^NpN~nN_+?J5_BHj*%JA2#MXDB5KivhM4A4eX2Ch1>{;hdZvI5Cc(u00HvD_ z0ODkKoVFQ!&)4Zn^3i4tFW}@~h%_7wRxncWaAvkCLI%9FHn8Q7bWqy4G-NWgXW)}4 zHtcc=9R@P|qppH*h}p(67EmyyzXa<`Z8T;5g;ePJ1Ob;}{2!4$26|D80STbS15Hcr z=u4E&RcdTPi3%n-{9^h~d9n3;snb&2n?aXY3^n#U18Ba0D2!09OsTh$SVxj8lS99# zcHw>&anBs4@yr1<4<0>iCm6wKM7+h4EfO|RP;TMebv zt{fCi+D?#-V}0=S6970!GCT~>oIgH}drbetPK9M-?{<@?+n{Z~nC*M0?O=ziR6BLM z_SOS5jD8}YYLMTvXQ2FKaEy_lVw|}67Lk0oKTEw@Gg7>+(P}h}Z7>+|97(oB&A4?V z4r3SHc=1|8I(Z=2h`2_xS@4PUik+fnw+kVZiYWea;w>A^nKP-l>EqNpslCkx;+cyX zacy^=&+oGi>tnsm@ESR9gHAj%Xas8h@AwZl^EJMfj(8vq5j+NG03#yq@o&`AdA2U* zx33y4X_L)Iv`?#~d`^F!Ydeu>bM#aQI@>@B+)H!pJ=MgA3|zt=m`GD?m4n6dtZc5g z#&Y1rMT|~mLeuZt8U1{QqQnl+)`TtT{=1(Sa(WgxNw>*A-($nslaxy^h5|E=&Zg>n ztTN7r7bLEON3zLk{?ybUtS%M4gV=dQ;IxeE<%yDYJ*YDiLdy#I3&Kvbb-l4v#+JDS89;+2Qjlv{t{)r8NC3l@moO0wuGYWkr z^7B*PYsqI{6r|S<2fej$=Fdgd_yW5eidCN`^8)31$qBe)UWp#& z{q!vRPHmch!kJ86LlMuPg_YKG(bpNEM!5^)h`uoe^MYljztyZEdb{ZyF<~%e(`3=e{ zPu`+^h*MhW+i>0D(8aqKOwQAaXz~#`H!0zpIC6Xc!wFn4GHS8&{CnA~)Q1tXlYds!^<{Y%zL9<~ZVno<&u(MR+TDFD@G&ss3@gRCwH_NZ;zd^0~f>{!`5@O)ZIVc*NB5u2jS$ zZite^mK;~|&D{4+@d0joU0^Z|IH|*j8My|W5s4eUl8O}MjK+-6OrYmmCyR$)n=faZ zi|s3H(9Q16cTT{c0SnY*3i1hz@B$w&*seQ;6r2N`%o{T(t@)(px8icGIQnlJ(plI% z+mo>_(6)|4Fb5Ir9d2YeQy3(J@i+k3TNLG=6Jh6ltWyhpqb$t1xvyMcO;`M!EfmJi zc|yhD{&-Gj7N^3L=Pz7$CVrd%C7q@gBIB87Gp#4?=Zv{eO&r@nEo=?;C&w_Gb(E(qWH&?C@M&!?@+M+kbLjTQos zv}5!mfHh?pma)M7`&WlnC6{8Vw)%_%WZZt%?}%;k6ZQKi+C=GiB+vKmr-H zgr%Qw>%YJRQw%Lt7qO4Gw$)qi+|f?)`kn7(^FxG9CwWWDLW-v}DDFawM1fe`|=46Lhi*9%bB<91c!5ogSAOH7h82|aZf@0<$0c0C8*TUKvS((Ear&qF3;7kti zrb7Qhz|un-dFfzPL09;eVCF&7!PJfm?K~hw9jEwXh?9)xf2!0gYbX2H&*=V8)~eyS zBD&i}6|oq98#54-%HCrIDD~W228IdTpl9weSSqaB^v;e)C}o0~=!IUzFi)W9LgCCL z-AuZ~k8hyEXT{{w{R=TF8e;O?_kFqrD*=5>Fz%87ntz9jz)^ewT?BSbb!0E-x5Rw` z+gt@@%9BDd2s3`||EfJNwu9quu*EpQ21#~UIFQ(ak%Qe#>GCi@X`8_l4h6L9Uh}S9 zPhm#E7QsE~@kFi#gWh`2XgZW!23|%C_P6#dlCU!P=>MHzfiv}lrbC-h@z?<5Q6@Nh zC_Nnckm9Vf?il546zIR9`BG;2REOKKKB)&0dhp+Y|I5_^pnu2ypUcS^1SROGX82>B&dx-fitNe0ku%uI^DZr33r0!DRh%%Z2!6UD;|;hc;1^#2{Wy8F zjEw8^)9!wu+hDiBA$LC?CwXn$Jgtl?*Ez7aA@>h14oS#^K^pW8G$?tcH4z{Wi0yOE z7pIF{;XA~q!q%H(&68c7j6#EB-Y`}J9st>`$)^ zx{eQqU8hdMo8^C61}bSU_=a?_T!cJF?t7;}QHTFRY!xXLOwMF-YqV-50HbD;V?#(j z;y>Q0$|d~_*1PIi-?9WO?G$lIzBYly!`D&02nkb)>LN11;MAF?xToqPPE*Ef*_Hwg z;BZ)i;N%KxMfo${&EY~1PoA)L5I>C60s#m_#zOOv$HYQ3Ys88a0R>s-q5RN%BAqyX zGil71F8!W{oVjh_Wb;un7MRT+?g}n7&Qq9dNCjrC~jvv3~s!2|G%>9DJM!AQrzjeF2--$b_$7gy-jNSuOfFpj+$nQF} z0S6)5B=K8hy*(ut((kG_zRIH$?~V_hPV;P79Y%kgTFhwf;$q?? zStm3CiQ*^22QKvgdh0Eu#qT_8@nAT*>80Dc9vY3mkf;H4&*p z$cF8dy%9!by|+;CNZgbf?!p|x5X(v92>VKNsrenX#N2^m-nPu#Xv@*gX{h@yF| zG*gWUyAL(zy0h%&rE`LcP3|e8I?4hOr#GPWd!#-Z3(!jgYv}wT;W9doN6NiaF6w~! zM)E;(RYSh-&vh^1n)W|%e7;Sp3h%@#J5Cyd4xEAvE&3v(iOEGrOf2Tmq%1LG{#@1f z&W~w$zxTYgX)j%A27eYt1pzu+l^q01%VqjJvmRxM&Hh_g2s82XJyuXM?B5Et2IumB||9J z{=LYHIcXDiui5tJ{5wN^C_q|nbDV$@>?2z7t&0t%DU+lHj4FICT+T}~9Ns4$%_;{8 zH9S8})`q)@MFkI!hfG$0s-JA!UV@}>5&w`~P+kq=WizjqqW9QEsiP5b5pIjTy}W?D zXL^SQ&C1IzCql8mEw4gdz{j`k%bbRT!L)mbmE|MU*{%nLg@NKu&=x2Lwdqa9Qtwg% zKy;4Gq}j9-4rZk5cP@4Nk+P(-Z7o6)MN%p+@M#J4K4K3F1s7-=oF@TEGI#TX_LCH@ zd{=^xG=6_~((lhvw^^qVf!xrD9rNikI&tPVL{{>p>Y)vAPxeTfQf&7@*wbjs$_Uk7 zA^b%UtMkiUwD9Zd@-;gyxsSdLNMJGG`}ag$d=U`1DTaKhV0|U>_am&k_iJ&vtd|C~ zvuUie^y>42io3%&=FxT<%(zN)ThEi|o60xM_b$&{R$t5t!x!_>5P<&*=tV!q9_!+! zUwE=8{5Yg9V6oCBG{PfyH8TB^tVh;twnd)y8iW9W2nJf!UGQz)T}Wk$GY6o}Rv;j@ zc(yeLI$(VIY+D!VfpVj+v1oVJ)V)ub%8bRU8SUEW;cY;!&xJ0>nCb7g4w2l{=-P4Le7FkUsLdsv$G6-!Z$JoZ%F z()3mrK0nAotJC}X67qZgOU!6YAx(`5Qk4$F+$|Kpk@3UCRrq)QyY1gYMX&5(uGF@e za4H23iRk5~3kO1)h_91>`ppjnOBb~6D-x0XUJJZfLL(PZRoK<|t#`e1k1$>?P~y@; zM4;cDktWCy2f?6-(O8<-yaIXX>1sz4nOf&rZCP=le9UpyRQJ-BmclT9^5wo~;vfRQ zO|qb|Mhh}(G-_Z%K$D-*Ws1ym)(OO~Y?HSUe3&y<5_KOl_%MF%csil(24oZK4xQ!& z!O6|c#ZgZ~vO#&}`WSc~->YnCu%~5zt-4}Ac6Q13hDdR^fR&sG%Ygdy1@F=wa3fKF zAyUvmtAn4QrMfnP-$f+MtB+ybPyk3-5GF=4`^bAK0UEw{A~mm^o8A!SLb|J+I}{m} ztsb`a@^1hA`?0;TBZxZBKIpUpZ9ogGHXrJOut5qkUN|4SZZFNRT$NkOzkkkXYSeE4 z^NQQ;)mH2nv~H?<8=p5e5q)j!XR6%?gvyNF_#AkC-+VHFzxcRLSmW$ z;ZWwVDj;S0sKYR-D%ukGS>q(~F4QCGTH|xFEb6mw;pbx>h{?{$d#;ff29}FxN2G-1_7vb1znC1GQ6FgE-g-_zS7*M&qqAp*u!h zXOKTyK{WH1L?f{o39g$s4qvT`U$=zAC6!X|&_wchH;JFz7{we`Qlp@O@I`L{i?hn> zDxn~fl=R#d{XBbhO3m^df94LPk@&ezrL1Ts4-1GK;T$>?r}kq!&F{hUyriWCI{!_k z*o6b0&3^Erk5v{6U_xD&x_pJxf_4D z8+Yo}9tm+{Jg)x3+pR66HnORLnn?oLZ-C-W1iLbl#ia z|DcaYJfDBb0}96h7VIl4-78XYn)9DEw>;b$vStftCM7r5heMUitbXPY1A5afm>gBK zJJH${+YC%F+RGuyT5IgenQUKg=_o&w*=h_cQAnD2KwcePi66yt!-X z9s0K8{FlSM33;+=#tP44p7uj{ZUv`3>7#>QO&l_s7nmk*^tiH6(kIcY0Nb_HtK%9G z{?-A^(G%Vx$G4J8^277WR!$jy8EaKP+Ze@`9oD*^3$CF8BMat%i<@T$(}l?yfAmfh zEm8piWl8)-v{veArE#Y#pT{oW?e_cj;VF-1qJr-lF0D(I5)QtdBGZbva1tjo*@`S( z8;o4h&JL8U^OLY?-5N8g{+TKLs@O8bfE^s0HgmK~Vv_K^<7VwfmqK%MOz&W1NmJ8v zo>cibndg~%($^Rl(O(g1DAo=^N(JFd6P(mS{xT)y!zebfu7UjW~93#1^ZY-AXTgBhZxcd@ouLJ_Pf9ZOOr)0liXahFOUebJ0RK#Py3)azXG!zb;YTo)zS zPq*+?8(;wzvQh5>rlPk~Y7zRxe_OSo_T+m>ZS=fWOIT~sYRur-rE5omj-0sdrmcr6 ziiUyr_75OO08Is17~ZJIF$1&6xTEs3Q^)-|+4QZboQZkP$PRa$yw-WI{=y(Lmzo5g zb3T*o>RT`Oe}P-U`@fKmg|MZ2GExmh=z+ij0hei@@I5rjGQ8)^CqKW^t?8SW+F&*9HfZ9_I71qe0Uy<~8JbG@eoBFXgI6pbbfknTL@BmmJ@yKKH z6Kc|wIA|^`zQrVJM(RBkQfxoFwH%)F7>f7T?2(=p=QorIyBC9_K&iLDlYQGh;=;Bo z%gx3b2W3$=gpnw5ecu^-{f=azA!pXJ|^fRqvI8)rN^Ce3J5gxdVxBE`kT$8YHT ztsmOR9)PXG7Req+R^C1CT8?;(B%26R&Hy#U&ZaEo&&7w+ z{jRyjk`l?EP9;C0#odG$_|M0#M9d(%avNkqgEGEaN zA(yARWRO3^kiTq?eN&r8Y5&i)z7T~AWDBc(%~Ui^L>2qnvNQJCcU$14de;fCZ4a;i z?BKutjKGqPk+ZsV>7o=^uf_xzZ%j(QoiT^jL&HAV7HEscN96?e@*P>kJ*1$fXQ*5Z z5S#S)(>y`fC`k|Q|N7{9W6j~#cKAtx2>;ApPcoZZq6ZpNS?(V7yo}_w1A1ovwdmyk zLB%i%Sal$YX}Q~npsG6|e;p&mjDThlvY7UsQ~TQwqrb-&sJ|HyVF{71^i1mmT_p@>u~N^#+x7-9gww@vv#`BvQn z8JhZ9P`xp?Jh$%iw5od^HZ1H?8p`HtBi9w(mO<7PypQB`i)_`0N)8i3E9X59M^?-a zm!5%<4kr*)XI0it8ve?I>=?)J(zNN);MIts#{e!R5kq~hhshm#;|_g{QjcMjH>TZw z3YX$Fa^$en#rt;>Ma>V1F$5@?PxKTiTzxvA9TQOQwBaaO1I-Qg4v8}>cTN;#FR^3E zP2~K*ee{$V{XNBs&R;|IXFeTSrjBKuE93>FDRXx(M$tB31gy z=r1rpd7B;;4Z6Yq5luvYMNgxstYFzeWgyN~Lu|54a}=U^JzP=B^hEi!REZm9 z*2e}+WgH$6G&yjlG+X8%@)**$rQ^JCzdqb<40Im^qnes@oIjX2yY3r!<>2D(FMV<; zbCX!rUK~~)>=BhwMBQ9N?HmCqZRiN>Zx+N8XgvsBmJbopj8F z+Ds4>)_+jS+GRo({wGZrS4mJJ3?FRzJ=B|SPDC`mBzfi?sY^#YINlU{$0cXGAAEZ7 zdhmd@;t%WW3Hk#@L$o$wI{^e?YPE*2qQ6f}be)W-`@J#pyjV@SBX97#l8STna$Vf5 z3-!E(Z`nV$GW^G|?jYBj%bEN;R{0xUbdhURz`nmG>iFeJrqi*Wj&9neA-w|Xb|wOo z-)n`p>P=mQrQk2D^E>7HTC@}nchqNfb5nPD;JPM1wN1L`-$Bq{B9Vkt6lT}QHN-%j zqGNxYS=O0ju}xdRu>6HQTaR>%68uu|9Tgq>r471?DR+uUv6{|a=-Xg*9`daoEfHC^ zD;881GgoqdLgKl)n36u45sb)z*2&S!O_%;HnJ2UO4ti=~dX?$}IMB`kmzR1_T*@k^ zo4QaWc<|hpDPdu?_@gI(ESd;j;!LTTSdz|JMRCFI;u2vTFfUbM=C^rCP_Lr+fR77} zqm2_EG@hHZUosdp@HTBywFd!f@K)HO@LhpEubXHrUsfma?$V4$cB-yxc zw1fntaGT@A%;Tf)*TlNo7o&8mu4Q{q1{*4O-2P+FP40NAuch|*EB9^di|w}P)IsFasF`FL6?QEMyHErJtrU&bf6oqhN5YMkcksU<3$ z$r81vcRK+y}QlsEmn~nLNeGkY@2wuE!EbZ zawNsK$Rz4%ZhTscO3rD7Gi5Y3go!thAcyy&0eQQ^rG>NuP9FqMhy6k5&tWUkym<>Z zpFCj|+aUWM1yKj~(Q&pFXU3;;P~w6du^6eruwvOpiq=#7;P6kC?4F9oQ!i$920erp zsrOhIbfjb?y30U6_6vdo<_+Uijb|!)jZ_-@yVR->0~B_KO(AMCpS7Jy;?IAIvpxL4 zny={dIr@`sX@3ZM8cAiH($j~gh9HkbT;9EscV1z>|7#;QukS&?IfJj~ak8Dd)X=Yg zA?`&AGyOKPpYxbddw~^Q7dyYBLuVSuRbFG}Zc0$EAUO9e|NFrOfFuGqv${#g=NIv& z>s`+~^cPa4dT)%z+}rF%F6%IO7{y2rbOH*)8?T}#O0FLxiu?Xzeh=55B?SfsU%d2q zF5|?VTae1?&g&Ptn^;YgzvBL$*AH*6>|D zSu64aKij9}RXaxi0ES zEDl;HDfGiv1L!AKsS7|LZ*Qj+fxUP1;W1>tr0foHVk>0dCdyY)`k8u``p2s;-zt6> zY*k2TCdn9u&dY)-NR9cW?QOZtc9NbIQJH7n1UKC=d4i2>F#LsKDkLyhP4)CzKwvV`P~J^~J? zihi>ZNPk#x5}o{qm(PA6Fzm{CDIa)MrDJ}0w{5QVyQTM3SgQtL4SaQ@ytLq z!h(?WG$fhsNygZI_j?yR#ckuGDP$KsEMW0eMT*t;yjV8VdC`rq7&(WCWsYOXRvwx1Pb<91${J2H_P;q-+%S&5?(Zc_eVfa zID#Ks!WRYDMNWmFXwr4B~YX`v%Y6#tcElT>O+8k(Q3MVF|3G;>Iu(pK5#8k z?jO;h4eoL8U1&hJ3`m$ia$@7WxREnzbA9h_khudi4oSW?Crq`YfQ7hX`9T3LHYPrJ z-t`^ccf&_2lK-OWDGi;d$4WIzRAC4sGyeU_BQAIe6bmH5!7*n?M&|q&d4g zg2+MF!=qojR^`4KYQU+Fz>V{b9mO{ACT~RtR5>9c;Qd+yWo>QWWKs^bzs$IX=~J>9 z{Bqqw=a8p#p7gG(3}G9PLT*l%_?$-o6)qI^WVfere)o#Sog&#w_xY8;^Al#Pp`h%2 zr&X>N_bosm`Z8cdR$Uw{L~k7A<|lLrdgO&^2AvUXNYTDLKRfytnI#2`NnRfhynHp0!L-|8T<8mlVx&Rx8biUJJD98Cb?F zQ342vKJX0)-2Mi9z_yilhxUcuDhYvx3zsJQMO@`vjbx9gJu~G#Dh(aA#}ZPpnDzCy zk@&#CytO0 zzWpsT9go69$1kq&JcMt-dwD@fjd=(V!!1tr9g_)37aA?Fd|Y5IQ*hnY;a-r#@_lZw z&hA+ddG7uT5kV4ikQm$m;^exkLEZPzOwQR2IB#gA?;UAgukot`KO?feib_@bv)P`X z6ucE^ky|79r3eS&PjTrRj#^K#w{cGkrjoWvfAn?M_2o-i8*^n7jl~*Y%Sd0gO*9l` zuk}RsoKrqE0lR}{w|7xl^S?KFH*g(Y>0AZPLI-}w-a{qg(VHFEdhgB&0y)L8$4AA+ zE2AVes;qy8_!L5uHtn(6kqJWNsee?WpUl7mVl#ct8r) z{X$E#9(=*Q%zd_dFep;Pb2KP2UpW(WF2Hx5_Rk%s!ohN~Qqf$%Xt;1<#bkjlOJD@? ztg!Xi+g!KwW!RZ_pVSj1o>g$N=uW{vB(G_eq)%>Mgl+y=I$B0KmcE50S}JT@AA6^~ zCE&eUa3GuD{v+XO$~mT+?wtpkPgPrO>m^!~WYd7ehg0!L&(Yu^$I-ebgxLC^ukx(u{moLo zcP}=%-`>!_guAS`3aT|EJq;-e+sI4(3n^9g-9uj;Yv|;<*7z;N;$jHHU{E@7etupf zMdWUp->oY*1Z^*MLvC~K>rx&6fg{XM@OgPG5LLZ?kOQDMdkH>4J*SfWuGNZUeu|Uq z^7U7KMR1c?d9HjXcq{rRDDS{ao^v&cIj9dZX^frW6R;0c^a5xvk_N$pV6;mBNuH(+ zXi-am0FZDqGNd(i5cW#-RF^};YKnIM2XJVBbP6&efC@<70w=u<%8;zFXN zcrkJH8u|OHFuR?(3msco+(-UFB9g!j{i>PyRuxxLrs10ug^!$cbH;11;vWdtZ*+kH zhY~SH6S^OT=VIE#fH+nA8sdPzwsPyU?`EgfjL+FOb(;UH)ou-r{Y%^^LSmY`b)R-z z3Bdx_^z1TMkUl@s>3q`3#s3;jV;%I)MfGski2m#qsTIm=?v(D;O%$7ACY zH(37b7Xl|t7uYZx3(dsuEh*_VJ{PVlFQ+Ns#6Ff_8~N@XVP_X)@JtQCFx#8v|OtyS&+5ON{dUbh2 zmpJrTP1pTyfZ5DyF5@b{UHr!s83s(bIO2SW!<_=r6E#C;&M6EJo1IGI@2Spi`|xIS zD>fE15A>1Vs6+%m)&qA0a76Gq*aP`JZ6RXDOjMwbv5s;|9b(oQnR=mD)Bz zZ?QU{7OjE_{RYX&L|h+odV|n7VIcoKWaMROfrb2`4^1Ui>ej~o_2`e+d=koTUwuy( z;QRo+OTPrlGJWQ#q~fH1D2i*nU^PBr;;oUVue#dwpvdw&b3IFi%uDXKbyzYK*O1c{ z)I$Ip?cBOD5y9y&yU``xa{Mb8Z~2o+7c4D_jAiC9axwWvPBH)=`brH_md?6&XJ{)sxS}0QuTCv$A?ts_78m^kTsD z_@ZkTIkTrZJRfhDF~ut}wJkoY>-=T6Yw1MbTQ+Sr&U5EMP_A2Yd(n1#O+I z%q2NS&^P37cT#K-kUd1b$Y{8a?ofVjQ34QG4U40|f}hLlVHXAmq<4OZY?Zo<>^*vVu0`zC2eUIyHx*5!c5Wx33uaP1FNzFl?_-HL zx_~K&;p7lWrh^X+(6teE{~LR69uM``_m3+i3fajr3Mp$s6qz<#K9VI%Vib~wCM0B- zB4nKqiZY?Ho9tv6yX@KbW$ei^BgQaGzteqvulxR7bzRqeeed7>xPRZ@@7EuF%K40$ zGv|HId2P?v^ZC`HEPe?zep@;fooH{Iz1`zI-0Q*ZHqR%@cUCY{KVv9UU(MrNGrl>f zXl>Yo&gO*g3WgLegv}2kH8O2SttKxPN)DBNJb%|!;hLuIu@a$YqHi)8)jd_0F$940 z+SX^OQQVosV`$LpgNs|s9h6;2W?F*hOHFJ1UW6x(rxL+-=V4B!+y`CpT?2ck^-|II z1m%mWS#2o#EFLq^ANhe9G$6~3P;`(s!|=5-I1 ze4M+thf}3oG{>UILaPQ_^P@+Sn!p)}*=&W-Jp0N!p3Svf7MnEnHXZZ_*>x}aK4wC%6)|CX@|}0{ zg+kv_!mWJK{`uNizMyuK3z9FE&bQv^JiXhJz=|D^Nz43_c(*v+=Jrlwj>UjLx26F9 zx70S?ZoPK^2Kw0C+~ge7fphJdKLz%`~lANS4NOxxX5Lom+8&S?(xKP;?R5!x)sh5|L54Dga_$-&~bug;sh(%Vb9 zu3Z}`O$?WeUcDd}^JG*|;}O#bA)ARdqA;D61)w$+(#5Gjd0CbtF*}-=JRzf9==%?Hgfe8w>Fcp zwiw~w)mNuXcA0RhzJA*usVF=~G8#(5N97ZIN!Q4}Q;-8ANut*}Yx5Mv5jeiajUJm8 z;qMGZ!8SP>Tw&B_MCj8ZM93uJS`bkn9DBG|Wmv&3e1)ehN*qzCUh-jXlz~w$tX%UJ zF69y#MS4ejti?v}2RW5+r1i;^6z`bUU3U~WS|m(0_gY0uM_JD5?zJi@SnDyiHf$vZetZ!~6c-4SdJVF4N>sJ{HH|ZXz9wpWddnO58eX>CR{u{RvysMV5d> zBIWU%+(>IedYGz#tE_RKU5`_MMrI867rVhww^AR5W##v7pG7vX1K43*(glDymLPjr zeMWL--Z@>AES?M+aw5;oNEXQ$^Q(lZ_nYmJe%%n;(!{Whnc<{zBS=2v?3pTq=7H0B z`FQKsckruNc^ApYD+iq|E3w>$JVlN}F=yQaQ?sIu#ynJN%ryqdWo9cv9nymKOuo`} z%K7G?OQmYgwWSUZ$HUikTq?^~r0#pS?YZh>mTz*8H?~G~0rde@zcyq&gR8-^YiE-+ z>Jw}=x>w@6tV$}(1iIX~jw-Mf?(uwWrtZn)5GU>a3~KBzL_J8bs9SsT(4zLt5tcrx z^1I?t{lKS++_G^NHwJl`7PfsgJPmZGQuaJWx}iD0}0qJ`PY7GvWRR)J%l5 znw?aXt#p(1qE1cw@H)NurYFk4xchnP+C7lH^zBR_gwt7pZGeVOh<+}L+*dmwrV;bS zp(j`3wnMeRaYmWb+T|~;9;}*+BWvtd|I(z7K+TL!4N~ah^lN^8Sc(=fNXjTD-0)UY zqF00Ki5Uwb-Dn&$iv)}X(6 z^j3`QF~_p95TmG5=CC3Sz3DSOyd!yDCs`R85@}(yFw|^MH8;q4mIGkaVhZfo7Z^bg zJM3Xd(8|Q?=Xqv#7+qag&S`VoRatW2lccOmwQj87v&g(ZTqy1-HPX-&kXfUPEl#q6 z)T##_6LKqg<_|(g1V2CU0gKi|*mzZf_;~Z1F7tApJ*K0uCGs}cp2+eG?qR2tz7M2B zkHm4(A|86t!^*H}C`as2As)RP=Qo`MJn)Zs*i2{`yjRzRs6S z4|ncS>hxnFJ*T~*3RA970SY3>aVF_2P2;k_Gnm|nN2AEJC1X}Zhe(!L$SGlu-b7xQ z{NoOf>(m{h*P~6Nr@&LEDe8P)0X;JXgwCW)?SuRCZM5b!UVhNPNJ-X+BoAwvVF;k0 zGNOiW+*;m(6YQ@K%Bx_wz0a?HYb&mJeaJUlqh;jFtq`9pQ~I)LGBFkmul8K0CsXCf z&Tjxt4~_>@N`}Pyc1YKk7!TEL1xY6A%?P%?<2w*L$;MLb@B44+3%WlD6Ax5s`%EJ^ zZ0=OEChi!WFgT+$<$6Yct};U^G*L78e9mKm)C|F0>czJLUuwMf3reH+qZoneM*JjT z;?mUTsG82qP5&5upL%_yresDgX6%qss1oKGw~m(U+X(vJ^kA(6RB_-(#e0v|!-_~j z&VX#oAoGsLxg+l@a#nh;#;(L$T-+F9T@PPiEidIN&ZihqPS9&{yP=M`Ixuds!oChz zLvP(@Q46y;$7FSka1U>!MA-46*(VCR%uhe%wUMG|XgUkMFaBgV^>WW!Lz6~ih0V3v zfypbuXBsQ>k6BotC11x#WJt#CigIq1e-jb&FTkT*Xqck4N9J0)zTuqq`5jhdwHfc6 z+pxpkivO}V%v=uV7hF>js<|sL!eT)c5KnoL{KHL@CqQrNApfC)LsoJ_yd+!Cie z3nXBB(SfKvR7Qe84L^ik>)=pTaA^8VQGR_}XEFU3l`$ISl7&iLcBdH_cE2)RKBns0 zWekFr_PT$UR{E>N68Jk6q&JMEDe2p0#eB^>q0n(?>mw*1YUE*?~? zn>_UEd>8oW=h(%|pkd+Xp?_H!1p2-AzYo?=h66KnW}AMBdL(rF0?UQoq{clscPy%( za|@S(t%s41O;Qt3PbN2OP+x8irUhy)J5yY>c})cWiN?||YES>#DPul!6*2tK zUFXtQekNbY1m{=VZVGpy+HxjgD!+x^DM8@TWA^T%@_wTO)?#}7LDaX0B-jwp8ZgB- z(*nUgquXK)ebjCr3(kXwT^f#=L`%M9nmgOulq}GmO(%eL(H~RQ1Qn zsbJI^cjmL}T!9bzhGiF#vS1450BS6$A{#NZFqN&3nuc*#9*3jsx8Je4pA9rbBeWcw z=A3l}BeFz7?6khpo`MAU8DWws`GPBc*jxi60Jm1y{MxtBUOu{BE9`lEG~ntPeWx0Q zvt(;Js~_bUTtH0?TB6t#7Xuo$Cyw}}cWVuQ`-6KnR_oo7Rb*Radp=})-m2+hnC?pC zMLycRvl_w^0;nfY>vtersIN_mw4-5_NxwjUH!=TQalyu5>J;Q3XsG=y!uJ>Drk@bN zfA9Z8l>I+L3Iu8pBRAyJ$?4!h7A?gaZ=W2A%fY((^7_aZwqFQ2tAEJB;)=fbZhdUb zeJojGYdIl(oc4Yd#kJ(Npk>&U#@)Qp&QFBW&%iP_%*u|KB-t22$xZ|;exVk}I!cD% zqk<6l74G4e0~2GAM4cLE$p>=l8VtLrVT>SyG$?Syt`{L_Z0optIjH{90UYO_ zOv>V)O^RU0&yG?;e?z|a{ol14 z>!@&)h?W3#UvH7C({xEWB&2BE>x!Ym#Hy#q?s0wISee$Py^)t1CN*xHTheBD=(x6% zLf_g@{WmM4@tq-NjgUkyU1K|C27J9t=Lv`h@CQM16v9>td(VTH7%U;bhZ(;DA{yM8KJ1*Q~ zV_k>pwD-%{>e?@6v8wEPr;R%4e~3ItF-O&2@>f}ca`>~}NdOfFuXH6R%LQM(8~J0# zcU6TBX*u+CpyL^=&fzWQd}Id{fjS3HRFm}vXjwC=Gm4CukbC5ls>I&;{NTAx?segp zuXsN5N9=z1?6lL0@bE#3#@(**ag=S3ru>^FTWKP5kL8z#+C_s2UffO&CrOJA@j6YH z`FLZ|m+)FVNI2P=*jvA)b&PB@y%(wdZg{NtRqy#2as7V2R=zl{!s5P-CeCZ*=DJc? zk;o*$2o*YjDeABMKpwnISO{|!U09Fk9jUiJ9&B}Rw{goX3k1o~EE%r_Y#7sx_@huK z=)n%Rm0Cn8g6L~x`_x^Agk>aP;7(66-Cvh1{Fdv)2uos zdPAp=Z|*#hnr7!UVMd%_8CHH6!waZyyQo0vOHEq#Sl&P zX#HtX^Iik17jn0jyr(#t-YVRA?qp4-kuvkM^ zLVe>F|GJ7vW7-l&)RSyk`HE-fL;^T3oE4qpBcs7mSr4k_+SkE&n?R`qwii)U7vN)S z^KKgBX45e9V2|72ZXDcy(w@`>3e82$q&F4R*E8*-UrSFlSIgMTX2%^J9xBzggYc2B z!=Z#I(VOjehPsC6-H?&vs4wv=K>X-##aq1|y;`nwlCh5%mh`hEJ^8jTASkz}W(jmQ zlgUCJ8)v}&?fwNL?w2;0PVZ@Sw&f<>&bzVkIhukT;8bq0eHsOo!5CU@65_{c$~N( zB>jx>6hrJ;VU?@C))m%Yy;qmt8$6W~j`?2?d+(0L!Wxwq4%p-$QI{U1D*B^ci*v<3 zgK9&LbOr5N;3CjJNQ-{44Zjm{ZPZXl)FJ7mg3ZI-L$V*0Y)~s5L|hZJ1l3$6Oj0E? zDvqk00V$0(TzMoq+RKjv`Q@!=r>o0zr7oR&?Tj}iU?nhy>b>3?AX96VN|h!20b6`{ z-6t9UoE4#f*#m#+)<1i9obUXbZ8Nr6GA6p8fK?uJb#=|jO)V%46)!E-j#8hwlJPW< zEi3I2gCN5_W+QFB%;*_Rk>cY#x+Il@*!*~7yaf5Gx}z0inj$Z+RS2Mkjfo9 zZ4*w{JzE?lf|!!%q`egk4@-5=5F1N;vb19XMwl zJ1zv;u=Dl~Cl70TW2q{b<*%UHWl)DBYk-hzrU+H9Pw&KSm{o$?F0cYZ*U*)PoH&ye zMud@_p~Hjpu!JBK!OQ+TL-XzL48gIq*QmuzZvY8qc>tw8h%y)XM9PwFMB(3pMnl++ zj4dAs?Z&}vAeu%$XhZ^4q||qK7*%u#gn=WcEIlMfGO*w!Kfe$9m(QBJ(T={8T50j? zyFmZWXT^p5p7QTi{=G5&2aX@-iZtbP6bkR`4T6e4T>@l4Cw_*gW=N1;9?tf5n>WrP zcUl&G)%*5Muzvs^(rlA`a7DWC^v=LSBaD0$vOG!{G)y#9YtWxzH#@fOQshB;v@+`1 zwe#fqrbe6nv)mrs87(2|DRL<=SM1~t&c?OylU?tq>OGRfyawgsx9$BVZx%`K(Rl#D zC4K#*alrX9|5kF7stjyAYGE;*%ClCJP|ZY(r^<_^3k9#)I&V6iKYre(+73!M%72my zUpXB-GBVLQA#0!)FDS09H*=QHnD@rjvr`P}3}*e$UypaB3CjYPU+>1xmFqwK%<{u< z<7yMClI~XJUmqE(0jMF%TP9HVw3%$aj5V`-bi)OU2E)Jj@I;7ta4&P4+g*tKiB_d+y+8;MV6)qi-P!LH^@;;FMe3{RI!i; zCLQocEZzWkGzAD<0ZqP)?>>LI>2S6M6fESR9~A|GPGw|fd3)2+bqTLKuQ_Z#*G(JUcG(u; zgX7}#rh@kXa!KHi1%!M_eD?&LNzihmQ#P=<;y{bs^!3JYZQ~9_H6E9Yztzd~_^fSa z*)xkp$dDSz^dk+U$>Rz5H7}+$(T`nJ)7y*4zlLp(uMIxue))@@x_q(D`8^ui?(c^q zFv|K6KajzCT=uUfgDhTAVFVY<0Xi?azUG6S5%!Bfi81#*ek;5~1fAm?RwwmIZ5nZb z&ZI1{JxD$m3eXPU84yE*%c}m${zH?6Aq}WN z9B=aqf}$arMQlfSTEiVCNWIUHU(rWVIi;_77V;;nl@VDz)=Y~@~f*TMHH-!zWUgDS+*_!QYdA#}C*J3~}AU~~h96GT@g z1T39n8AV-*^b>ZZGYnAa^fwgpc5&u;_y^|M;*UyAkrtKL4x?-~EE zQ0Vs>|3?h?dsqB5K>oce{)cvjMYw-Al;{5B69{vq^-RZk$1nq7A(L+X+W2)xrO_sh z*F7f|ME4k-g?A!-DG2{|F^1lERTaeksNxd=CZoD;8Evwhc+*|C`!E)su!qz_A~dX8 z6{I5!w4{f$v^s)J0+th71^_r*&Ev;qYw*PRHZB)#^o#~6xh%;Ejzq&@YL$Hp^Jwi^vn2kJ3S)YU_OKR zH7Y-au8#(k#rtgmiNxv8Eb)p!Mt0gh<33r{rL|r>oD#4XN?N-N04se+@ZVHr1PB7Q zAXGH0><0(`d8#=C_4yZK) z5T9QGDd8hf_b2=5HmvPP09pky1Y|5fZJ_Fxw4_npLLgGCp`huy01FVt@PnIh6T*XA zj2Hzb*bkUs31EUbGsqwoxp-?5F!ZcKx5aQNr;jrJ;7$B_lDbr_AHp+SNhm5O$dk@K z1hk3&Ba^Goptwd2l>d>3DO zYULFM#zzc`vK4z?uX%(B_UGD@R>O{FNy_5a$j3NC5lDFoKk`yl?^yGh@#5FPy54J8 zyV4i_N*ZC5;Oa}X3N5iaFkX}cCe)UzJJoq@^s@D$#JPm%jp3Q9p|lG1CmEub-Av_Q z8jnMyP_-gdq4$fpLY@3+^3=Hua;$CHw_6auH-%y9DG`{99x^<~KwA`e<u%T?Ihlqeh>ssW zrxv?kmk~4ZQT@8-QNN7mCXt_Kj?CTiLxJrtM$0Y6Jc2T+IBN+_2*Y@g=bkmD+h%18 z!_}iD%U(0?*6b+I35{-AuV>aq`VlVBS*33fFW~1A8gM|OX&{w|2p6}}Pbs=Ryh86w zy-2y9pf4Bu$GP@LF7=}2>SNwOhB)MjDvkrGMN78BImMij*01b6GX6@c{fgyoefqZ* z=vJdY1*rwT;0$WFw{Mfy!Dy+T;#{qP_5Rq^ZRLi%M-S~pxcbD{uVSU$5x27;U8uT9 z#B?*2Cxq12qs8DI*ue7@!%=DF>5?iD7hvtG-+sXM?Pa~-+qVRhZfpmfm<#UF$_J0S z5fpVEPbmibvk}w+*H%@k)S4{RX3Ua@+l?g6^*P#Zd5UklzkK-;6@H6Thy~P`$j2P# z(i@CMEAYDYn0+mz$eXS5hnr?vm@1Vg?y$=oYCdK8T9UM%GuM9v=}W^@3(fgP*hiPBFY!+UL1INMwltK#iHQh9sY`Ii+29)fJy%=Vk87lg%&BUoSHFw zxMoePfwx(%NI$tOKNJ_`JYN>(*L0Rq_n=JHk?zh1SSTUh=qZd~#5tOFp7zSR!Rz2w zJsM(k>%%!Ewp_7n32W=?+di_qgt3$;oj+K)^u-;|Z(s_cR312fvYGR-EeAQ}2GP3V zWQcWvMe<1Z^tx-Fy}bw_Lqc5laKX1PFg-HBx=Rt7>o5lZ71AD%0pxt@nT=+jyf)d$ z*Bl*su*dj>PFK-~^E2~|EKE}Y9{So}9Mq(;TxhqkTI6CNV36H}A~E-&HWDvw9Q?Kx z4qLxe=>*D;HoCwec$*h&hi*0^A2yNN+8M-4g zT`uZDH}!-Aj1KTEHU;^*NXFfym(j##aQ>VKTT@z9L^WOFIH`OF%|6tXy|hnLufz*} z_dPtC(<-_y*wM*LL5D5V1=|PtkRGav9@QX0h`M#Ku$_+C!IKFBVqysN!q*w zy)|*y&ZKr9J1-gbh8RQtNTkoM>OItpOb!r^J5i$ml@TsK8;cXnt@{Or-)YO}1lGbU`8%<5oL5ePyU+G+TRC+HWf&RgTg7cb8q-79{ zYEdCL0>AWw76YyDDvIeY{`O0D=oD%?>Xx~fBMl6 zb$xg5>qqTVPEoMBCyMiWjs8L4{`_MjiDpldCWrGUcT|txA5FMQSAWwdKVD0^%8Z** zNsXxx86VM|Hv&9fqGV8dXLil@??Dv{M0x@>n$@|YUVMRfTKu_PV)ln(PTdR`7kmLI z--PU%Wzk8m$O%(xf~eYK;ED#-1MfimLg?BiDwwY1x@B(hN7AbNio?aq0ME1en)z=t z2%Y&U%*2R2<7&(2D9qmbNH563h#3+&F7NioxT?+mI1(nk=%%pGO}mzQkA%?fZ%gp6 z1{ku0Q$3)36SgKNOcWJmQFz9;Lwmn&PLpbQ}f5yxj{`YU0v~2TAv%%&%LkbZgxF1 zk;`jbaP-E(BMU6PWw#DjzXH3m=~}%#;5M^u9pmD|g>8^O^TZabP^M1!5@c6lLtAu1 zBfJ1D?4vG_rZ$^?ReVT4W6}SFe^V^=A}tCewSdtZRx}-$G$S+>%MGj_l9HeGDxkQ= zEosNIDj$A(ch_R0zH8Qb@Q5r>4qYr%bp!N>>7@b0YB5^GJ4)6%=@_-pb#Hu+vryWh z3!9JZxX&_0)qPwGtKlTe4F>56wtu{ZB3QzK^E*|Bnxb zt>`ZQW(>g)8hr5bYeG0F4#xNO1e`Pdik@?>_j4=|{w8g(g>k1bFWSDIgANS9klg{p!F~ zFTY%1Qm^z$0BRM-eQhm#m|NHzkKVk(OxUY0p6T$n1<1E*W-?+Xy~)OOda}V)hy5}v zq|I4ADpuky;CWt_zO1>fWa7URHg>Fj!owGm1{&zG!=}2l7&`kM zsGz@0Q@q&mfn_m@S^SO8*mrfwsA2TIT8nlJq+z$mTmVW-v0C1L07@{0Mtn?vOy^$O z(%MIMeSgx?@|~}*FI-wKzs;ZUY>TI>XeChU9LsGstdxH-s#Xtq!3U2W!cN<)1U^rk zA8BoqsPrlwAg!aDP6=8BfCno^m3V&}S1`90Iu*nW6ni#DOOuVaMl`NQ2|mMUANnMg zWAv~w*UT`s`_pzQ@FWA&0DS%9#R+l1Fc)l%=C?i+FO}G8z?AGL#HMibW8AbPK``5Q zx)?PD9#jdU$#CC{3a&tHMZ?3xD|5Th%6aQyIHI~3S7OrCGkw$OwMbU(oL*y+|7W4N zLBwh!>J+9lHx5&eCLc?vH#+EiJjZm&-P_)>e7H8=(vziFs%k{T(RAtPb05!hLLRrf z7T>Ru+KirzO^)fh9uOCZ3s5jR7jrh}HN4T5kFZ_~a?$+xj_-5vqnsmo5>GDq@wDHl z$oTRV77xy1An5Ea#;;L?b5I+>^lC+bG?)Ux8W+liGo%D2RINdtr)Y<*Hcd3wKikXi zv*)#=U@$8XAGQzNM=ATvDBd0vJaz5W_;R!i+n@{0nf#ivo8FG&Lr4vze}>fW1a(hr zot8}feCn>3kCg4Cbmk2)BNIb!4OHzBI#axc=GE!5RgV+fF=%I z2e5x)Q8t96SL?va$1{jZ_w-_!S?J`YYqDHLEZKK1=P(7%(Q zEjD0NKh&JR?F_hLlgL7#&IEhzgPbEw)x9>2gm#W!2|oFC)|*_Z*3aK^_^jI z6iU~|_I*4`Dp(b3I)e_>f}m>EKpjwVw{2sl?H8|P*|I0WMk`6tD(6CSj=xn>Cwbmj zf!!ar9Cj|b_hrYk@x4DRE=0)>O-B(4MxpK+DY8#CR1A&xWPgRK=q8b4NK)q|Dl1lY{QqDt1y2# zLIVvM_@&-q1Lq_KM(jfb{mZX^@qI=prTNGw-y8>C0}}ik1hIsE~fpS^q-gh_e%e1 zyZrxtd&ph@F>ipb_Yv7RKl^F16wkYy?awUh8KaliB;TMWkKkPp$xCLa zqttwayv|uUI`WR<_kJVb`1$f(_Dr5!GK`a|8@asZuBGLv`aiC?LqY#S$JW2Mg&@6% z7Ni3}8Al#wn6s2D>dJYwOzK@l_bf%YLd-zL^7cNS7JL5bhq17m#)kU2Po|R><^Y36 zt+W;s{}CuJIojfbvQ_Lh?YSum--}{|F2acr8V$T+_72S;6+6;a{^KTZ12@KGO&3rD z(gkFdE`ToLAh1D0xD@%kbBxUm9XOE zJdNTcci9Z6AOvok(6Th(`ni?m8^cepdU9JA@&_BmT5BKsRkBJ#~Ep7P1&HkS+cCt4)4kST%uJe`J$!Jh>%v+`ukZ;|B~Pr?of#-#Yl~O6w51(+Z&5_LJv7v!DO%otOjv3A~|x zk}SVPjfDimNP<;>6WkL!CPV!Zc1)sLl*ph&dLw+2CVh>8=0*mgfuuzZgrxWdwxcil zFw(~h0I|0ZS2KY6E$Y(0=_&W!W&qt(|LD)|*Z;UnvlV=}8FT`eOm@^%I%?g9&Vw4< z1^U~|;4enF{E{&6oxz|0Q=i}!Glsfjs3Ozi z9-Xy(y#A!#QTM%~-W`6vGthtuK{62YKm@=Jq*2ThQ18#(aQ}QjRPr&8!{@?d_05M_ zBH}b3Khx3nmEzqt$G5N86RdT>8X)Q8KPXkxvWDsHFuvu4`ot%54JWSa!)0e(xeZ_`4{Jw1p9f0A#PsBSrJZlv3Dm;JK;*`RnvXW+16>T97&V+=rM9?KK^|tUdtQ*2z}_lMN8^1x;hTx`KRziP4!N3$D(k zZSEQf%iPE(Vu8AZf5*q5x662=%Y)tuL_ezXp z)WC?+H-|WVRz?vgiOq*$mlB0D>dMi=x4pEE5N_e{6>55Us;*i~J!-KUd<&szCPPe9 z{0j`PER3|RUT&9zt^I}eton$5%R`pPqP0+qovX`q$&Ur`lN1H#_g4+f;w(Si3KrpZ z5M&U0HT_{zaj0TCZh^{si*sZ^-at=`J)&Xd?kx;OS7{LxbLKAE>c+LFJwQ&DcfsOu zMvIxV=K09gEp=?DmT(mjQ;+2(Lk(lp?{1FE?9>T7k3QJq$=HxHcR}>c2Wf^^_xJq3 zGX!|iTTxsnN6wImV}!1T@bMF*t?T{V>pbrb<+^k9*_yuSzjtGkjyVW3))F~rt-QVi|2rV%{FyFjH_P07Ykz9?Y61zC1iej!p)NGVG~XDK_V zbEYg~$CPA2R-|0~qP2%u5=y!0{eH69om?BwTxgX%y;m+#Ak6!zQeF7`>YV*`w-|SC zN>tb-wk?Q8F}iLTHs`rhwErDf>7ko@-++bRp3z z>t~HSeb-p&Eii&Hx}6i~flcyOf)X+_^Jm;0Ur}9sqrG36y5|D)(*?Fm3r{Zd zEA5Jy`=Gm~E9x^{okaTprq*UOlK!K3QNO28K))}oEaXb>-SI!7wS5rf7VTHXpL>tb zNV->)GU(Or#DrbXK(1XN29oS)F}SHW7*?v&6pq8YaN6cMbibw)val_EQ!rPC*GXe*LY#gCSLcg8`r>M=*a|pz8x<=j_Ns zU}pS;gnERS)jk@JP4{eoch~;%igQIh1#bv`o52_)YqYq&)^R(b!ps(xz8bSvdJgcHz?u-8ccA-` z`h?T;)uXB_!p43kJp%U%t`Co=$_1-vmc~jtRG(($(JKCCRD*u11)zTcj`Y6M*cx(T@3JJE{jHDWeB`=9aBW)3!@>#x5Tt!W1AUa<v%zM*s&;T``g`RHJS?yG+}~p&BM~VwSZ(MG6HMJ-t-P1 z$zOlDJZAXi8=qV|%dw`;jK+P(MlNMaWQfYdY~>mFub{2|AxYGq8D)O|8&Ea;i9qYW z@Ndpo;6~L07l)+@au84&X-SZkDTsz^F-@^H1{q6iO8ajft!osmYj}KBm+cWx44_RQ zrvdx+hRjazov|$^DjSh2@NgJ+NjOJ5>E>d~(?8Jn0e+zE^{DBou5+-SO%xOZ$ezgw z$h+i@)QwRDCuFm3)eP9R>|;{xk#8ntp`KLEDHtnKl~9!sP`U5DcG}{@+itGT9BT@P zBwh+0y{X6i;+0coUO||w>4AUZF8?Dp`rpTYiZNPC>)`)wF~%Xe{CZ(S!0&O^>SYuI zW2WQ=FT;+k^5uadKNyN+NEN8Im|U0AKe;gIte$(C;b=}$mG6ZQ9}R?8bVerT|8Nb{ zj}|TLWz&;Z&HWQ^j71Gy6dbvD{}%c&GUf&$L2nR?xz@L-z7g)^dK&LKTN!_Y>9$DT zS)aXE+TZM-eRkqD<679!)L$sepx+1oUl-UMz)fW*daj~pAVJkyVG>f6vR=E+Jc(bg zKaqK+bdUOXhWmpl0h-Hq+i97p1x51k%fut0>Ev+T=SDZOtQ$QM;){gN$K4_QdaBuH z>;4Nz{rCXM=Q!BM(7@akeVgNG$J$feh+L)_{W&%Udk$-cbvtiK2}K${-0;G4ld zrSB#?roBc@bKsobSULp7tUHGLay)2yyZQh?a?WY>&%ladD-tR64hXvg(Xh|iFKKd(zeJ>8K0wp# zkHEARLh%dGf=Md<&Lmk8L6@l#xJY}9a#-Q+kQb!FG~*6+-xi8Ai}istBq8Xfoil ztpMH>lyVH!eF`{xxC98*9ZkLg?nMK7Xh#T*3PAKT&uw@8ey88-^m`ZlJ}tlRg5P)M z|Irpf2#+Qo#Vo&@wrCEdAJ#PJrG^+G#m=x)Iuu01sz{Xcv=IkTq(BAlbkykct{PY;pSV#LE+@Ylu-iV)U6A7hV-ts7 z8=mJ?8WDmsvtS`KPeX%&mJp9FIdtkPy2$xj-)_rqkBA?n9Ky~jheX!u2x$fe=&DYb z%L~5;`4EP`{^9HJE^YGXCWu8UKCOi3jNE?cpsCt8+rs2?hF3W{{>*cCU$$@Pk$p1> z!B8h`@HKRU5jXlw%He&o+OAk1A91bgGCnm^g(o@s%+=LvsYtR7foCRx%Db-_vFd0NH(oquVsS-qyOaPS012`Zk1t@vWqRePb6MYzz?O)N`P~Wz*QBzeoa@NnT zk=HN32qA!IvLJ!Rlf+5cb_0Z8M=N*t|9+?6>-2jURQ*0JzwZK>-@D+qMF2^K-*>_9 zyWsaO_=|TK#Z!+X7-NSGU=;?(Dh=G;YKE{4mZ-6c8D%#`WpCaDp+f?`i-+vdbnv2> zI3YO`p7SL^Lh1T&du$!O?7pOk*FxAfXCsPWWHfBh$j^Q49RA4XRlx(Lr#;6TOy2tj zMbAD3v>s`y+qE;;V2BuSh+p|Dmy*K?GnTOpS`2;CmaF_{&4rYE_ATy`iPE{~k?xN;{{ zyo<^gJ|*XI!rI%uAy$WjQBbZ|i%c=jfZ~@ijHpF302ikGfD0#5+XzcKzmBR`^Y8r5uwn2+^drCkLRZ$t56NpS)WZlQASAsZiEt$`o2CpHF#@D5C z9&|U(r});MMtpP7ro3cJ5tqrAk!p; z{>~tj5fkW~AfS?{1&|ma1xR+#-e3ya8&*MkL(J`8hv2I)@~ySuNqQ&(P@n7De`ja{ zuL{0P1Av~zc(Mhkp~pk1xAF+f+Ua9tI9;rTphgce;sR}V6;Qf<+Rp>na?~$VO8a%* ziX64hTmQXN46pxi&95sM_p^cc)nX+4I-g(HF_o~)kMY1`$-dGxKzv10_dA3CG62RN zLH{yRJ@_b&VgcgD*ja``7EL!U0dvtB*G z9w$PV11TrGOKLZ02KbV2m#Dpy=_5xlN4L1I?M;G4`dc6$&=RVT&>L(Ih0LriujJW` zdAs*$TbIpk&ll<1X;!?ulIeD5VPDLfObJc=qH#pgdH3g@4>6Uh>Gt&8>f&z+%j3j_ zv$WJ|{x3kt@xB9p>BS^hovsHna9_badf&$N4t?Iz5vu(J(E-3jpa|$bXl{ObQKKSt zh1dAHlifez6y8N8c_-0LLjlPF>?CR@;+=mis`ii9u_RIQn=5fzI(-&zfZ!i51k7*RmtrxYi;CvPm0VC+Jc+#>x8_W+`*LiIVO---2<)Vz^ew6TQ z1yQqKH?b66;4E(xwBjuuljouLRu)I$cT&(xpEQ!@a{qndl2pc_teXJiIpu>zB{fE*S29 zq}5aUvADtho>@puGQ=0o~73xN^gJ_ zA(n^nua%pjd@Abro??CTBjv>(qn545KD}$O*mL4Rd2Rjv6!Aw5pIJzO#%*#}E`IBr zR-a*h`2v4cS2D(%!D9M51C<*>$|fQjVH|)$iBaqDlKY*Jgus=Q${qzLsRdURfYv;r z=W~PcMIC>eYwX>7Z!GGd1hdJJwI&ER{RAAd8>y6S0G~42(~XE2-*#x)*x5s5UU{+Zq>H~Q_0|t79y>}# z0ptlM=*Z};yt;G{wS0!+gp?<{rTh0Li*~Q7cyA2FnmrvFUmlQ`4_gzE-_3P6!!+TF zLDuX?W_C0OEn!W;6EaedS4eqCcWoSuED~~XXOLUVJl}p#eKwJSJ`NA>^OrA(pvmk2h9h;I3MKncG_Af0JmmOL+Lrx3L2(%G z^Z3d6(%w~Vy^?qt$$JqVui^x$b4m2Qy%f_6c#TNEO%#WImNx6l`(>-E2l1bT)}I8A zU6>aOTo}g8FoMrdbzPNT#Tz79ncsF0ve4O|!+B4a$>I~F6x*aILS>;PAc2|_zG}=| z>rn68-kFkQOB2tC>k}9DMT)D=2#G+T z3i38G=R6R6joqWXL>+z0d8>e6amVKc$qjy>0fre)OYoQPAWDN>v$GG5-fcbXY@Rbe z>zB&PY7LV+e^&j(2bVnEcBAW`S$Z)91I#F7W?@BQ1|#eZpE**+Q3`+S{K00VVA%Sa zrn}07_5M*^K}T_L8=Tp*cL7@T`k@7pkD@^b0U$r>j;NP8VXY2sV4dB;KYTY&yT8@? zXy~L}?cMY>P~4y8zKf!W^{%h8<>$iie0^|QH>uUHU|!a5yzHBh$F*y=*mv*;@QmA~ zAMWsDpA}kvDrj;W-2WtSdvINsqDF5-L2w8S3>Wn(j;Qj06g{q@cDl1za!}dUHjbma ziC6h#qobVu)hn$6nva|FvMJi&x;TltosH!jy@PS=yFVCUogqK#)T^4rdi-m-=vfEP z)?gXQ$Wm9CwzH6-IlgA<8Dd^6QM$%fgdFlF#73=Q$Mb!d@{?Dj6h zKfK}m{`vnz@ZWmE3Y@?V8IhjqOrJ`+84Z7sQ@Zmz#_Jt zk}cYm?+m^>2ix*mIa(KI^759uniPk^Np+=U7#A%OciRV2UwWEp%{kq6@|H?zz370~ zACpUUCz0ix{}+4j8P!zSt&5_7fOMp{AVoxaml_eJh=`zcAu1ppqz4EIg7hXJpdcVk zdM}|zx`2xG-hzNqBmoS86z}po=j^lZz2DyF?EPbpJH|afC4SJGSejl%8_jGk?)h59qI zjFJ4k+{?>GZRft{Zb1sC8eLXHQ-`|+lBKvKgVs=TCC zNwxr7BO!6%e{#rw^2vf-;; z;sMAF&J6YP<{;jlSsSksrt!{R?Rp#j_0vI2g?(CGhUj142(%AFcdZ!qV$YFKvA_JF%t zZ*z1SQqhVeD+Ate7b`AMQ20|=a$yeEQ4!kgP>b0f1oQD5|1jaPjCdj6ukhnE4X5J3 zA({UA-!Fm&I0k*unps)J-@|ea!6y_fD0>pq+ z45wYZgaOtERhcwv2}y6(HwSGKTZ1>^Z(lHaCbB8{@ro4kAgEV1p3I0}#_Zn4=dMYj zntz-v30ob#5WS~ueK|u%!!fQ$pJ(T~=;OEDl0+Fy&|peT`)nUr&^lq6>rr^$HH@GN zVSJR2C2*K8{KwpS`0fM>Xgzg?#O3{Ms&OMvW+V50WAiri*JtBo*lu+R#j-kSNH<%( z_(c0LIOrPlXw%`K5EF#{Pz9g$mLxE4Iw19+KmFsbsP9!LC!tCS9xB!zDt~1$x2JGk z@`Obid?Fun|A3KrY0A<0o2IsBwOE|t#c#!+1=W5;z_KE%H_q~#gJ>>6$?{Q zPTY_BA$~UwR+cB`51&&|QZQxU3or*;z{%CQ53~t~0hojFOUwOcPs>92qUlqh!`Le4 zUnDsGBXS-8k=F(f4Xj3Ig9e$S0iit~H23s=K!;_NUG!Z=2Y*Fbf~f(=P;0IJKMYJ} z$#g~=cJ^arPUfB@*I4qWJn5UXabp>mpCQ{#_uGW8^E-=o!3X}X$d^zl3%eWVlW9`R zeU7I#Y8TyRko^w2>p%&jK?V5sk5&LM8+h$~R(9#2$wJXOa&On^`L{XQxd}T|k59!| zi?zWISSu^H^9NgjU{Wq-JEqB-&V@H9im2h1X=9)6El}OWnkeOStH4zM8&lUVHU*9P z0&Gwgm^!Z;`FDoM=eAIum2Nqr4o1OpfFS*)$A$lPPxHStWBgaXrbd6LoA#TwC{)oJ z1B!plrEcHmDOUC4#wSaD_3fg9K8YRf^J*NkfP_>+KISf%W!Ih-UxL-Zh0HvYQ96=d zD7|e|t-facC_}J;CPn*`BrX}nhH!)cs-<9TxGcpOkPNEpx#Jd^tFheQ@P9>L9RGg% z2YU?83-1r{Kmf6@2MPr9#VU~M{Vm(Nn=DUX`q|xi+_byE7w|l{=c2wa%6AtlPNoCa zq|5p7G~_pc%&fpPe9>Z>ED0Rd3pn7@e>v*^IQoCpPmYY5A0d`;O+bjjm6! z^7Lbfln_;v(AV92m}=8>pXTq=*uHIwHznLBn&Qv-Xc#$gcbZERAN=Hk-}R!=>6YM6 zQ(q6e0QU9xhYvH5d^snBf$nuy@NRe4ABrMQl&{p^|K!P8$qX!9E$rMF{~u5AKl=&D z_+LVd_(+3yw*U~<^mXmT7+%7>YBs-~d4T)9-RG7T1y=HBo2bTmB8Oq^7x4f6#VaPU zf*1a-l&h3L3d*c$NtdsW6?l!~GAMOFwWKwTSH;xPTnlAkq(I1lfet3tpY2@xFeSpN zg@p0}^Nxy2&l{Q3jJ39fww=Hm+msWiiUqPfS&RG`)I_rf!HNagR@xFIr4{g_1^DcK zg&x`0go4y(iTPJNDDK|VrF?h3)!}Czkjg}SfX{bd#=!Deat6Lx2V=RNrlj^BBT-Hw zRB^A)@v#zpD&)TE&~Q^=R~K{odA;Mo?x^^M?$m2zZULjQoVOm249>F11EH*qVua)w zj8q`CJ&AfO%jL4WNwoR-`RNR*DntqOJqzlYt#M;4A15tZuO zl5tyGr*};%s_ydZc=A127JJgX`SC_a-M~j1avaJNbgERF@P`5?xq~{pcYKcc6VW3Q zg(Rv3CT#DmlF}=JZR>N%CYbH+JaD$=?38Xv3bxyJ|&T_hG>J&FBvX|W(^uLa9a2g8y8(u$tV8h(}KaYVtiZX zNxtVqnLh&`cn!3d1K=7j^ZAH6*!0^I-}67h)jHj=!7MVF?MY)}0Sw;}l?r$54TgIg zTBb!SDbA5B;CuRWLZE1HFDgDie2|jh2GdaKxGRokN^N|mvQM5#;PV-jpXAu(L?FfY zOR$jj<(R$c_5G*2)<*aT#yX|*2Q#wL5wQauW84Y~8S8Ttdu>eLImh0>=rH2(Z~^!N zic#|%diP4>tiLS(4~yB%wKxXffwGT}yl$F@@4hk^657b7AOXm6L=upC>cDgeGOIrk z7s(v+wqqN{Hsb+w2i}*yBI}z{zsJj^M)Pe4CZ&uW7KYzxSw|jCt^-9?#9AG=2@+F) z9Si?${B-+fm((}AN>_Cyws3Q@`LQ=Z~0OJRs{|F++t zi#xoJI4w`)L`I~%_60sFuCel)=?&M9QAbinCaut87ReV8gnLl$wXGO}7Exg!ax}`}rNOx7j$GM__16ogIilgPdV)aj5*>I2;BJpP|Oad{Glk73?Ty*UuOtCw4)c&0>nA=_?f{_ zS(cwGD&uKqD~N2DEv|8;9E^!brQh$`9S7V7-mn(-oRratz-;%{g_YWNHbw7@fY6zt z^szNFKr-e9xjNXkA*FC*D;x||i`HUaB6=6`$>1FtPe7qVxE+C)k!pVn$bDaT0%2ur zwVo7!kLQNn!~nMJt$A`pSM;vZRZpP44DvBmO|cGHatij3JxEJa6Lw zg9+br?xB>8$HpYd zH0_~tZI^#O(2kb}#Llt_>W9#Lw0)9noU&t-bmk7AfIhjE@#N;`GM*a41$uePrP&1X z7@~z{A4H(vIXigK^hM=r^)DIK9bP7st3qte6qQ0nWuKB+#{JT*g^!FQ&x^xY(Euj> zhho1P>vhO{ktj2%L}I?*{JN%}O}9pmsiGeLI$X2|m_M zf%ioJbjY&C;8HzZ1D|?gtIALck_eW&do~4w zlob-0XvXqrI67{C{*3>B5gN&|$wKYK5LUm<*aeK^@7-Bt0bKIRU;R6XHpPGDf0q5L zNbp{2F?>3oZgbLuP12hW3N!R8u-9e}E@s3vAYDo?o&)!;LtYhwT3m{!k9h-wz#OQx zH;Cr$TG2G}CorF&5r_l&c+|77dCSZ>epc8{-EQf$WzjHEus)(Q*db`&7%l;&1`mvjXsmad7<$s<#Xxcf0q;F-4!NHe~F0s*1i;h~NYMP)I;# zQM=tme<(goLRzNrbOdSq5)p`6B3`;8Sb0oA{b%lO_hM-uhIVl{IZ>qDuy`tG_!EK( zn6@k}7}BpT1I9VE?%y5Dhuc&B1ot-{zq|_LL*K;~1(^rS&$^|j$GpP5<#bC=LSn zGMs9l5<$QF0AOhHT>!xy^3VQgYl%;EfnC1MZgHjOzw4?3f!cug=^bPgV2aS40rdKt z6FdPxhy%5GZH4O(Ma`KdIrSgOk)wmrKSm_(-yf0N?EiaDpSibeRnu-@$CQjn^NZ&U zX|1<-)*S24SBVtIHt6+agbPK!()pqDp61^ke(2`*J~hVK1Yb?_k+90KaC@Wj)d#Js z2S!=zo2LA-Gj?$QckzVZwAUOYIl&3pZ5(ngvuV29)1LH*&2W~(ya06^DmPV3+ zQMR~J@IQx|$RO+Lzj$4bF!;M7R+rrRKcjpRe(=YL_^VaMz&D_; z{|JCGp5ei38hxes?I9bk7_V@uzOtRbmNbeGSffE{eu+2UcF3L<`=xOOFW#>n6f3>4 zUOf40z2o*+<;~C3Tms1zz=3rBwV3X|`TO$~89*LscKsCamOw9y^gT0eyHJAgc5VyP zfA=%>xSE+By4_>1))We0B=|@ZEOnLRg)Ebf=wHg>@1^PG*dIv&mb}?SUHmYnXkBP> z5sgS_LeVo?=SqW{yf#{nK8M1-k1M~Xmw1CKZbr!cA2qyqkf&Cs#GZQlTh;e zZ=9fiIX#X@bS;}JoDtJqk0$vnXsPNpwsyBUn(fuu>P>tCsz^}}!qvZB_|0*&y7!Y{ z43j67!Q{)K$o0?_<;?V8oW#H$$oZAgW>qAm-}w?Nzx>|rmj&|8j|=Mq4%nbUy)zD` zSnW#JVjIQS{@L^)ZyvuicBRB3QOZHTN5vp6GTYKfoh@|nR;K=SbK^VnZ}M+Yz5FIA zm~dOTp*`A+RzxWIrP;T0|8lzj3khT3bu?(py(3_C(!j?6`{nNg5~KTx@DRy1%pJ4( z*XrtZE>ZXI%sU}RHxp9-mOq=YIhP-wIQ=KGpda^8|Ifte$GvdY47)qPV9V)zXK_zU z0AjcBH57R|vMr9&!RD;QBJjmWHdw;&$iPQxCKG6+e&~vpFfSriO?4-F3 zZe+}?G5_AwgYOMY9QsQ}XO> zOpiTd%XBiz`~BSQ@=y|^2?Ce&4?cRv269@ph3xfd6P3lXG|`M6pM%{>SB zcn8S7Sqr$K;BvfCZ~OGf%C5R{2C4V4R2C<8WP=~`wKzEfIc?4^Oi@up!9;OBGoE5- zMpNrOH2R!p?a!8lch`K`cG%zQoLv`A*8{MYPK`^pc!W{&1lq$%`mq7~#)q2}lF$Cz zHu7iU|Hr`zunU~Sc<&!n!)F!{y{8`FXCUT*a{W;D@`~lf)*OonHaUxl@hKW9Ci)^n zq2Wbtq3dJ=*(%wlj``#Ldn-mp9nLPB(T?)NeC2(Tl@t#nd#D^OPl_P&Fa#;3`y6>9 z^PaXS-dC}5ZyvCdNbtNP#ULYoANH{;&D8B!V#99*(y_5$7P2%LssWT0hh?r+prXz@72t4&~joP6eYC`qcepA{paV0@1&z z62otZ^0O(vm_QX?{E@L&JGYfoD;Wep8t?0Bw?j9w_KgVo@I^4_7s?qRFq^fG!^EAX zUUeq;~VzJN6YU)L{^Pno2NfOmpTJ6MQ#d@=3MJX;Ab~ukJM9c?0qt+8UJZ* zVv$;OsG%62`bww@U{!s9Wd9zcm2s90IUXr!ze%_(*B7bASB&@44j+BLR8(ZMQ znUe~oQBJiBh2)Kgbks zTO0GM<#;H!+*%vVFf&VJ!{pzecUY%AXsWUrx> zg3O(@sy1MUhElk9$2RgWE!GrVZ^~xOY;$X2w$2T+cY>f>?{zA%;)2JW>HVP1$KSiS3p;ODt+1hj?9+y-lu&Q zWmO+1BkgO?0+7gAKRq4I{jKw z*zy^7IYa8g(IyR#^tJoQvzbGnBn0>m1yZmp7&{3(8RLj&De-W*{GL^YD&Afew2nYq z+SX?~o=<+8Z%Z-;8VrSmwVC8Qg682Dfd|S8riC}cI`<$rfMUau?F6I`iLtY{S$R{F zc{b0@BV_&9)`2?%Zm}e4MtAD6?fD}zRjg7=l6+B_aF=+4^tPM%N1i0!+V5%hOhHXg z>1P=<7oX?K4B8>~gn?~bTwF8E4`NQF$49F6Ln0B(ME9DdMFIEz_6r$h%R}cb7H<8T zP%EL$i8E&!q7;2G=#Bw&_d5tzpy2i1NAQVki$+916~MChv00io+01dd)sk-Th36uu zijpFYLNt)$*m)1wnW-l6Pl|u8(xP0=vG$Eu>dxS)XmCBEs2aH-BVE)g|6Lz7%7EWZ zyFgc5d>ZeQa!o4-S3ruEC99Js$rtd;p4jt@7ql4t=N3(}g=eW;PrUtd^x3XbpKMUW zEk+%;DUVlB=TK_}-vM_VnveW~sZhrhBIwcV;y(($3;F$sM(3U{U=s}Wa6J~0R3qBd z*m1GSQ@VQEX2)@f_DJq0ucJ?AT@RoJE?Iva=@@oW2_5a_W&9oj@2IhIoqgcoXsK$d zE3*AzI*@9+MY15-U^B@nF0v@x{PlO15SH6;dKfT$A`ItX_wm6_SlNv~6iLlxown#t zTxKqwyegrH=BugNvtkoQqLVCsLVR*VUiVZ%l6ccxSMXxP#xDJ(4Zg@hHveUCJb7E4~x?XtOAH^t{CYri;*o*JG2TdmUo+a`ae{KABEOuuiEkQ-#iW zC86^fpm85en0Ig?IkveC3AV9Y^7(pmLo~aP;h{ZSjQ$2>U$zQgx;FNLXsQ}TqzMpf zK8g2YA=aewm@O#8n{PQwUzr=F#mg*J%yz=(LG{{21e!&>{s!{n0q;&?Tvr zt(~imPeY#Ay#PnSOtCq*cay zWuf&fdSz^z*K(`OH4t(8lD&=XBHw7-gk-?E#KfNal;3`7KF#&^^A5WB2;iOQ3XQbO zIX&6azkpI!W}eG`hym}3VMTBNCipUMW6!q$zP&&PE z=e9~>pJc1g(bACOizR0PM#RlO6iu^3Ns7JTdQ?1I1s}NW5rT>-N;iBB%K17YVo=TR zP;Qa?XroT6{90D)vWC@J@0jW2Z;Gwn9m!PI1@eQ+eeD?6>&g(zStSVbe6Ftjl=ShU z`P!)8HC=A)z3&%^z$Zk6EG?2pQFU4Uh=rI(&F*o^!JBPO;c1-ED(1O;mNS~pH1lVm zz6ixc%h%*lNd0OYU}k8sfZP`+m_lbQ@+Qc?Y>l<~#N*W*Sy;CectkRKtDxn=Z8{2~3NQQkW# z47~JubgErYOSqlT(13}>8GR^u}WMPicH-Ki4x|v$yT1wFLFy~ZG z9eXRm@O4!Pe0lyDU|zCwtyO^=0X`pUeYU5=&hGbIrxto{%Dz*0xr9r8C+pFmK=1xh zAZg>Bb8?1Ekfr<0HnzaKq!;*0nEh@hA{PeHXPax~PSeM0*Og#ItjWGkoO{UHVdHTJ;&U!rZ8;>F| z1M(7FVE0uzJE-_WY}jlxnGx!4mIh4Xi|GLsCj3rm*IO+ElJ371TdKdn$DaAb`0I=z z-OUrv{3-h+v;bv);NVf;LT*dBSE*~-jAQOOfrQH<%Jq=Z?R`EBcmS}oL?jDRxB(QZ z1Sol2-^I?3w`;1il@aSp@F-5oVyaNM zr#56J`7;F%l_j$Gkz+L>_&d9+#B_7}!Yz)ACa=liWwqNUWI=iWyOjfoYs>(K(th&a zTj8jIDgFjAP6N~s>FfXmDa{?^lGK$Bet%8!lmv9nMEs4e!9OAgfW@r_s006P8SFu< zeE=Qnp#M%EdFTIL3s8uRMC$ zuuV04Y-g7tFmb)SQY{3as#xcw&>xD02OA!Me5d%HyYfJ8qT;BlOiAgd z%kAAzCh<3Rj$zpo3QPh#)*qLwq94`*H2DSR0ZTFs;ASlx+BYN07sf%i3xRB|`dj_Hc@@^FVL>q2nggmU-gc5m(Z&m#%3L4&&dX~7Tx$9F;Cuf}{t z&F7=}Uu3#fLB*x<5GPtb2yFjN1S0 z|4l|Y;d-;-1&i?-5!-0N@ysQ}HDUqq1Q(GfL98%ZO%Z|yjIX10veR^9$w6O-?h@#$YwmWzagaV5p-Aag$Fix zLXUebUA@r(EE71b)-f;qkfUavU}vtq>VO*qDzZ&Oxc42z+>OtRyGXU6Zb@t;na&kE zg!T|r!yfDOIk0}jkcQ0CTpTHmdjGRof8dyJf$MOmjlUA;E!-k&G;Sw zzU#T)X|z7}f@{LHTWQwv-elD;;a4}u^#ckPOZrZWFL7HL)d!qToqw=(KE1r8=fTX- z@jIC1x=$4_`K|{f$X7am9SFA&E4e!MovQLeugjWL%e4GZ>r zb++ZQmuGpr)MfBk45IdBZ)6R^r2+TV8fvtb(yL{;A^Q=+z55NC^RZ>W(m>WZ=H%4^ zvx2Ko=7MBUgw;2tc;C}SBt>qIUw5n;mj(P}#%0Dox}~*~>lMD3|WHE%U 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

    t7op9Kii+bGm?A%w|rX6ipt=a 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 Date: Wed, 25 Sep 2024 00:56:13 -0700 Subject: [PATCH 14/19] reformat code using black --- knowledge_storm/__init__.py | 2 +- knowledge_storm/collaborative_storm/engine.py | 31 ++++++++++--------- .../modules/co_storm_agents.py | 12 ++++--- .../modules/grounded_question_generation.py | 1 + knowledge_storm/dataclass.py | 22 ++++++------- knowledge_storm/interface.py | 9 +++--- 6 files changed, 42 insertions(+), 35 deletions(-) diff --git a/knowledge_storm/__init__.py b/knowledge_storm/__init__.py index 7a55e52..f93158a 100644 --- a/knowledge_storm/__init__.py +++ b/knowledge_storm/__init__.py @@ -7,4 +7,4 @@ from .utils import * from .dataclass import * -__version__ = "1.0.0" \ No newline at end of file +__version__ = "1.0.0" diff --git a/knowledge_storm/collaborative_storm/engine.py b/knowledge_storm/collaborative_storm/engine.py index 2a68a3d..01684b9 100644 --- a/knowledge_storm/collaborative_storm/engine.py +++ b/knowledge_storm/collaborative_storm/engine.py @@ -296,19 +296,20 @@ class TurnPolicySpec: Represents the policy specifications for determining the behavior of a conversation turn. Attributes: - should_reorganize_knowledge_base (bool): - A flag that indicates whether the knowledge base should be reorganized after the current turn. - - should_update_experts_list (bool): + should_reorganize_knowledge_base (bool): + A flag that indicates whether the knowledge base should be reorganized after the current turn. + + should_update_experts_list (bool): A flag that indicates whether the list of experts should be updated based on the conversation context. - - should_polish_utterance (bool): + + should_polish_utterance (bool): A flag that indicates whether the generated utterance should be polished (e.g., refined or rephrased) before it is used in the conversation. - - agent (Agent): - The `Agent` responsible for generating utterances or responses during the conversation turn. - This agent interacts with the knowledge base and the conversation history to produce responses. + + agent (Agent): + The `Agent` responsible for generating utterances or responses during the conversation turn. + This agent interacts with the knowledge base and the conversation history to produce responses. """ + should_reorganize_knowledge_base: bool = False should_update_experts_list: bool = False should_polish_utterance: bool = False @@ -626,7 +627,7 @@ def warm_start(self): def generate_report(self) -> str: """ - Generate report leveraging organized collected information in the knowledge base (i.e. mind map). + Generate report leveraging organized collected information in the knowledge base (i.e. mind map). The article generation follows the paradigm in STORM paper, where it considers mind map nodes as section names, and generate the report section by section. Returns: @@ -650,8 +651,8 @@ def step( """ Yields a single turn in the conversation flow. - This method take a user input when user choose to inject an utterance or generates the next system utterance based on the current conversation history and defined discourse policies. - It handles updating the conversation history, managing expert lists, and interacting with the knowledge base. + This method take a user input when user choose to inject an utterance or generates the next system utterance based on the current conversation history and defined discourse policies. + It handles updating the conversation history, managing expert lists, and interacting with the knowledge base. Additionally, it logs each stage of the conversation for monitoring and debugging purposes. Args: @@ -665,13 +666,13 @@ def step( Workflow: 1. User Utterance Handling - If `user_utterance` is provided, it is appended to the `conversation_history` - + 2. System Utterance Generation - If no `user_utterance` is provided, the method proceeds to generate the next system utterance. - Determines the next turn policy by consulting the `discourse_manager` with the current conversation history. - Generates a new utterance using the agent defined in the turn policy, leveraging the `knowledge_base` and `conversation_history`. - If the turn policy indicates that the experts list should be updated, it updates the expert list based on the latest utterances. - + 4. Knowledge Base Update - Inserts the new turn into the `knowledge_base`, optionally allowing the creation of new nodes or inserting under the root based on the `rag_only_baseline_mode` flag. - If the turn policy specifies, it reorganizes the `knowledge_base` to maintain optimal structure and relevance. diff --git a/knowledge_storm/collaborative_storm/modules/co_storm_agents.py b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py index 3fbe122..afc138d 100644 --- a/knowledge_storm/collaborative_storm/modules/co_storm_agents.py +++ b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py @@ -24,7 +24,7 @@ class CoStormExpert(Agent): """ Represents an expert agent in the Co-STORM framework. - The `CoStormExpert` is a specialized type of `Agent` that is tasked with participating in roundtable discussions within the Co-STORM system. + The `CoStormExpert` is a specialized type of `Agent` that is tasked with participating in roundtable discussions within the Co-STORM system. The expert uses language models to generate action plans, answer questions, and polish its utterances based on the current conversation history and knowledge base. It interacts with modules for action planning and question answering grounding on provided retrieval models. @@ -38,6 +38,7 @@ class CoStormExpert(Agent): rm (Optional[dspy.Retrieve], optional): A retrieval module used for fetching external knowledge or context. callback_handler (BaseCallbackHandler, optional): Handles log message printing """ + def __init__( self, topic: str, @@ -112,6 +113,7 @@ class SimulatedUser(Agent): For more information, please refer to Section 3.4 of Co-STORM paper: https://www.arxiv.org/pdf/2408.15232 """ + def __init__( self, topic: str, @@ -155,13 +157,14 @@ def generate_utterance( class Moderator(Agent): """ - The moderator's role in the Co-STORM framework is to inject new perspectives into the conversation to avoid stagnation, repetition, or overly niche discussions. - This is achieved by generating questions based on unused, uncited snippets of information retrieved since the last moderator's turn. - The selected information is reranked according to its relevance to the conversation topic and its dissimilarity to the original question. + The moderator's role in the Co-STORM framework is to inject new perspectives into the conversation to avoid stagnation, repetition, or overly niche discussions. + This is achieved by generating questions based on unused, uncited snippets of information retrieved since the last moderator's turn. + The selected information is reranked according to its relevance to the conversation topic and its dissimilarity to the original question. The resulting top-ranked snippets are used to generate an informed question to be presented to the conversation participants. For more information, please refer to Section 3.5 of Co-STORM paper: https://www.arxiv.org/pdf/2408.15232 """ + def __init__( self, topic: str, @@ -319,6 +322,7 @@ class PureRAGAgent(Agent): It does not utilize any other information besides query itself. It's designed for Co-STORM paper baseline comparison. """ + def __init__( self, topic: str, diff --git a/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py b/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py index 8f810d9..331692c 100644 --- a/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py +++ b/knowledge_storm/collaborative_storm/modules/grounded_question_generation.py @@ -6,6 +6,7 @@ For more detailed information, refer to Section 3.5 of the Co-STORM paper: https://www.arxiv.org/pdf/2408.15232. """ + import dspy from typing import List, Union diff --git a/knowledge_storm/dataclass.py b/knowledge_storm/dataclass.py index 153b961..fd98190 100644 --- a/knowledge_storm/dataclass.py +++ b/knowledge_storm/dataclass.py @@ -292,14 +292,14 @@ class KnowledgeBase: """ Represents the dynamic, hierarchical mind map used in Co-STORM to track and organize discourse. - The knowledge base serves as a shared conceptual space between the user and the system, allowing for effective collaboration by reducing the user's cognitive load and ensuring that the discourse is easy to follow. - + The knowledge base serves as a shared conceptual space between the user and the system, allowing for effective collaboration by reducing the user's cognitive load and ensuring that the discourse is easy to follow. + The knowledge base is structured as a tree (or mind map) that dynamically organizes collected information and concepts as the conversation progresses. - The mind map consists of concepts (nodes) and edges that represent parent-child relationships among topics. Each concept is linked to retrieved information, + The mind map consists of concepts (nodes) and edges that represent parent-child relationships among topics. Each concept is linked to retrieved information, which is placed under the most appropriate concept based on its associated question and semantic similarity. - For more details, please refer to Section 3.2 of Co-STORM paper: https://www.arxiv.org/pdf/2408.15232 + For more details, please refer to Section 3.2 of Co-STORM paper: https://www.arxiv.org/pdf/2408.15232 Attributes: root (KnowledgeNode): The root node of the hierarchical knowledge base, representing the top-level concept. @@ -827,14 +827,14 @@ def get_knowledge_base_summary(self): def reogranize(self): """ - Reorganizes the knowledge base through two main processes: top-down expansion and bottom-up cleaning. + Reorganizes the knowledge base through two main processes: top-down expansion and bottom-up cleaning. - The reorganization process ensures that the knowledge base remains well-structured and relevant as new information is added. It consists of the following steps: - 1.Top-Down Expansion: Expands nodes that have accumulated significant amounts of information by creating subtopics, - ensuring that each concept remains specific and manageable. - 2.Bottom-Up Cleaning: Cleans the knowledge base by removing empty leaf nodes (nodes with no supporting information) - and merging nodes that have only a single child, simplifying the structure and maintaining clarity. - """ + The reorganization process ensures that the knowledge base remains well-structured and relevant as new information is added. It consists of the following steps: + 1.Top-Down Expansion: Expands nodes that have accumulated significant amounts of information by creating subtopics, + ensuring that each concept remains specific and manageable. + 2.Bottom-Up Cleaning: Cleans the knowledge base by removing empty leaf nodes (nodes with no supporting information) + and merging nodes that have only a single child, simplifying the structure and maintaining clarity. + """ # pre-processing self.trim_empty_leaf_nodes() self.merge_single_child_nodes() diff --git a/knowledge_storm/interface.py b/knowledge_storm/interface.py index f5727d5..5922602 100644 --- a/knowledge_storm/interface.py +++ b/knowledge_storm/interface.py @@ -567,13 +567,13 @@ class Agent(ABC): """ Interface for STORM and Co-STORM LLM agent - This class must be implemented by any subclass of `Agent` to define how the agent generates an utterance. - The generated utterance can be influenced by the conversation history, knowledge base, and any additional parameters passed via `kwargs`. + This class must be implemented by any subclass of `Agent` to define how the agent generates an utterance. + The generated utterance can be influenced by the conversation history, knowledge base, and any additional parameters passed via `kwargs`. The implementation should align with the specific role and perspective of the agent, as defined by the agent's topic, role name, and role description. Args: - knowledge_base (KnowledgeBase): The current knowledge base (e.g., mind map in Co-STORM) that contains the accumulated information relevant to the conversation. - conversation_history (List[ConversationTurn]): A list of past conversation turns, providing context for generating the next utterance. + knowledge_base (KnowledgeBase): The current knowledge base (e.g., mind map in Co-STORM) that contains the accumulated information relevant to the conversation. + conversation_history (List[ConversationTurn]): A list of past conversation turns, providing context for generating the next utterance. The agent can refer to this history to maintain continuity and relevance in the conversation. logging_wrapper (LoggingWrapper): A wrapper used for logging important events during the utterance generation process. **kwargs: Additional arguments that can be passed to the method for more specialized utterance generation behavior depending on the agent's specific implementation. @@ -585,6 +585,7 @@ class Agent(ABC): - Subclasses of `Agent` should define the exact strategy for generating the utterance, which could involve interacting with a language model, retrieving relevant knowledge, or following specific conversational policies. - The agent's role, perspective, and the knowledge base content will influence how the utterance is formulated. """ + from .dataclass import KnowledgeBase, ConversationTurn def __init__(self, topic: str, role_name: str, role_description: str): From 0777607873a5581b167936b18f1ed28af44cf4cf Mon Sep 17 00:00:00 2001 From: Yijia Shao <67158122+shaoyijia@users.noreply.github.com> Date: Wed, 25 Sep 2024 10:06:43 -0700 Subject: [PATCH 15/19] Polish README.md for co-storm release. --- README.md | 44 +++++++++++++++++++++----------------------- 1 file changed, 21 insertions(+), 23 deletions(-) diff --git a/README.md b/README.md index 8b03be2..382aa32 100644 --- a/README.md +++ b/README.md @@ -9,9 +9,9 @@

    **Latest News** 🔥 -- [2024/09] Release Co-STORM codebase and intergrated into knowledge-storm python package. +- [2024/09] Co-STORM codebase is now released and integrated into `knowledge-storm` python package v1.0.0. Run `pip install knowledge-storm --upgrade` to check it out. -- [2024/09] Introduce collaborative STORM (Co-STORM) to support human-AI collaborative knowledge curation! [Co-STORM Paper](https://www.arxiv.org/abs/2408.15232) accepted to 2024 EMNLP. +- [2024/09] We introduce collaborative STORM (Co-STORM) to support human-AI collaborative knowledge curation! [Co-STORM Paper](https://www.arxiv.org/abs/2408.15232) has been accepted to EMNLP 2024 main conference. - [2024/07] You can now install our package with `pip install knowledge-storm`! - [2024/07] We add `VectorRM` to support grounding on user-provided documents, complementing existing support of search engines (`YouRM`, `BingSearch`). (check out [#58](https://github.com/stanford-oval/storm/pull/58)) @@ -35,7 +35,7 @@ While the system cannot produce publication-ready articles that often require a -## How STORM / Co-STORM works +## How STORM & Co-STORM works ### STORM @@ -51,23 +51,21 @@ STORM identifies the core of automating the research process as automatically co 1. **Perspective-Guided Question Asking**: Given the input topic, STORM discovers different perspectives by surveying existing articles from similar topics and uses them to control the question-asking process. 2. **Simulated Conversation**: STORM simulates a conversation between a Wikipedia writer and a topic expert grounded in Internet sources to enable the language model to update its understanding of the topic and ask follow-up questions. -Based on the separation of the two stages, STORM is implemented in a highly modular way using [dspy](https://github.com/stanfordnlp/dspy). - ### CO-STORM -Co-STORM proposes collaborative discourse protocol which implements conversation turn policy management controlling smooth collaboration among +Co-STORM proposes **a collaborative discourse protocol** which implements a turn management policy to support smooth collaboration among -- **Co-STORM LLM experts**: This type of agent generate answers grounded on external knowledge sources and/or raise follow up questions based on discourse history. -- **Moderator**: This agent generate thought provoking questions taking inspiring from collection information provided by Co-STORM LLM experts. -- **Human user**: Human user will take the initiative to either (1) observe the discourse to gain deeper understanding of the topic, or (2) actively engaging in the conversation by injecting utterances to steer the discussion focus +- **Co-STORM LLM experts**: This type of agent generates answers grounded on external knowledge sources and/or raises follow-up questions based on the discourse history. +- **Moderator**: This agent generates thought-provoking questions inspired by information discovered by the retriever but not directly used in previous turns. Question generation can also be grounded! +- **Human user**: The human user will take the initiative to either (1) observe the discourse to gain deeper understanding of the topic, or (2) actively engage in the conversation by injecting utterances to steer the discussion focus.

    -Co-STORM also maintains a dynamic updated **mind map**, which organize collected information into hirarchical concept structure, aiming to build a shared conceptual space between the human user and the system while reducing the mental load when having long in depth discourse. +Co-STORM also maintains a dynamic updated **mind map**, which organize collected information into a hierarchical concept structure, aiming to **build a shared conceptual space between the human user and the system**. The mind map has been proven to help reduce the mental load when the discourse goes long and in-depth. -Co-STORM is also implemented in a highly modular way using [dspy](https://github.com/stanfordnlp/dspy). +Both STORM and Co-STORM are implemented in a highly modular way using [dspy](https://github.com/stanfordnlp/dspy). ## Installation @@ -152,7 +150,7 @@ runner.summary() ### Co-STORM -The Co-STORM knowledge curation engine is defined as a simple Python `STORMWikiRunner` class. Here is an example of using Bing search engine and OpenAI models. +The Co-STORM knowledge curation engine is defined as a simple Python `CoStormRunner` class. Here is an example of using Bing search engine and OpenAI models. ```python from knowledge_storm.collaborative_storm.engine import CollaborativeStormLMConfigs, RunnerArgument, CoStormRunner @@ -183,7 +181,7 @@ lm_config.set_warmstart_outline_gen_lm(warmstart_outline_gen_lm) lm_config.set_question_asking_lm(question_asking_lm) lm_config.set_knowledge_base_lm(knowledge_base_lm) -# Check out the CoSTORM's RunnerArguments class for more configurations. +# Check out the Co-STORM's RunnerArguments class for more configurations. topic = input('Topic: ') runner_argument = RunnerArgument(topic=topic, ...) logging_wrapper = LoggingWrapper(lm_config) @@ -198,17 +196,17 @@ costorm_runner = CoStormRunner(lm_config=lm_config, The `CoStormRunner` instance can be evoked with the `warmstart()` and `step(...)` methods. ```python -# warm start the system to build shared conceptual space between Co-STORM and users +# Warm start the system to build shared conceptual space between Co-STORM and users costorm_runner.warm_start() -# step through the collaborative discourse -# running either of code below in any order for as many times as you would like -# Either by observing the conversation via running +# Step through the collaborative discourse +# Run either of the code snippets below in any order, as many times as you'd like +# To observe the conversation: conv_turn = costorm_runner.step() -# Or by actively engaging in the conversation to inject your utterance via running +# To inject your utterance to actively steer the conversation: costorm_runner.step(user_utterance="YOUR UTTERANCE HERE") -# generate report +# Generate report based on the collaborative discourse costorm_runner.knowledge_base.reogranize() article = costorm_runner.generate_report() print(article) @@ -283,15 +281,15 @@ The interface for each module is defined in `knowledge_storm/interface.py`, whil If you have installed the source code, you can customize Co-STORM based on your own use case -1. Co-STORM introduces multiple LLM agent types (i.e. CoSTORM experts and Moderator). LLM agent interface is defined in `knowledge_storm/interface.py` , while its implementation are instantiated in `knowledge_storm/collaborative_storm/modules/co_storm_agents.py`. Different LLM agent policy can be customized. -2. Co-STORM introduces collaborative discourse protocol and the core function is turn policy management. We provide an example implementation of turn policy management through DiscourseManager in `knowledge_storm/collaborative_storm/engine.py`. It can be customized and further improved. +1. Co-STORM introduces multiple LLM agent types (i.e. Co-STORM experts and Moderator). LLM agent interface is defined in `knowledge_storm/interface.py` , while its implementation is instantiated in `knowledge_storm/collaborative_storm/modules/co_storm_agents.py`. Different LLM agent policies can be customized. +2. Co-STORM introduces a collaborative discourse protocol, with its core function centered on turn policy management. We provide an example implementation of turn policy management through `DiscourseManager` in `knowledge_storm/collaborative_storm/engine.py`. It can be customized and further improved. ## Replicate Replicate STORM & Co-STORM paper result For STORM paper experiments, please switch to the branch `NAACL-2024-code-backup` [here](https://github.com/stanford-oval/storm/tree/NAACL-2024-code-backup). -For Co-STORM paper experiments, please switch to the branch `EMNLP-2024-code-backup` (place holder right now, will be updated soon). +For Co-STORM paper experiments, please switch to the branch `EMNLP-2024-code-backup` (placeholder for now, will be updated soon). ## Roadmap & Contributions Our team is actively working on: @@ -303,7 +301,7 @@ If you have any questions or suggestions, please feel free to open an issue or p Contact person: [Yijia Shao](mailto:shaoyj@stanford.edu) and [Yucheng Jiang](mailto:yuchengj@stanford.edu) ## Acknowledgement -We would like to thank Wikipedia for their excellent open-source content. The FreshWiki dataset is sourced from Wikipedia, licensed under the Creative Commons Attribution-ShareAlike (CC BY-SA) license. +We would like to thank Wikipedia for its excellent open-source content. The FreshWiki dataset is sourced from Wikipedia, licensed under the Creative Commons Attribution-ShareAlike (CC BY-SA) license. We are very grateful to [Michelle Lam](https://michelle123lam.github.io/) for designing the logo for this project and [Dekun Ma](https://dekun.me) for leading the UI development. From 4c16d2e9e194a786220d0370dff26edb718461e1 Mon Sep 17 00:00:00 2001 From: Yijia Shao <67158122+shaoyijia@users.noreply.github.com> Date: Wed, 25 Sep 2024 10:10:07 -0700 Subject: [PATCH 16/19] Update run_costorm_gpt.py --- examples/costorm_examples/run_costorm_gpt.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/examples/costorm_examples/run_costorm_gpt.py b/examples/costorm_examples/run_costorm_gpt.py index 8fe6c7f..66d6bd3 100644 --- a/examples/costorm_examples/run_costorm_gpt.py +++ b/examples/costorm_examples/run_costorm_gpt.py @@ -1,5 +1,5 @@ """ -STORM Wiki pipeline powered by GPT-4o/4o-mini and Bing search engine. +Co-STORM pipeline powered by GPT-4o/4o-mini and Bing search engine. You need to set up the following environment variables to run this script: - OPENAI_API_KEY: OpenAI API key - OPENAI_API_TYPE: OpenAI API type (e.g., 'openai' or 'azure') @@ -116,6 +116,9 @@ def main(args): # warm start the system costorm_runner.warm_start() + # Below is an example of how users may interact with Co-STORM to seek information together + # In actual deployment, we suggest allowing the user to decide whether to observe the agent utterance or inject a turn + # observing Co-STORM LLM agent utterance for 5 turns for _ in range(1): conv_turn = costorm_runner.step() @@ -235,4 +238,4 @@ def main(args): help='If set, enable console log print.' ) - main(parser.parse_args()) \ No newline at end of file + main(parser.parse_args()) From b35c27229a5261f80c1b297c60bc5da84f5bcc0b Mon Sep 17 00:00:00 2001 From: Yijia Shao <67158122+shaoyijia@users.noreply.github.com> Date: Wed, 25 Sep 2024 10:15:59 -0700 Subject: [PATCH 17/19] Update comments. --- .../collaborative_storm/modules/co_storm_agents.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/knowledge_storm/collaborative_storm/modules/co_storm_agents.py b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py index afc138d..e092cd6 100644 --- a/knowledge_storm/collaborative_storm/modules/co_storm_agents.py +++ b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py @@ -109,8 +109,9 @@ def generate_utterance( class SimulatedUser(Agent): """ - Simulated Users is a special type of Agent in Co-STORM that simulate real user interaction behavior or automatic experiments. - + Simulated Users is a special type of Agent in Co-STORM that simulates real user interaction behavior based on the given intent. + + This class can be used for automatic experiments. For more information, please refer to Section 3.4 of Co-STORM paper: https://www.arxiv.org/pdf/2408.15232 """ @@ -318,8 +319,9 @@ def generate_utterance( class PureRAGAgent(Agent): """ - PureRAGAgent only handles grounded question generation by retrieving information from retriever based on the query. - It does not utilize any other information besides query itself. + PureRAGAgent only handles grounded question generation by retrieving information from the retriever based on the query. + It does not utilize any other information besides the query itself. + It's designed for Co-STORM paper baseline comparison. """ From ded466dcaa33af43477d88a53b926bbea3622e52 Mon Sep 17 00:00:00 2001 From: Yijia Shao <67158122+shaoyijia@users.noreply.github.com> Date: Wed, 25 Sep 2024 10:19:16 -0700 Subject: [PATCH 18/19] Mark `StanfordOvalArxivRM` as for internal use only. --- knowledge_storm/rm.py | 1 + 1 file changed, 1 insertion(+) diff --git a/knowledge_storm/rm.py b/knowledge_storm/rm.py index c177b8f..9ae5955 100644 --- a/knowledge_storm/rm.py +++ b/knowledge_storm/rm.py @@ -334,6 +334,7 @@ def forward(self, query_or_queries: Union[str, List[str]], exclude_urls: List[st class StanfordOvalArxivRM(dspy.Retrieve): + """[Alpha] This retrieval class is for internal use only, not intended for the public.""" def __init__(self, endpoint, k=3): super().__init__(k=k) self.endpoint = endpoint From efac123871781392e2c2bca24670cd9aba9588c7 Mon Sep 17 00:00:00 2001 From: shaoyijia Date: Wed, 25 Sep 2024 10:22:38 -0700 Subject: [PATCH 19/19] Fix python code format. --- .../collaborative_storm/modules/co_storm_agents.py | 4 ++-- knowledge_storm/rm.py | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/knowledge_storm/collaborative_storm/modules/co_storm_agents.py b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py index e092cd6..e7f6029 100644 --- a/knowledge_storm/collaborative_storm/modules/co_storm_agents.py +++ b/knowledge_storm/collaborative_storm/modules/co_storm_agents.py @@ -110,7 +110,7 @@ def generate_utterance( class SimulatedUser(Agent): """ Simulated Users is a special type of Agent in Co-STORM that simulates real user interaction behavior based on the given intent. - + This class can be used for automatic experiments. For more information, please refer to Section 3.4 of Co-STORM paper: https://www.arxiv.org/pdf/2408.15232 """ @@ -321,7 +321,7 @@ class PureRAGAgent(Agent): """ PureRAGAgent only handles grounded question generation by retrieving information from the retriever based on the query. It does not utilize any other information besides the query itself. - + It's designed for Co-STORM paper baseline comparison. """ diff --git a/knowledge_storm/rm.py b/knowledge_storm/rm.py index 9ae5955..7f029e7 100644 --- a/knowledge_storm/rm.py +++ b/knowledge_storm/rm.py @@ -335,6 +335,7 @@ def forward(self, query_or_queries: Union[str, List[str]], exclude_urls: List[st class StanfordOvalArxivRM(dspy.Retrieve): """[Alpha] This retrieval class is for internal use only, not intended for the public.""" + def __init__(self, endpoint, k=3): super().__init__(k=k) self.endpoint = endpoint