class LangChainModule(dspy.Module):    def __init__(self, lcel):        super().__init__()                modules = []        for name, node in lcel.get_graph().nodes.items():            if isinstance(node.data, LangChainPredict): modules.append(node.data)
        self.modules = modules        self.chain = lcel        def forward(self, **kwargs):        output_keys = ['output', self.modules[-1].output_field_key]        output = self.chain.invoke(dict(**kwargs))                try: output = output.content        except Exception: pass
        return dspy.Prediction({k: output for k in output_keys})        def invoke(self, d, *args, **kwargs):        return self.forward(**d).output

class LangChainPredict(Predict, Runnable): # , RunnableBinding):    class Config: extra = Extra.allow  #  Allow extra attributes that are not defined in the model
    def __init__(self, prompt, llm, **config):        Runnable.__init__(self)        Parameter.__init__(self)
        self.langchain_llm = ShallowCopyOnly(llm)
        try: langchain_template = '\n'.join([msg.prompt.template for msg in prompt.messages])        except AttributeError: langchain_template = prompt.template
        self.stage = random.randbytes(8).hex()        self.signature, self.output_field_key = self._build_signature(langchain_template)        self.config = config        self.reset()
    def reset(self):        ...
    def dump_state(self):        ...
    def load_state(self, state):        ...    def __call__(self, *arg, **kwargs):        if len(arg) > 0: kwargs = {**arg[0], **kwargs}        return self.forward(**kwargs)    def _build_signature(self, template):        gpt4T = dspy.OpenAI(model='gpt-4-1106-preview', max_tokens=4000, model_type='chat')
        with dspy.context(lm=gpt4T): parts = dspy.Predict(Template2Signature)(template=template)
        inputs = {k.strip(): OldInputField() for k in parts.input_keys.split(',')}        outputs = {k.strip(): OldOutputField() for k in parts.output_key.split(',')}
        for k, v in inputs.items():            v.finalize(k, infer_prefix(k))  #  TODO: Generate from the template at dspy.Predict(Template2Signature)
        for k, v in outputs.items():            output_field_key = k            v.finalize(k, infer_prefix(k))
        return dsp.Template(parts.essential_instructions, **inputs, **outputs), output_field_key
    def forward(self, **kwargs):        #  Extract the three privileged keyword arguments.        signature = kwargs.pop("signature", self.signature)        demos = kwargs.pop("demos", self.demos)        config = dict(**self.config, **kwargs.pop("config", {}))
        prompt = signature(dsp.Example(demos=demos, **kwargs))        output = self.langchain_llm.invoke(prompt, **config)
        try: content = output.content        except AttributeError: content = output
        pred = Prediction.from_completions([{self.output_field_key: content}], signature=signature)        dspy.settings.langchain_history.append((prompt, pred))        if dsp.settings.trace is not None:            trace = dsp.settings.trace            trace.append((self, {**kwargs}, pred))
        return output    def invoke(self, d, *args, **kwargs):        return self.forward(**d)

trained_langchain_predict = LangChainPredict(prompt, llm)#此处省略优化步骤，得到优化后的 trained_langchain_predict...chain = trained_langchain_predict | StrOutputParser()

#获取signaturesignature = trained_langchain_predict.signature#获取demosdemos = trained_langchain_predict.demos#得到提示词字符串prompt_content = signature(demos)#转换为提示词类prompt = PromptTemplate.from_template(prompt_content)#创建大模型llm = OllamaLLM(model="llama3", stream=False)#连接成 LCELchain = prompt | llm

import dspy
from langchain.cache import SQLiteCachefrom langchain.globals import set_llm_cachefrom langchain_ollama import OllamaLLMfrom langchain_community.retrievers import WikipediaRetriever
set_llm_cache(SQLiteCache(database_path="cache.db"))llm =  OllamaLLM(model="llama3", stream=False)retriever = WikipediaRetriever(load_max_docs=1)prompt = PromptTemplate.from_template(    "Given {context}, answer the question `{question}` as a tweet.")def retrieve(inputs):    return [doc.page_content[:1024] for doc in retriever.get_relevant_documents(query=inputs["question"])]
def retrieve_eval(inputs):    return [{"text": doc.page_content[:1024]} for doc in retriever.get_relevant_documents(query=inputs["question"])]
question = "where was MS Dhoni born?"

from dspy.predict.langchain import LangChainModule, LangChainPredict          zeroshot_chain = LangChainModule(RunnablePassthrough.assign(context=retrieve)| LangChainPredict(prompt, llm)| StrOutputParser())

from dspy.primitives.example import Examplefrom datasets import load_dataset
dataset = load_dataset('hotpot_qa', 'fullwiki')
trainset = [    Example(dataset['train'][i]).without("id", "type", "level", "supporting_facts", "context").with_inputs("question")    for i in range(0, 50)]valset = [    Example(dataset['validation'][i]).without("id", "type", "level", "supporting_facts", "context").with_inputs("question")    for i in range(0, 10)]testset = [    Example(dataset['validation'][i]).without("id", "type", "level", "supporting_facts", "context").with_inputs("question")    for i in range(10, 20)]
"""trainset[0]Example({'question': "Which magazine was started first Arthur's Magazine or First for Women?", 'answer': "Arthur's Magazine"}) (input_keys={'question'})"""

class Assess(dspy.Signature):    """Assess the quality of a tweet along the specified dimension."""
    context = dspy.InputField(desc="ignore if N/A")    assessed_text = dspy.InputField()    assessment_question = dspy.InputField()    assessment_answer = dspy.OutputField(desc="Yes or No")

optimiser_model = dspy.OpenAI(model="gpt-4-turbo", max_tokens=1000, model_type="chat")METRIC = None

def metric(gold, pred, trace=None):    question, answer, tweet = gold.question, gold.answer, pred.output    context = retrieve_eval({'question': question})
    engaging = "Does the assessed text make for a self-contained, engaging tweet?"    faithful = "Is the assessed text grounded in the context? Say no if it includes significant facts not in the context."    correct = f"The text above is should answer `{question}`. The gold answer is `{answer}`. Does the assessed text above contain the gold answer?"
    with dspy.context(lm=optimiser_model):        faithful = dspy.Predict(Assess)(            context=context, assessed_text=tweet, assessment_question=faithful        )        correct = dspy.Predict(Assess)(                        context="N/A", assessed_text=tweet, assessment_question=correct        )        engaging = dspy.Predict(Assess)(            context="N/A", assessed_text=tweet, assessment_question=engaging        )
    correct, engaging, faithful = [        m.assessment_answer.split()[0].lower() == "yes"        for m in [correct, engaging, faithful]    ]    score = (correct + engaging + faithful) if correct and (len(tweet) <= 280) else 0
    if METRIC is not None:        if METRIC == "correct":            return correct        if METRIC == "engaging":            return engaging        if METRIC == "faithful":            return faithful
    if trace is not None:        return score >= 3    return score / 3.0

from dspy.teleprompt import BootstrapFewShotWithRandomSearch
optimizer = BootstrapFewShotWithRandomSearch(    metric=metric, max_bootstrapped_demos=3, num_candidate_programs=3)
optimized_chain = optimizer.compile(zeroshot_chain, trainset=trainset, valset=valset)

from dspy.evaluate.evaluate import Evaluate
evaluate = Evaluate(    metric=metric, devset=testset, num_threads=8, display_progress=True, display_table=5)evaluate(optimized_chain)#  Average Metric: 3.0 / 10  (30.0): 100%|██████████| 10/10 [00:22<00:00,  2.22s/it]