标签: large-language-model

我正在使用Langchainversion 0.218，并且想知道是否有人能够在运行时动态过滤种子向量库？例如当由代理运行时。

我的动机是将这个动态过滤器放入对话检索 QA 链中，在其中我使用filename从对话输入中提取的内容来过滤检索器并检索其所有块（使用映射器文件k设置为属于search_kwargs中文件名的块的计数）。

我可以手动过滤种子向量库（如 Chroma） ，例如：

from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory

# init a vectorstore and seed documents
vectorstore = Chroma.from_documents(..)

# 'somehow' I get hands on the filename from user input or chat history
found_filename = "report.pdf"

# filter using a search arg, such as 'filename' provided in the metadata of all chunks
file_chunk_mapper = {"report.pdf" : ["chunk1", "chunk2", ... ] …

我之前在 LangChain 中构建了一个 pdf 搜索工具，它使用 chain.run(input_documents=, question=)语法来询问模型问题以及该 pdf 中的上下文。我想将其与langchain提供的代理集成。我正在使用语法agent.run('Question')

我无法找到集成这两种方法的链接。

上下文：我正在尝试查询 Llama-2 7B，取自 HuggingFace (meta-llama/Llama-2-7b-hf)。我给它一个问题和上下文（我猜有 200-1000 个标记），并要求它根据上下文回答问题（上下文是使用相似性搜索从向量存储中检索的）。这是我的两个问题：

1. 答案结束，直到到达为止的其余标记max_new_tokens都是换行符。或者它只是不生成任何文本，整个响应都是换行符。添加repetition_penalty1.1 或更高版本已经解决了无限换行生成问题，但没有给我完整的答案。
2. 对于确实生成的答案，它们是从给定上下文中逐字复制的。这与 相同repetition_penalty=1.1，并且重复惩罚太高会使答案变得毫无意义。

我只尝试过使用temperature=0.4和temperature=0.8，但从我所做的来看，调整温度 和repetition_penalty都会导致上下文被复制或产生无意义的答案。

请注意“上下文”：我正在使用存储在 Chroma 矢量存储中的文档，相似性搜索会在将其传递给 Llama 之前检索相关信息。

示例问题： 我的查询是总结某个主题 X。

query = "Summarize Topic X"

从向量存储中检索到的上下文有 3 个源，看起来像这样（我将查询中的源格式化为以换行符分隔的 LLM）：

context = """When talking about Topic X, Scenario Y is always referred to. This is due to the relation of
Topic X is a broad topic which covers many aspects of life.
No one knows when …

我正在尝试微调 LLM

到目前为止我的代码：

from datasets import load_dataset, DatasetDict, Dataset

from transformers import (
    AutoTokenizer,
    AutoConfig, 
    AutoModelForSequenceClassification,
    DataCollatorWithPadding,
    TrainingArguments,
        Trainer)

from peft import PeftModel, PeftConfig, get_peft_model, LoraConfig
import evaluate
import torch
import numpy as np

# load dataset
dataset = load_dataset('TokenBender/code_instructions_122k_alpaca_style')
dataset

错误：

    ---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In [12], line 2
      1 # load dataset
----> 2 dataset = load_dataset('TokenBender/code_instructions_122k_alpaca_style')
      3 dataset

File /usr/local/lib/python3.9/dist-packages/datasets/load.py:1664, in load_dataset(path, name, data_dir, data_files, split, cache_dir, features, download_config, download_mode, ignore_verifications, keep_in_memory, save_infos, …

我收集了大量文档，每个文档由大约 10 个句子组成。对于每个文档，我希望找到最大化困惑度的句子，或者等效于微调因果 LM 的损失。我决定使用 Hugging Face 和distilgpt2模型来实现此目的。当尝试以有效（矢量化）方式进行操作时，我遇到两个问题：

1. 分词器需要填充才能在批处理模式下工作，但是在计算填充的损失时，input_ids这些填充标记会造成损失。因此，给定句子的损失取决于批次中最长句子的长度，这显然是错误的。

2. 当我将一批输入 ID 传递给模型并计算损失时，我得到一个标量，因为它（意思是？）跨批次池化。相反，我需要的是每件物品的损失，而不是汇总的损失。

我制作了一个逐句运行的版本，虽然正确，但速度非常慢（我想总共处理约 2500 万个句子）。有什么建议吗？

下面的最小示例：

# Init
tokenizer = AutoTokenizer.from_pretrained("distilgpt2")
tokenizer.pad_token = tokenizer.eos_token
model = AutoModelForCausalLM.from_pretrained("clm-gpu/checkpoint-138000")
segmenter = spacy.load('en_core_web_sm')

# That's the part I need to vectorise, surely within a document (bsize ~ 10)
# and ideally across documents (bsize as big as my GPU can handle)
def select_sentence(sentences):
    """We pick the sentence that maximizes perplexity"""
    max_loss, best_index = 0, 0
    for i, sentence in …

我想在我的数据集和 GCP VM 实例上微调 Starcoder ( https://huggingface.co/bigcode/starcoder )。

文档中称，为了训练模型，他们使用了 512 个 Tesla A100 GPU，花了 24 天。

我还在 HuggingFace 的文件部分中看到了模型（.bin）文件（https://huggingface.co/bigcode/starcoder/tree/main）

模型总大小约为64GB

根据所有这些信息，

1. 如何确定哪个 GPU 最适合对我的数据集进行微调？
2. 如何估计finetune 需要的时间？（例如，基于 epoch=1 等参数的假设）
3. 选择硬件/计算时间是否考虑其他因素？

我尝试执行 langchain 代理。我想将 verbose 的输出保存到变量中，但我可以从 agent.run 访问的只是最终答案。

如何将详细输出保存到变量以便以后使用？

我的代码：

import json
from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.llms import OpenAI
from langchain.agents import Tool
from langchain.utilities import PythonREPL

llm = OpenAI(temperature=0.1)

## Define Tools
python_repl = PythonREPL()

tools = load_tools(["python_repl", "llm-math"], llm=llm)

agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

response = agent.run("What is 3^2. Use calculator to solve.")

我尝试访问代理的响应，但这只是最终答案，而不是详细输出。

打印响应仅给出 9。但我想要详细的过程，例如：

> Entering new AgentExecutor chain...
 I need to use the calculator to solve …

我创建了一个检索 QA 链，它使用 chromadb 作为向量 DB 来存储“abc.txt”文件的嵌入。如果我想动态添加更多文档嵌入（比如说另一个文件“def.txt”）怎么办？怎么做？我不想重新加载 abc.txt 嵌入，然后重新加载 def.txt 嵌入，然后将其放入色度数据库实例中。我只想重用相同的色度数据库实例（已经具有 abc.txt 的嵌入）并添加更多 def.txt 的文档嵌入，然后使用相同的内容进行检索。

loader = UnstructuredFileLoader('abc.txt', mode='elements')
documents= loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1500, chunk_overlap=150)
texts = text_splitter.split_documents(documents)
embeddings = OpenAIEmbeddings()
vectordb = Chroma.from_documents(texts,embeddings)
chain = RetrievalQA.from_chain_type(llm=OpenAI(temperature=0.0),chain_type="stuff", retriever=vectordb.as_retriever(search_type="mmr"),return_source_documents=True)

我读了很多关于开源法学硕士的文章，随着最近发布的 Llama 2，我有一个问题。

由于 Llama 2 现在位于 Azure 上，作为外行/新手，我想知道如何在 Azure 上实际部署和使用该模型。我想为 Llama 2 创建一个实时端点。我看到 VM 的最小值。每小时 6 美元，我可以部署 Llama 2 7B...其成本让我感到困惑（虚拟机是否持续运行？）。

有谁知道如何部署以及在 Azure 上运行 Llama 2（例如 7B）需要多少费用？

我尝试通过 Azure AI ML studio 在 Azure 上部署实时 Llama 2 7B 端点。对部署此类模型端点的正确方法感到困惑。

我有点不确定如何继续讨论上述主题。

基线是通过 Huggingface\xe2\x80\x99s 库创建的模型，作为 AutoModelForCausalLM 模型、PEFT 和 LoRA 方法，并随后合并权重。

我现在想进一步微调模型而不丢失其原始属性 - 在这种情况下通过指令微调/前缀调整。

我的方法如下：

model = AutoModelForCausalLM.from_pretrained(\n        model_id,\n        use_cache=False if gradient_checkpointing else True\n        device_map="auto",\n        load_in_8bit=True,\n    )\n\nmodel = create_peft_config(model)\n\noutput_dir = "/tmp"\ntraining_args = TrainingArguments(\n        output_dir=output_dir,\n        overwrite_output_dir=True,\n        per_device_train_batch_size=per_device_train_batch_size,\n        per_device_eval_batch_size=per_device_train_batch_size,\n        bf16=bf16,\n        learning_rate=lr,\n        num_train_epochs=epochs,\n        gradient_checkpointing=gradient_checkpointing,\n        gradient_accumulation_steps=2,\n        logging_dir=f"{output_dir}/logs",\n        logging_strategy="steps",\n        logging_steps=10,\n        optim="adafactor",\n        save_strategy="epoch",\n        save_total_limit=3,\n        evaluation_strategy="epoch",\n        load_best_model_at_end=False,\n        no_cuda=False,\n        auto_find_batch_size=True\n)\n\ntrainer = Trainer(\n        model=model,\n        args=training_args,\n        train_dataset=dataset_train,\n        compute_metrics=compute_metrics,\n        preprocess_logits_for_metrics=preprocess_logits_for_metrics,\n        eval_dataset=dataset_eval,\n        data_collator=default_data_collator\n)\n\ntrainer.train()\n\ntrainer.model.save_pretrained(output_dir)\n\ndel model\ndel trainer\n\npeft_config = PeftConfig.from_pretrained(output_dir)\nmodel = AutoModelForCausalLM.from_pretrained(\n        peft_config.base_model_name_or_path,\n        load_in_8bit=False,\n        return_dict=True,\n        device_map="auto",\n        torch_dtype=torch.float16,\n        low_cpu_mem_usage=True,\n)\nmodel = PeftModel.from_pretrained(\n        model,\n        output_dir,\n        torch_dtype=torch.float16,\n …