标签: huggingface

如何处理长度超过 512 个标记的序列。我不想使用截断= True。但实际上想要处理更长的序列

我目前正在使用diffusers StableDiffusionPipeline（来自拥抱的脸）通过我和朋友一起使用的不和谐机器人生成人工智能图像。我想知道是否可以在完成之前预览正在生成的图像？

例如，如果生成一张图像需要 20 秒，因为它使用扩散，所以它一开始会很模糊，然后逐渐变得越来越好。我想要的是在每次迭代（或每隔几秒）保存图像并查看它的进展情况。我怎样才能做到这一点？

class ImageGenerator:
    def __init__(self, socket_listener, pretty_logger, prisma):
        self.model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", revision="fp16", torch_dtype=torch.float16, use_auth_token=os.environ.get("HF_AUTH_TOKEN"))
        self.model = self.model.to("cuda")

    async def generate_image(self, data):
        start_time = time.time()
        with autocast("cuda"):
            image = self.model(data.description, height=self.default_height, width=self.default_width,
                               num_inference_steps=self.default_inference_steps, guidance_scale=self.default_guidance_scale)
            image.save(...)

我目前拥有的代码是这样的，但是它仅在完全完成时返回图像。我试图研究图像是如何在 StableDiffusionPipeline 内部生成的，但我找不到生成图像的任何地方。如果有人可以提供任何关于我可以从哪里开始的指示/提示，那将非常有帮助。

我想"flax-community/t5-large-wikisplit"用数据集训练模型"dxiao/requirements-ner-id"。（仅用于一些实验）

我认为我的一般程序不正确，但我不知道如何进一步。

我的代码：

加载分词器和模型：

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModel
checkpoint = "flax-community/t5-large-wikisplit"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSeq2SeqLM.from_pretrained(checkpoint).cuda()

加载我想要训练的数据集：

from datasets import load_dataset
raw_dataset = load_dataset("dxiao/requirements-ner-id")

raw_dataset 看起来像这样 ['id', 'tokens', 'tags', 'ner_tags']

我想将句子作为句子而不是标记。

def tokenToString(tokenarray):
  string = tokenarray[0]
  for x in tokenarray[1:]:
    string += " " + x
  return string

def sentence_function(example):
  return {"sentence" :  tokenToString(example["tokens"]),
          "simplefiedSentence" : tokenToString(example["tokens"]).replace("The", "XXXXXXXXXXX")}

wikisplit_req_set = raw_dataset.map(sentence_function)
wikisplit_req_set

我尝试重构数据集，使其看起来像 wikisplit 数据集：

simple1dataset = wikisplit_req_set.remove_columns(['id', 'tags', 'ner_tags', 'tokens']);
complexdataset = …

我有一个简单的代码，它采用 opt6.7B 模型并对其进行微调。当我在 Google colab（Tesla T4，16GB）中运行此代码时，它运行没有任何问题。但是当我尝试在 AWS p3-2xlarge 环境（Tesla V100 GPU，16GB）中运行相同的代码时，它给出了错误。

RuntimeError: expected scalar type Half but found Float\n

为了能够在单个 GPU 上运行微调，我使用 LORA 和 peft。在这两种情况下，安装方式完全相同（pip install）。我可以使用with torch.autocast("cuda"):，然后该错误就消失了。但是训练的损失变得非常奇怪，这意味着它不会逐渐减少，而是在很大的范围内（0-5）波动（如果我将模型更改为GPT-J，则损失始终保持为0），而损失是逐渐减少的对于 colab 来说减少。所以我不确定使用是否with torch.autocast("cuda"):是一件好事。

Transfromeers 版本是4.28.0.dev0两种情况。Colab 的 Torch 版本显示1.13.1+cu116，而 p3 的 Torch 版本显示 - 1.13.1（这是否意味着它没有 CUDA 支持？我怀疑，除此之外，这样做torch.cuda.is_available()显示 True）

我能看到的唯一大的区别是，对于 colab，bitsandbytes 有以下设置日志

===================================BUG REPORT===================================\nWelcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n================================================================================\nCUDA_SETUP: WARNING! libcudart.so not …

我需要使用它pipeline来从数据集上的模型中获得标记化和推理distilbert-base-uncased-finetuned-sst-2-english。

我的数据是一个句子列表，出于娱乐目的，我们可以假设它是：

texts = ["this is the first sentence", "of my data.", "In fact, thats not true,", "but we are going to assume it", "is"]

在使用之前pipeline，我从模型输出中获取 logits，如下所示：

with torch.no_grad():
     logits = model(**tokenized_test).logits

现在我必须使用管道，所以这就是我获取模型输出的方式：

 selected_model = "distilbert-base-uncased-finetuned-sst-2-english"
 tokenizer = AutoTokenizer.from_pretrained(selected_model)
 model = AutoModelForSequenceClassification.from_pretrained(selected_model, num_labels=2)
 classifier = pipeline('sentiment-analysis', model=model, tokenizer=tokenizer)
 print(classifier(text))

这给了我：

[{'label': 'POSITIVE', 'score': 0.9746173024177551}, {'label': 'NEGATIVE', 'score': 0.5020197629928589}, {'label': 'NEGATIVE', 'score': 0.9995120763778687}, {'label': 'NEGATIVE', 'score': 0.9802979826927185}, {'label': 'POSITIVE', 'score': 0.9274746775627136}]

我再也找不到“logits”字段了。

有没有办法得到 thelogits …

我有 10 个 Javascript (VueJS) 代码存储库（每个存储库对应 1 个主题）

我想在这 10 个代码存储库上训练一个 LLM 模型，以便我可以使用提示生成新主题。

LLM模型以10个代码存储库的上下文为参考（因为所有存储库的文件结构都是相似的）

我是法学硕士和机器学习的初学者。

如何在我自己的代码库上微调 LLM 模型？

Huggingface (meta-llama/Llama-2-7b) 上的 Llama2 7B 模型有一个 pytorch .pth 文件solidified.00.pth，大小约为 13.5GB。拥抱脸部变形金刚兼容模型 meta-llama/Llama-2-7b-hf 具有三个 pytorch 模型文件，大小合计约为 27GB，以及两个安全张量文件，合计大小约为 13.5Gb。

有人可以解释一下文件大小差异巨大的原因吗？

我在 Huggingface 模型卡或他们的博客Llama 2 is here - get it on Hugging Face 中找不到解释。

更新：当模型下载到 Huggingface 缓存时，我注意到只下载了安全张量，而不下载 Pytorch 二进制模型文件。这可以避免同时下载 safetensors 和 pytorch 模型文件。

我正在尝试使用 Hugging Face Transformers 库微调 TheBloke/Llama-2-13B-chat-GPTQ 模型。我使用 JSON 文件作为训练和验证数据集。但是，当我尝试运行脚本时遇到与 Exllama 后端相关的错误。

这是我的代码：

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from datasets import load_dataset
import torch

# Check GPU availability
print("Available GPU devices:", torch.cuda.device_count())
print("Name of the first available GPU:", torch.cuda.get_device_name(0))

# Load model and tokenizer
model_name = "TheBloke/Llama-2-13B-chat-GPTQ"

# Load tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Move the model to GPU
model.to('cuda')

# Load training and validation data
train_data = load_dataset('json', data_files='train_data.jsonl')
val_data = load_dataset('json', data_files='val_data.jsonl') …

SBERT ( https://www.sbert.net/ )sentence-transformer库 ( https://pypi.org/project/sentence-transformers/ ) 是 Python 开源 LLM 生态系统中用于生成文本块向量嵌入的最流行的库。它有一个简单的 API，但却是一个非常大的依赖项。它所有的膨胀从何而来？

下面是使用此工具构建基础 Docker 容器映像的屏幕截图，该工具接管11 mins构建，最终映像大小为7.5 GB：

作为参考，这是我的Dockerfile.base：

FROM python:3.11.2-slim-bullseye
RUN pip install --upgrade pip && pip install sentence-transformers

我预计这是因为它安装了一些已经预先打包的模型，但是当我尝试他们流行的入门片段时

FROM python:3.11.2-slim-bullseye
RUN pip install --upgrade pip && pip install sentence-transformers

它又向我的文件系统下载了数百 MB 的文件。所以我想找到一种方法将其精简为我需要的包。我相信这个库的大小很大程度上取决于底层torch依赖项（6.9 GB），而底层依赖项又由于其底层nvidia-*依赖项而占用了大量磁盘空间（顺便说一句，这些依赖项安装在哪里？）

假设我已经将一个模型下载到我的文件系统（即path/to/all-MiniLM-L6-v2来自 HuggingFace 的存储库），而我想要做的就是在 CPU 上运行上面的代码。如何才能只安装我需要的东西而不造成臃肿？

现在假设我选择了一个 GPU 来运行它。为了让这段代码在不膨胀的情况下运行，我需要的下一组边际依赖项是什么？

有时，我们必须这样做来扩展预先训练的分词器：

from transformers import AutoTokenizer

from datasets import load_dataset


ds_de = load_dataset("mc4", 'de')
ds_fr = load_dataset("mc4", 'fr')

de_tokenizer = tokenizer.train_new_from_iterator(
    ds_de['text'],vocab_size=50_000
)

fr_tokenizer = tokenizer.train_new_from_iterator(
    ds_fr['text'],vocab_size=50_000
)

new_tokens_de = set(de_tokenizer.vocab).difference(tokenizer.vocab)
new_tokens_fr = set(fr_tokenizer.vocab).difference(tokenizer.vocab)
new_tokens = set(new_tokens_de).union(new_tokens_fr)


tokenizer = AutoTokenizer.from_pretrained(
    'moussaKam/frugalscore_tiny_bert-base_bert-score'
)

tokenizer.add_tokens(list(new_tokens))

tokenizer.save_pretrained('frugalscore_tiny_bert-de-fr')

然后在加载分词器时，

tokenizer = AutoTokenizer.from_pretrained(
  'frugalscore_tiny_bert-de-fr', local_files_only=True
)

%%time从Jupyter 单元中加载需要很长时间：

CPU times: user 34min 20s
Wall time: 34min 22s

我猜这是由于添加的令牌的正则表达式编译所致，这也在https://github.com/huggingface/tokenizers/issues/914中提出

我认为没关系，因为它会加载一次，并且无需重新进行正则表达式编译即可完成工作。

但是，有没有办法以二进制形式保存标记生成器并避免下次进行整个正则表达式编译？