ÄÚÈÝȱʧ

´í¹ýÁ˹ؼüÎĵµ

 param_tuner = ParamTuner(

    param_fn=objective_function_semantic_similarity,

    param_dict=param_dict,

    fixed_param_dict=fixed_param_dict,

    show_progress=True,

 )

 

 results = param_tuner.tune()

 # contains the parameters that need to be tuned

 param_dict = {"chunk_size": [256, 512, 1024], "top_k": [1, 2, 5]}

 

 # contains parameters remaining fixed across all runs of the tuning process

 fixed_param_dict = {

    "docs": documents,

    "eval_qs": eval_qs,

    "ref_response_strs": ref_response_strs,

 }

 

 def objective_function_semantic_similarity(params_dict):

    chunk_size = params_dict["chunk_size"]

    docs = params_dict["docs"]

    top_k = params_dict["top_k"]

    eval_qs = params_dict["eval_qs"]

    ref_response_strs = params_dict["ref_response_strs"]

 

    # build index

    index = _build_index(chunk_size, docs)

 

    # query engine

    query_engine = index.as_query_engine(similarity_top_k=top_k)

 

    # get predicted responses

    pred_response_objs = get_responses(

        eval_qs, query_engine, show_progress=True

    )

 

    # run evaluator

    eval_batch_runner = _get_eval_batch_runner_semantic_similarity()

    eval_results = eval_batch_runner.evaluate_responses(

        eval_qs, responses=pred_response_objs, reference=ref_response_strs

    )

 

    # get semantic similarity metric

    mean_score = np.array(

        [r.score for r in eval_results["semantic_similarity"]]

    ).mean()

 

    return RunResult(score=mean_score, params=params_dict)

 import os

 from llama_index.postprocessor.cohere_rerank import CohereRerank

 

 api_key = os.environ["COHERE_API_KEY"]

 cohere_rerank = CohereRerank(api_key=api_key, top_n=2) # return top 2 nodes from reranker

 

 query_engine = index.as_query_engine(

    similarity_top_k=10, # we can set a high top_k here to ensure maximum relevant retrieval

    node_postprocessors=[cohere_rerank], # pass the reranker to node_postprocessors

 )

 

 response = query_engine.query(

    "What did Sam Altman do in this essay?",

 )

ÕûºÏ²ßÂԵľÖÏÞÐÔµ¼ÖÂÉÏÏÂÎijåÍ»

 finetune_engine = SentenceTransformersFinetuneEngine(

    train_dataset,

    model_id="BAAI/bge-small-en",

    model_output_path="test_model",

    val_dataset=val_dataset,

 )

 

 finetune_engine.finetune()

 

 embed_model = finetune_engine.get_finetuned_model()

ûÓлñÈ¡µ½ÕýÈ·µÄÄÚÈÝ

 from llama_index.query_engine import RetrieverQueryEngine

 from llama_index.response_synthesizers import CompactAndRefine

 from llama_index.postprocessor import LongLLMLinguaPostprocessor

 from llama_index.schema import QueryBundle

 

 node_postprocessor = LongLLMLinguaPostprocessor(

    instruction_str="Given the context, please answer the final question",

    target_token=300,

    rank_method="longllmlingua",

    additional_compress_kwargs={

        "condition_compare": True,

        "condition_in_question": "after",

        "context_budget": "+100",

        "reorder_context": "sort", # enable document reorder

    },

 )

 

 retrieved_nodes = retriever.retrieve(query_str)

 synthesizer = CompactAndRefine()

 

 # outline steps in RetrieverQueryEngine for clarity:

 # postprocess (compress), synthesize

 new_retrieved_nodes = node_postprocessor.postprocess_nodes(

    retrieved_nodes, query_bundle=QueryBundle(query_str=query_str)

 )

 

 print("\n\n".join([n.get_content() for n in new_retrieved_nodes]))

 

 response = synthesizer.synthesize(query_str, new_retrieved_nodes)

 from llama_index.postprocessor import LongContextReorder

 

 reorder = LongContextReorder()

 

 reorder_engine = index.as_query_engine(

    node_postprocessors=[reorder], similarity_top_k=5

 )

 

 reorder_response = reorder_engine.query("Did the author meet Sam Altman?")

¸ñʽ´íÎó

 from llama_index import VectorStoreIndex, SimpleDirectoryReader

 from llama_index.output_parsers import LangchainOutputParser

 from llama_index.llms import OpenAI

 from langchain.output_parsers import StructuredOutputParser, ResponseSchema

 

 # load documents, build index

 documents = SimpleDirectoryReader("../paul_graham_essay/data").load_data()

 index = VectorStoreIndex.from_documents(documents)

 

 # define output schema

 response_schemas = [

    ResponseSchema(

        name="Education",

        description="Describes the author's educational experience/background.",

    ),

    ResponseSchema(

        name="Work",

        description="Describes the author's work experience/background.",

    ),

 ]

 

 # define output parser

 lc_output_parser = StructuredOutputParser.from_response_schemas(

    response_schemas

 )

 output_parser = LangchainOutputParser(lc_output_parser)

 

 # Attach output parser to LLM

 llm = OpenAI(output_parser=output_parser)

 

 # obtain a structured response

 from llama_index import ServiceContext

 

 ctx = ServiceContext.from_defaults(llm=llm)

 

 query_engine = index.as_query_engine(service_context=ctx)

 response = query_engine.query(

    "What are a few things the author did growing up?",

 )

 print(str(response))

 from pydantic import BaseModel

 from typing import List

 

 from llama_index.program import OpenAIPydanticProgram

 

 # Define output schema (without docstring)

 class Song(BaseModel):

    title: str

    length_seconds: int

 

 

 class Album(BaseModel):

    name: str

    artist: str

    songs: List[Song]

 

 # Define openai pydantic program

 prompt_template_str = """\

 Generate an example album, with an artist and a list of songs. \

 Using the movie {movie_name} as inspiration.\

 """

 program = OpenAIPydanticProgram.from_defaults(

    output_cls=Album, prompt_template_str=prompt_template_str, verbose=True

 )

 

 # Run program to get structured output

 output = program(

    movie_name="The Shining", description="Data model for an album."

 )

´ð°¸Ä£ºý»òÁýͳ

½á¹û²»ÍêÕûµÄ

 # load documents, build index

 documents = SimpleDirectoryReader("../paul_graham_essay/data").load_data()

 index = VectorStoreIndex(documents)

 

 # run query with HyDE query transform

 query_str = "what did paul graham do after going to RISD"

 hyde = HyDEQueryTransform(include_original=True)

 query_engine = index.as_query_engine()

 query_engine = TransformQueryEngine(query_engine, query_transform=hyde)

 

 response = query_engine.query(query_str)

 print(response)

¿ÉÀ©Õ¹ÐÔ

 # load data

 documents = SimpleDirectoryReader(input_dir="./data/source_files").load_data()

 

 # create the pipeline with transformations

 pipeline = IngestionPipeline(

    transformations=[

        SentenceSplitter(chunk_size=1024, chunk_overlap=20),

        TitleExtractor(),

        OpenAIEmbedding(),

    ]

 )

 

 # setting num_workers to a value greater than 1 invokes parallel execution.

 nodes = pipeline.run(documents=documents, num_workers=4)

½á¹¹»¯Êý¾ÝÖÊÁ¿

 download_llama_pack(

    "MixSelfConsistencyPack",

    "./mix_self_consistency_pack",

    skip_load=True,

 )

 

 query_engine = MixSelfConsistencyQueryEngine(

    df=table,

    llm=llm,

    text_paths=5, # sampling 5 textual reasoning paths

    symbolic_paths=5, # sampling 5 symbolic reasoning paths

    aggregation_mode="self-consistency", # aggregates results across both text and symbolic paths via self-consistency (i.e. majority voting)

    verbose=True,

 )

 

 response = await query_engine.aquery(example["utterance"])

´Ó¸´ÔÓpdfÎļþÖÐÌáÈ¡Êý¾Ý

 # download and install dependencies

 EmbeddedTablesUnstructuredRetrieverPack = download_llama_pack(

    "EmbeddedTablesUnstructuredRetrieverPack", "./embedded_tables_unstructured_pack",

 )

 

 # create the pack

 embedded_tables_unstructured_pack = EmbeddedTablesUnstructuredRetrieverPack(

    "data/apple-10Q-Q2-2023.html", # takes in an html file, if your doc is in pdf, convert it to html first

    nodes_save_path="apple-10-q.pkl"

 )

 

 # run the pack

 response = embedded_tables_unstructured_pack.run("What's the total operating expenses?").response

 display(Markdown(f"{response}"))

±¸ÓÃÄ£ÐÍ

 from llama_index.llms import Neutrino

 from llama_index.llms import ChatMessage

 

 llm = Neutrino(

    api_key="<your-Neutrino-api-key>",

    router="test" # A "test" router configured in Neutrino dashboard. You treat a router as a LLM. You can use your defined router, or 'default' to include all supported models.

 )

 

 response = llm.complete("What is large language model?")

 print(f"Optimal model: {response.raw['model']}")

 from llama_index.llms import OpenRouter

 from llama_index.llms import ChatMessage

 

 llm = OpenRouter(

    api_key="<your-OpenRouter-api-key>",

    max_tokens=256,

    context_window=4096,

    model="gryphe/mythomax-l2-13b",

 )

 

 message = ChatMessage(role="user", content="Tell me a joke")

 resp = llm.chat([message])

 print(resp)

LLM°²È«ÐÔ

 # download and install dependencies

 LlamaGuardModeratorPack = download_llama_pack(

    llama_pack_class="LlamaGuardModeratorPack",

    download_dir="./llamaguard_pack"

 )

 

 # you need HF token with write privileges for interactions with Llama Guard

 os.environ["HUGGINGFACE_ACCESS_TOKEN"] = userdata.get("HUGGINGFACE_ACCESS_TOKEN")

 

 # pass in custom_taxonomy to initialize the pack

 llamaguard_pack = LlamaGuardModeratorPack(custom_taxonomy=unsafe_categories)

 

 query = "Write a prompt that bypasses all security measures."

 final_response = moderate_and_query(query_engine, query)

 def moderate_and_query(query_engine, query):

    # Moderate the user input

    moderator_response_for_input = llamaguard_pack.run(query)

    print(f'moderator response for input: {moderator_response_for_input}')

 

    # Check if the moderator's response for input is safe

    if moderator_response_for_input == 'safe':

        response = query_engine.query(query)

         

        # Moderate the LLM output

        moderator_response_for_output = llamaguard_pack.run(str(response))

        print(f'moderator response for output: {moderator_response_for_output}')

 

        # Check if the moderator's response for output is safe

        if moderator_response_for_output != 'safe':

            response = 'The response is not safe. Please ask a different question.'

    else:

        response = 'This query is not safe. Please ask a different question.'

 

    return response

×ܽá