ziwang-com / zero-lora Goto Github PK
View Code? Open in Web Editor NEWzero零训练llm调参
Home Page: http://www.m-f.vip
zero零训练llm调参
Home Page: http://www.m-f.vip
ggerganov/llama.cpp#1101
LoRA 适配器 #1101 的潜在想法
马铃薯斯普多夫斯基在“创意”中开始了此对话
LoRA 适配器的潜在想法
#1101
@PotatoSpudowski
马铃薯斯普多夫斯基
last month · 2 评论 · 1 回复
返回页首
讨论选项
马铃薯斯普多夫斯基
last month
嗨,
感谢您的存储库和初始 lora 适配器支持.
我们在fastLLaMa存储库中探索了一些实验。
我们做了什么:
在 convert-lora-to-ggml.py 脚本中缓存了 lora 矩阵乘法结果.
我们不是在运行时执行计算,而是缓存并保存了这些结果,
以便在加载适配器时速度更快。
我们也有参数允许用户使用与此存储库中看到的相同实现。
我们还有一个参数,允许用户在 fp32 或 fp16 模式下缓存 lora 适配器.
fp16模式似乎不错,可能会使下游应用受益。
添加了对分离 lora 适配器的支持.
我们在此处添加了对在 llama 中分离适配器的支持.cpp此处。
这些功能是否看起来与此存储库相关?
如果是,我们很乐意帮助实施这些!
快乐的黑客:)
https://github.com/seycho/python_mini_script-LoRA_WSI
LoRA TCGA-LUAD 发生器
制作参考肺腺癌WSI贴片图像(TCGA-LUAD)的虚假病理图像。
https://portal.gdc.cancer.gov/projects/TCGA-LUAD
基本模型是跑道ml/稳定扩散-v1-5
https://huggingface.co/runwayml/stable-diffusion-v1-5
数据准备
图块大小为 500 微米,间隔大小相同,调整大小为 128 x 128 像素。他们有两种类型的标题,即正面贴片图像中的“H&E染色病理学图像与肺腺癌”和负片图像中的“H&E染色病理学图像与肺正常”。./total 目录中的示例数据。
训练洛拉
https://github.com/deep-diver/vicuna-lora
此存储库包含使用低秩自适应 (LoRA) 重现斯坦福羊驼结果的代码。我们提供了一个质量与可以在 Raspberry Pi 上运行的 Instruct 模型(用于研究)类似的模型,并且代码很容易扩展到 、 和 模型。text-davinci-00313b30b65b
除了在单个RTX 4090上在数小时内运行的训练代码之外,我们还发布了一个脚本,用于下载和推理基础模型和LoRA,以及生成的LoRA权重本身。为了廉价而高效地进行微调,我们使用Hugging Face的PEFT以及Tim Dettmers的bitsandbytes。
在没有超参数调整的情况下, LoRA 模型产生的输出可与斯坦福羊驼模型相媲美.(请参阅下面包含的输出。进一步调整可能能够实现更好的性能;我邀请感兴趣的用户尝试一下并报告他们的结果。
用RLHF可选LoRA对LLaMA和MOSS进行训练|使用 RLHF 训练 LLaMA 或 MOSS
https://github.com/Miraclemarvel55/LLaMA-MOSS-RLHF-LoRA
LLaMA-MOSS-RLHF-LoRA
本代码的RLHF代码不需要Megatron或者deepspeed框架, 只需要传统的炼丹torch和显卡就好了,RLHF的Critic用的目标GPT的缩小版本,而Reward咱们直接使用一个和目标输出比较的相似度模型即可。这样只需要学习核心的PPO算法即可,其他的都是已经了解的模型和结构。非常有利于NLPer进军RLHF,似乎看起来只需要RLHF也能finetune模型。
代码里面可选LLaMA或者MOSS,优化方式LoRA是可选的喔。
功能:
RLHF数据格式的定义和使用√
只用RLHF就对模型进行了微调√
让模型认主√
修改自我认知钢印
主人的姓名
Robot的昵称
batch 化生成多个不同的prompt,再同时RLHF×
ggerganov/llama.cpp#323
重新生成模型 #323
普里诺瓦开始了这个对话 一般
重新生成模型
#323
@PriNova
普里诺瓦
on Mar 20 · 3 评论 · 4回复
返回页首
讨论选项
普里诺瓦
on Mar 20
现在使用合并的 PR https://github.com/ggerganov/llama.cpp/pull/252,我需要重新转换模型。
这是否意味着,我需要重新转换合并.0.pth 的基本模型,或者我也可以重新转换量化模型吗?
我目前正在使用 7B 羊驼 Lora 4bit 和 13B 羊驼 lora 型号 4bit,并希望继续使用它.
我没有资源来:
再次微调模型以与美洲驼一起使用.cpp
我也没有资源来量化大模型。
如果我能重新转换我的量化羊驼劳拉模型将是惊人的.
如果没有,这将是一个重大变化(因为数字nomade通常减慢wifi和有限的资源)
当有人可以澄清时,这将是惊人的。
谢谢
答复:3 评论 · 4回复
注释选项
j-f1
on Mar 20
合作者
您需要从 开始,然后转换为 GGML,然后再次量化生成的文件。.pth
1 回复
@PriNova
注释选项
普里诺瓦
on Mar 20
作者
好的, 这对我来说是一个重大变化, 因为我无法为 LoRa 训练.
与其将分词器分数存储到模型中,不如将分数存储在单独的文件中更有意义吗?
然后,该模型可以按原样使用,并且与令牌词汇分数没有直接依赖关系。
注释选项
鹦鹉螺
on Mar 20
@eiz制作了一个脚本,通过在标记器中与其权重合并来修补 ggml 模型:#324(评论)
3回复
@PriNova
注释选项
普里诺瓦
on Mar 20
作者
谢谢,我找到了它,它工作得很好
@j-f1
注释选项
j-f1
on Mar 21
合作者
请注意,我们将很快更新模型格式以允许即时加载,这将需要再次从文件重新生成(尽管不需要重新训练任何内容)。.pth
@PriNova
注释选项
普里诺瓦
on Mar 21
作者
请注意,我们将很快更新模型格式以允许即时加载,这将需要再次从文件重新生成(尽管不需要重新训练任何内容)。.pth
我是否正确理解它,它也适用于预训练的模型?
J-f1和Wingie用竖起大拇指的表情符号做出反应
注释选项
普里诺瓦
on Mar 21
作者
这是我在#324中发布的两个文件进行比较。
0回复
https://github.com/OptimalScale/LMFlow
用于微调和推理大型基础模型的可扩展工具包。适合所有人的大型模型。
一个可扩展、方便且高效的工具箱,用于微调大型机器学习模型,旨在用户友好、快速可靠,并且可供整个社区访问。
适合所有人的大型模型。查看我们的愿景。
https://github.com/PhoebusSi/alpaca-CoT
Alpaca-CoT:具有指令数据收集和统一大语言模型接口的指令微调平台
这是该项目的存储库,旨在构建一个指令微调(IFT)平台,该平台具有广泛的指令集合(特别是CoT数据集)以及各种大型语言模型和参数高效方法的统一接口。我们正在不断扩展我们的指令调整数据收集,并集成更多的LLM和更参数高效的方法。此外,我们还创建了一个新的分支tabular_llm来构建用于解决表智能任务的表格 LLM。Alpaca-CoT
热忱欢迎您向我们提供任何未收集的指令调整数据集(或其来源)。我们将统一格式化它们,使用这些数据集训练 Alpaca 模型(以及早期的其他 LLM),开源模型检查点,并进行广泛的实证研究。我们希望我们的项目能够为大型语言模型的开源过程做出一点贡献,并降低NLP研究人员入门的门槛。
您也可以选择加入我们的群聊(WeChat),与更多志趣相投的人交流。目前,群成员数量太大,无法直接通过群二维码加入群。您需要先与我联系才能进入小组。
https://github.com/KohakuBlueleaf/LyCORIS
LyCORIS - Lora beYond 常规方法,其他秩自适应实现稳定扩散。
一个用于实现不同算法以对稳定扩散或更多进行参数高效微调的项目。
此项目从 LoCon 启动(请参阅存档分支)。
https://github.com/zcc31415926/lora_wrapper
定制的低秩适配包装器,可实现高效的微调
有关LoRA高效微调技术的详细信息,请参阅LoRA的官方实现
https://github.com/deep-diver/LLM-As-Chatbot
用大量开源指令遵循微调的LLM模型作为聊天机器人服务。当前重点模型是 、、 和 。由于不同的模型行为不同,并且不同的模型需要以不同的方式形成提示
不同的模型可能有不同的策略来管理上下文,因此,如果您想知道应用于每个模型的确切策略,请查看聊天目录。但是,以下是我最初提出的基本想法。我发现长提示最终会减慢生成过程,所以我认为提示应该尽可能简短,同时尽可能简洁。在以前的版本中,我已经积累了过去的所有对话,但这并不顺利。
在对话的每一个转折中,过去的对话都会被保留。将 视为超参数。作为实验,目前仅保留所有模型的过去 2-3 次对话。NN
在对话的每个回合中,它都会总结或提取信息。总结的信息将在每次对话中给出。
当前支持的型号
https://github.com/KohakuBlueleaf/guanaco-lora
瓜纳科-洛拉: LoRA 用于培训多语言教学 - 基于 LLaMA 的 LM
🤗 在此处试用预训练模型
这个存储库是从 alpaca-lora 分叉的, 并引入了一种方法来训练更多模块,如嵌入/头与 lora.
使用训练有素的嵌入和头部,您可以在多语言性能上获得更好的结果。
https://github.com/kuleshov-group/llmtune
LLMTune:消费者GPU上LLM的4位微调
LLMTune允许在一个消费级GPU上微调LLM(例如,最大的65B LLAMA模型)。
其功能包括:
对多个LLM的模块化支持(目前为LLAMA,OPT)
支持各种消费级 NVidia GPU;65B 美洲驼在一台 A6000 上进行微调
小巧易用的代码库
能够在一个 GPU 上微调较大的 LLM(例如,65B 参数)的一个好处是能够轻松地将数据并行性用于大型模型。
在引擎盖下, LLMTune 在使用 GPTQ 算法压缩的 LLM 上实现 LoRA 算法, 这需要为量化的 LLM 实现向后传递.有关各种 GPU 支持哪些 LLM 的详细信息,请参阅硬件要求。
目标
LLMTune是康奈尔理工大学和康奈尔大学的一个研究项目。其目标是:
为大型语言模型的创意实验提供易于使用的平台
促进LLM对齐,偏差缓解,有效推理和其他主题的研究
https://github.com/megvii-research/Sparsebit/tree/main/large_language_models/alpaca-qlora
有了alpaca-qlora支持,您可以使用单个2080ti来指导微调llama-7b / 13b。
alpaca-lora是一个伟大的项目,它允许在几个小时内在单个RTX4090上运行Instuct调谐。指令调整后,可以获得与文本达芬奇-003质量相似的指令模型。
但是,基础模型越大,获得的指令结果就越好。我们希望每个人都能享受到这个好处。因此, 我们提供 alpaca-qlora, 它将骨干量子化为 4 位,同时将 lora 参数保留为 fp16.
在alpaca-qlora中,将释放大约一半模型大小的GPU内存(例如,llama-7B将释放3.5GB)。当计算资源不足时,可以缓解需求;即使在有足够的计算资源的情况下,Alpaca-Qlora 也可以帮助扩展CUTOFF_LEN,这可能会改善您的 Instuct 调整结果或增加宏批次大小以减少您的训练时间。
PhoebusSi/Alpaca-CoT#53
是否要定期发布新训练的模型检查点?
【zw-ps】
强烈建议发布,目前hf极度缺乏这种不同时间周期的连续训练模型,而这种模型和数据,是很多llm优化项目说需要的。
在《zero-lora零训练llm调参算法》当中,其中的一个关注要点就是:
https://github.com/ziwang-com/zero-lora
基于时间(不同训练周期检查点)、空间(不同token权重对比)、深度(不同模型的tok权重映射)等多种维度的lora权重优化体系。
https://github.com/poteminr/medner
俄罗斯扁平数据集的美洲驼模型微调
https://github.com/tic-top/MoreLoRA
将两个lora矩阵相乘,相加
https://github.com/horseee/LLM-Pruner
为什么选择LLM-Pruner
与任务无关的压缩:压缩的LLM应保留其作为多任务求解器的原始能力。
更少的训练语料库:在这项工作中,我们只使用50k公开可用的样本(羊驼)来训练LLM。
高效压缩:修剪 3 分钟,训练后 3 小时。(你可以让它更长)
自动结构修剪:以最少的人力修剪新的LLM(正在进行中)。
LLM-Pruner:论大型语言模型的结构修剪[论文]
马欣银, 方公凡, 王新潮
新加坡国立大学
arxiv版本将很快发布。
训练您自己的 LoRA
https://github.com/oobabooga/text-generation-webui/blob/main/docs/Training-LoRAs.md
训练您自己的 LoRA
WebUI 旨在使训练您自己的 LoRA 尽可能简单.它归结为几个简单的步骤:
第 1 步:制定计划。
您想使用哪种基本模型?您制作的 LoRA 必须与单个架构匹配 (例如 LLaMA-13B) 并且不能转移到其他人 (例如 LLaMA-7B, 稳定LM, 等等都是不同的).同一模型的衍生物(例如LLaMA-13B的羊驼微调)可能是可转移的,但即便如此,最好完全按照您计划使用的内容进行训练。
您想要什么模型格式?在撰写本文时,8 位模型最稳定,支持 4 位模型,但处于实验阶段。在不久的将来,4位可能是大多数用户的最佳选择。
你在训练它什么?你想让它学习真实的信息,一个简单的格式,...?
步骤 2:收集数据集。
如果使用类似于 Alpaca 格式的数据集,则 WebUI 中的输入本机支持该数据集,并带有预制格式化程序选项。Formatted Dataset
如果使用的数据集与 Alpaca 的格式不匹配,但使用相同的基本 JSON 结构,则可以通过复制到新文件并编辑其内容来创建自己的格式化文件。training/formats/alpaca-format.json
如果您可以将数据集放入一个简单的文本文件中,那也可以!您可以使用输入选项进行训练。Raw text file
这意味着您可以复制/粘贴聊天记录/文档页面/任何您想要的内容,将其推入纯文本文件中,然后对其进行训练。
如果您使用的结构化数据集不是这种格式,则可能需要找到一种外部方法来转换它 - 或者打开问题以请求本机支持。
第 3 步:进行培训。
3.1:加载 WebUI 和模型。
确保您没有加载任何 LoRA(除非您想训练多 LoRA 使用)。
3.2:打开顶部的选项卡,子选项卡。TrainingTrain LoRA
3.3: 填写 LoRA 的名称, 在数据集选项中选择您的数据集.
3.4:根据您的喜好选择其他参数。请参阅下面的参数。
3.5:单击 ,然后等待。Start LoRA Training
大型数据集可能需要几个小时,如果进行小规模运行,则只需几分钟。
您可能希望在损失值发生时监控损失值。
第 4 步:评估您的结果。
在“模型”选项卡下加载 LoRA。
可以在选项卡上试用它,也可以使用选项卡的子选项卡。Text generationPerplexity evaluationTraining
如果您使用了该选项, 您可以从 LoRA 模型文件夹内的子文件夹中获取模型的先前副本并尝试它们.Save every n steps
第 5 步:如果您不满意,请重新运行。
确保在训练之前卸载 LoRA.
您可以简单地恢复先前的运行 - 用于选择 LoRA, 并编辑参数.请注意,您无法更改已创建的 LoRA.Copy parameters fromRank
如果要从沿途保存的检查点恢复, 只需将检查点文件夹的内容复制到 LoRA 的文件夹中.
(注意:是保存实际 LoRA 内容的重要文件)。adapter_model.bin
这将开始学习速率并返回到起点。如果您想像中途一样恢复,您可以将学习率调整为日志中上次报告的 LR 并减少您的 epoch。
或者,如果您愿意,可以完全重新开始。
如果您的模型产生损坏的输出,您可能需要重新开始并使用较低的学习率。
如果您的模型没有学习详细信息,但您希望它学习,则可能需要运行更多纪元,或者可能需要更高的排名。
如果你的模型强制执行你不想要的格式,你可能需要调整数据集,或者重新开始,而不是训练那么远。
格式化文件
如果使用 JSON 格式的数据集,则假定它们采用以下近似格式:
[
{
"somekey": "somevalue",
"key2": "value2"
},
{
// etc
}
]
Where the keys (eg , above) are standardized, and relatively consistent across the dataset, and the values (eg , ) contain the content actually intended to be trained.somekeykey2somevaluevalue2
For Alpaca, the keys are , , and , wherein is sometimes blank.instructioninputoutputinput
A simple format file for Alpaca to be used as a chat bot is:
{
"instruction,output": "User: %instruction%\nAssistant: %output%",
"instruction,input,output": "User: %instruction%: %input%\nAssistant: %output%"
}
请注意,键(例如)是以逗号分隔的数据集键列表,值是将这些键与 .instruction,output%%
因此,例如,如果数据集具有 ,则格式化文件将自动填充为 ."instruction": "answer my question"User: %instruction%\nUser: answer my question\n
如果您有不同的键输入集,则可以创建自己的格式化文件来匹配它。此格式化文件设计为尽可能简单,以便轻松编辑以满足您的需求。
原始文本文件设置
使用原始文本文件作为数据集时,文本会根据你获得一些基本选项来配置它们,自动拆分为块。Cutoff Length
Overlap Length是块重叠的程度。重叠的块有助于防止模型学习奇怪的句子中间剪切,而是学习从早期文本流出的连续句子。
Prefer Newline Cut Length设置最大字符距离,以将块切口移向换行符。这样做有助于防止行在句子中间开始或结束,从而防止模型学习随机截断句子。
Hard Cut String设置一个字符串,指示必须存在没有重叠的硬剪切。这默认为 ,表示 3 个换行符。任何经过训练的块都不会包含此字符串。这允许您在同一文本文件中插入不相关的文本部分,但仍确保不会教模型随机更改主题。\n\n\n
参数
每个参数的基本用途和功能都记录在 WebUI 的页面上,因此请在 UI 中通读它们以了解您的选项。
也就是说,以下是您应该考虑的最重要参数选择的指南:
显温
首先,您必须考虑您的VRAM可用性。
通常, 在默认设置下, 使用默认参数进行训练的 VRAM 用法非常接近生成文本时 (具有 1000+ 上下文标记) (即, 如果您可以生成文本, 您可以训练 LoRA).
注意:目前在 4 位猴子补丁中默认更糟。减少到以将其恢复到预期。Micro Batch Size1
如果您有多余的VRAM,设置更高的批量大小将使用更多的VRAM,并为您提供更高质量的培训作为交换。
如果您有大型数据,设置较高的截止长度可能是有益的,但会花费大量的 VRAM。如果可以留出一些,请将批量大小设置为 ,看看可以将截止长度提高多高。1
如果您的 VRAM 较低,减少批量大小或截止长度当然会改善这一点。
不要害怕尝试一下,看看会发生什么。如果太多,它只会出错,您可以降低设置并重试。
排
其次,你要考虑你想要的学习量。
例如,您可能希望只学习一种对话格式(如 Alpaca 的情况),在这种情况下,设置低值(32 或更低)效果很好。Rank
或者,你可能正在训练项目文档,希望机器人理解并能够理解有关问题,在这种情况下,排名越高越好。
一般来说,更高的等级=更精确的学习=更多的学习内容=更多的VRAM使用。
学习率和时期
第三,你希望它被学习得多么仔细。
换句话说,你对模型失去不相关的理解有多好。
您可以通过 3 个关键设置来控制这一点:学习率、其调度程序和您的总纪元。
学习率控制它看到的每个令牌对模型进行了多少更改。
它通常采用科学记数法,因此例如表示哪个是 .后面的数字控制数字中有多少个 s。3e-43 * 10^-40.0003e-0
值越高,训练运行得更快,但也更有可能损坏模型中的先前数据。
您基本上有两个变量需要平衡:LR 和纪元。
如果将 LR 设置得更高,则可以将纪元设置得同样低以匹配。高 LR + 低时期 = 非常快速、低质量的培训。
如果将 LR 设置为低,请将纪元设置为高。低 LR + 高时期 = 缓慢但高质量的培训。
调度程序在您训练时控制随时间的变化 - 它从高位开始,然后变低。这有助于在获取数据和同时保持良好的质量之间取得平衡。
您可以在HuggingFace文档中查看不同调度程序选项的图表 这里
损失
运行训练时,WebUI 的控制台窗口将记录报告,其中包括名为 的数值。它将从一个高数字开始,并逐渐变得越来越低。Loss
AI训练世界中的“损失”理论上意味着“模型离完美有多近”,意思是“绝对完美”。这是通过测量模型精确输出的训练它输出的文本与它实际输出的文本之间的差异来计算的。0
在实践中,一个好的LLM应该在其人工头中运行一个非常复杂的可变想法范围,因此丢失将表明模型已经损坏并且忘记了如何思考除您训练它之外的任何事情。0
因此,实际上,Loss是一个平衡游戏:您希望它足够低,以便它理解您的数据,但又足够高,以至于它不会忘记其他一切。一般来说,如果它低于,它将开始忘记它以前的记忆,你应该停止训练。在某些情况下,您可能更愿意将其降低到(如果您希望它非常非常可预测)。不同的目标有不同的需求,所以不要害怕尝试,看看什么最适合你。1.00.5
注意:如果您看到损失开始于或突然跳到确切,则可能是您的训练过程中出了问题(例如模型损坏)。0
注意:4 位猴子补丁
4 位 LoRA 猴子补丁适用于训练, 但有副作用:
VRAM使用率目前较高。您可以减少 to 进行补偿。Micro Batch Size1
模特做时髦的事情。LoRA 自己应用, 或拒绝应用, 或自发错误, 或等.在训练/使用之间重新加载基本模型或重新启动 WebUI 可能会有所帮助,以最大程度地减少出现任何问题的可能性。
同时加载或使用多个 LoRA 目前不起作用.
一般来说,识别猴子补丁并将其视为肮脏的临时黑客 - 它可以工作,但不是很稳定。当所有内容都合并到上游以获得全面的官方支持时,它会及时变得更好。
旧版笔记
LoRA 培训由 mcmonkey4eva 在 PR #570 中提供。
使用原始羊驼-洛拉代码
保留在这里以供参考。“训练”选项卡具有比此方法更多的功能。
conda activate textgen
git clone https://github.com/tloen/alpaca-lora
编辑这两行以使用现有的模型文件夹,而不是从十足点下载所有内容:alpaca-lora/finetune.py
model = LlamaForCausalLM.from_pretrained(
"models/llama-7b",
load_in_8bit=True,
device_map="auto",
)
tokenizer = LlamaTokenizer.from_pretrained(
"models/llama-7b", add_eos_token=True
)
使用以下命令运行脚本:
python finetune.py
它只是工作。它以 22.32s/it 的速度运行, 总共有 1170 次迭代, 所以大约 7 训练 LoRA 的一个半小时.使用RTX 3090,18153MiB VRAM,消耗最大功率(350W,房间加热器模式)。
huggingface/peft#312
它很简单,使用低秩近似,低秩矩阵分解。
给定模型及其微调,以及目标排名,提取模型权重中每个差异的“最佳”低秩近似值,并导出为 LoRA。
参数可以是常数,也可以是每个矩阵的唯一,例如为
总结一下,给定找到
每个都有行使得规范
最小化。
这绝对很有趣。想知道梯度方法、进化算法或普通的线性代数范数(光谱等)和因式分解是否是解决这个问题的理想选择。
题外话:我想知道从权重到 lora 权重是否会有明确的梯度路径?我在微积分方面不够流利,但假设因式分解可能无法微分。在这种情况下,这可能是另一种操作, 其中不是向后传播梯度,而是可以使用另一个信号从非 lora 权重达到 lora 权重.
https://github.com/kojima-takeshi188/zero_shot_cot
LLM模型Zero-Shot Reasoners
这是(在 NeurIPS 2022 上接受)的官方实现。Large Language Models are Zero-Shot Reasoners
该论文可在NeurIPS 2022和arXiv上获得。
今天github排行榜,居然有两个TOT思维树项目入榜。
@
https://github.com/kyegomez/tree-of-thoughts
@
https://github.com/ysymyth/tree-of-thought-llm
TOT思维树:使用大型语言模型进行深思熟虑的问题解决,将模型推理提升至少 70%
TOT思维树,全称:tree-of-thought。
TOT思维树,是语义链 思维链的自然扩展。
这个其实也是一种广义版本的zero-lora零训练llm优化技术,通过优化模型的逻辑流程,提高llm的实际推理能力。
类似我们的logNET逻辑神经网络,如果能够集成专业知识库,更加理想。
目前,您可以加载多个适配器并合并到基本模型中,如下所示,此处所有适配器的权重相等:
model = AutoModel... # base model # set load_in_8bit
to False
for peft_model_id in peft_model_ids:
model = PeftModel.from_pretrained(model, peft_model_id)
model = model.merge_and_unload()
我不确定这是否是一个常见的要求,但我可以分享我的例子:我目前正在开发一种人工智能服务,主要训练专业人士之间的日常对话,以及与专业领域相关的理论知识。最终目标是提供更接近人与人之间日常对话风格的答案,而不是产生僵化的理论知识。因此, 我希望能够同时加载多个 LORA,并在提问时根据一定的权重融合它们, 例如在这种情况下, 用于日常对话和专业知识的 LORA.这类似于在文本到图像生成中组合不同样式的图像。
https://github.com/johnsmith0031/alpaca_lora_4bit
对 peft 和 gptq 中的代码进行了一些调整,用于美洲驼, 并使 lora 微调成为可能 4 位基本模型.可以对 2、3 和 8 位进行相同的调整。
text_generation_webui推理性能更佳,速度提高约 40%
简单体验结果:
组大小 = 128 的 7b 模型 没有操作顺序
从 13 个令牌/秒提高到 20 个令牌/秒
令人难以置信的好表现
johnsmith0031/alpaca_lora_4bit#7
在单个RTX 4090上训练LLaMA-13B-4bit(使用PyTorch 2测试版,以支持计算修订版8.9所需的CUDA 11.8)只需一分钟即可完成3个epoch:finetune.py
谢谢!RTX 4090 非常快 XD
我认为接下来要做的是减少 vram 用于训练的使用, 然后我们可以在单个 30b 模型上训练 lora 4090
我做了一个比猴子补丁更好的补丁,它可以在没有 lora 或 with 的情况下工作。
https://github.com/Ph0rk0z/text-generation-webui-testing
突然间,30b 模型可用于在我的帕斯卡上进行推理。你认为有可能让它适用于GPT-J和NEO-X吗?
GPTQ 分支中已经有它们的代码。
在 4090 上训练 30b 模型需要多长时间?
我不确定这是针对时代还是整个工作,但我说 40 小时
ggerganov/llama.cpp#630
将大型LLM与小型LLM相结合,以加快推理速度 #630
打开
格尔加诺夫打开了这个问题 on Mar 31 ·27 评论
评论
@ggerganov
所有者
格尔加诺夫评论 on Mar 31
所以我在考虑以下想法。
这可能完全是假的,但我肯定会在有时间的时候调查它,所以也许其他人也会感兴趣。
大型LLM需要花费大量时间来执行令牌推理。假设每个令牌需要 500 毫秒。
小型LLM(或其他方法)可以非常快速地推断令牌。假设< 5 毫秒。
让我们假设小LLM在80-90%的情况下是正确的。
思路如下:
在为下一个令牌运行大型 LLM 推理之前,我使用小型 LLM 进行推断
我现在想以某种方式部分评估大型LLM(假设层的前10%)并获得下一个令牌的近似估计值
如果这个估计表明该代币的概率很高(即高于某个阈值) - 我们停止并直接说这是新代币。在这一点上,我们将消耗(小型LLM为5ms + 大型LLM为~50ms)
否则,我们继续评估大型LLM的其余层
在所描述的过程中,对于 10-20% 的令牌,我只会到达步骤 4,但对于其余的 - 我将采用步骤 3 中的快捷方式。
因此,我将对大型LLM进行有效的推断。
显然,最大的问题是第 2 步是否可行。
我想答案是否定的,但谁知道呢。
https://github.com/serp-ai/LLaMA-8bit-LoRA
8位LoRA
用于在 HuggingFace 上训练 LLaMA 模型的 LoRA 的存储库 8 位量化.仅研究。
https://github.com/MBZUAI-nlp/Bactrian-X
MBZUAI Bactrian-X一种多语言可复制的指令遵循模型
Bactrian-X 数据集包含 52 种语言的 3.4M 对指令和响应。指令是从alpaca-52k和dolly-15k获得的,并翻译成52种语言(52种语言x 67k实例= 3.4M实例)。52种语言的响应是从模型中生成的。gpt-3.5-turbo
Bactrian-X模型是在Bactrian-X数据集上微调(使用低秩自适应/ LoRA)的一系列LLM模型。
【zw-ps】
zero-lora的一个基础要点,就是数据、模型的归一化处理
ggerganov/llama.cpp#858
如何使用在运行时指定的其他新本地数据来增强基础模型? #858
古典爵士乐开始了这个对话 一般
如何使用在运行时指定的其他新本地数据来增强基础模型?
#858
@classicjazz
古典爵士乐
on Apr 9 · 3 评论 · 3回复
返回页首
讨论选项
古典爵士乐
on Apr 9
基础模型(例如 LLaMA)仅限于模型发布者在创建模型之前抓取的那些来源。我想通过在运行时手动指定一个包含“权威”数据文件(例如.HTML TXT、PDF、XLS、XML)的目录来增加给定模型的“知识”,然后在呈现指令时将其合并到 AI 的响应中。通过权威,我的意思是,如果指定目录中的数据与模型中预先存在的数据冲突,则赋予它更大的权重/重要性。
例如,发布新产品或发生新闻事件。我手动保存了50个相关的网页,文本文件等。关于该产品或新闻事件到给定的本地目录。然后我想运行 llama.cpp,它输出新闻文章、摘要、关键点、论文、博客文章、诗歌、歌曲等。基于新数据。
我通常运行一个 Bash 脚本来加载骆驼.cpp带有所需的参数。我不确定 llama.cpp 本身是否在目录中加载和处理数据,或者是否有先前的步骤以某种方式修改/向模型添加层,然后由 llama.cpp 调用。
注意:对于这个用例,我设想它是临时的,仅限于本地目录,以实现安全/隐私/有限的长期重用。它应该能够在合理的时间内在消费级硬件(例如Macbook或Mac Studio)上处理新数据。
谢谢
答复:3 评论 · 3回复
注释选项
j-f1
on Apr 9
合作者
这听起来像是一个巨大的挑战——尤其是关于让它将这些信息视为权威的部分。通过使这样的东西在本地运行良好,您将显着推进LLM。
0 回复
注释选项
贝塔狗狗
on Apr 9
目前,执行此操作的最佳方法可能是为您希望模型理解的新数据训练 LoRA.这并不快,但在消费类硬件(24gb vram或更少)上应该是可能的。不过,这可能不是您要找的。
1 回复
@classicjazz
注释选项
古典爵士乐
on Apr 9
作者
这与我的想法相同,作为一个层应用,可能是在调用 llama.cpp 之前作为 Bash 脚本中的一个单独步骤。
我可能不是一个典型的用户,但我有一个具有64GB统一内存的Apple Studio Max作为我的主要工作站。
注释选项
锝1
on Apr 9
https://github.com/lastmile-ai/llama-retrieval-plugin
FNsi reacted with eyes emoji
oobabooga/text-generation-webui#959
我尝试从 https://github.com/ymcui/Chinese-LLaMA-Alpaca
加载 lora,https://huggingface.co/ziqingyang/chinese-llama-lora-7b
它报告了以下错误:
RuntimeError('Error(s) in load state_dict for {}:\n\t{}'.format(
RuntimeError: Errors in loading state_dict for PeftModelForCausalLM: size 不匹配 for base_model.model.model.embed_tokens.weight:
使用形状火炬复制参数。尺寸([49954, 4096]) 从检查点开始,当前模型中的形状是割炬。大小([32000, 4096])。
base_model.model.lm_head.weight的大小不匹配:使用形状火炬复制参数。尺寸([49954, 4096]) 从检查点开始,当前模型中的形状是割炬。大小([32000, 4096])。
从错误消息来看,模型检查点的大小是正确的 (49954),但初始化的模型嵌入是 32000,因此它不会加载,问题应该只在 config.json 中。
我尝试在config.json中将vocab_size从32000修改为49954,但仍然报告上述错误。
就像https://github.com/ymcui/Chinese-LLaMA-Alpaca/issues/87一样,但是他可以在将vocab_size修改为49954后成功加载Lora,他没有使用文本生成webui。
这是否存在现有问题?
此解决方案解决了这个问题,需要替换 tokenizer.model 并调整 tokenizer 的大小。
ymcui/Chinese-LLaMA-Alpaca#136
将下载的 lora 权重放入 loras 文件夹
ls loras/chinaese-alpaca-lora-7b
adapter_config.json adapter_model.bin special_tokens_map.json tokenizer_config.json tokenizer.model
将拥抱脸格式的骆驼-7B模型文件放入模型文件夹中
ls models/llama-7b-hf
pytorch_model-00001-of-00002.bin pytorch_model-00002-of-00002.bin config.json pytorch_model.bin.index.json generation_config.json
将 lora 权重的分词器复制到模型/美洲驼-7b-hf
cp loras/**羊驼-lora-7b/tokenizer.model models/llama-7b-hf/ cp loras/chinaese-alpaca-lora-7b/special_tokens_map.json models/llama-7b-hf/ cp loras/chinaese-alpaca-lora-7b/tokenizer_config.json models/llama-7b-hf/
修改 /modules/LoRA.py 文件,大约第 28 行
shared.model.resize_token_embeddings(49954) assert shared.model.get_input_embeddings().weight.size(0) == 49954 shared.model = PeftModel.from_pretrained(
shared.model, Path(f“{shared.args.lora_dir}/{lora_name}”), **params)
接下来你可以开心地跑了,参考 https://github.com/oobabooga/text-generation-webui/wiki/Using-LoRAs
蟒蛇 server.py --模型美洲驼-7b-hf --劳拉**羊驼-劳拉-7b
abetlen/llama-cpp-python#237
你的意思是像这样可视化代币概率吗?
是的。可能吗?理想情况下 - 可以将BertViz https://github.com/jessevig/bertviz 用于LLaMA和衍生模型。
该示例应该适用于我刚刚推送的 v0.1.51。
步骤:
安装 llama-cpp-python >= v0.1.51
启动 Web 服务器--model_alias text-davinci-003
通过 docker 启动 openplayground,并将那里的 IP 地址替换为 llama-cpp-python Web 服务器的本地 IP 地址docker run --rm -e OPENAI_API_KEY=sk-xxx -e OPENAI_API_BASE=http://100.64.159.73:8000/v1 -p 5432:5432 natorg/openplayground
转到您的 Web 浏览器并使用我们刚刚创建的“openai”模型。http://localhost:5432
ggerganov/llama.cpp#904
以交互方式将加载的模型导出到二进制文件 #904
打开
Jon-Chuang 打开了本期 on Apr 12 ·2 评论
评论
@jon创
贡献
钟创评论 on Apr 12 •
对于 https://github.com/ggerganov/llama.cpp/pull/820,加载的模型可能与基本模型不同。能够以交互方式将当前加载的模型导出到 binfile 是有意义的。
特别是如果允许线性插值多个 LoRA 文件的选项 - 即 LoRA 调酒学以获得独特的 LLM 个性.
@MillionthOdin16
百万之奥丁16评论 on Apr 12
如果您熟悉 loras 的混合,我认为如果您可以在上面链接一些资源,这对这里的很多人都会有所帮助。我听说你可以做一些很酷的事情,但我不是很熟悉。
https://huggingface.co/docs/diffusers/main/en/training/lora
目前, LoRA 仅支持 .我们还支持在有限的容量内使用 LoRA 微调 DreamBooth 的文本编码器。微调 DreamBooth 的文本编码器通常会产生更好的结果,但它会增加计算使用率。UNet2DConditionalModel
大型语言模型的低秩适配 (LoRA) 是一种训练方法,可在消耗更少内存的同时加速大型模型的训练。它将秩分解权重矩阵(称为更新矩阵)对添加到现有权重,并且仅训练那些新添加的权重。这有几个优点:
先前的预训练权重保持冻结,因此模型不容易发生灾难性遗忘。
秩分解矩阵的参数明显少于原始模型, 这意味着经过训练的 LoRA 权重易于移植.
LoRA 矩阵通常添加到原始模型的注意力层中.🧨 扩散器提供了 load_attn_procs() 方法将 LoRA 权重加载到模型的注意力层中.您可以通过参数控制模型适应新训练图像的程度。scale
更高的内存效率使您可以在特斯拉T4,RTX 3080甚至RTX 2080 Ti等消费级GPU上运行微调!像T4这样的GPU是免费的,可以在Kaggle或Google Colab笔记本中轻松访问。
ggerganov/llama.cpp#904
对于 https://github.com/ggerganov/llama.cpp/pull/820,加载的模型可能与基本模型不同。能够以交互方式将当前加载的模型导出到 binfile 是有意义的。
特别是如果允许线性插值多个 LoRA 文件的选项 - 即 LoRA 调酒学以获得独特的 LLM 个性.
@MillionthOdin16
百万之奥丁16评论 on Apr 12
如果您熟悉 loras 的混合,我认为如果您可以在上面链接一些资源,这对这里的很多人都会有所帮助。我听说你可以做一些很酷的事情,但我不是很熟悉。
@jon创
贡献
作者
钟创评论 on Apr 12 •
我不是那么熟悉,它只是我突然想到了一种可能性。
基本模型和 LoRA 之间的线性插值已经是一个标准功能: https://huggingface.co/docs/diffusers/main/en/training/lora
Anw,线性插值在这里跟踪:ggerganov/llama.cpp#905
此问题是关于将加载(和修改,例如微调)模型导出到 binfile。
ggerganov/llama.cpp#820
添加 LoRA 支持 #820
动态应用 LoRA 适配器,而无需复制模型文件.
指示:
获取 HF PEFT LoRA 文件和 LoRA 适配器,并将它们放在相同的路径中.对于羊驼,可以在 https://huggingface.co/tloen/alpaca-lora-7b/tree/mainadapter_config.jsonadapter_model.bin
使用进行转换以获得convert-lora-to-ggml.pyggml-adapter-model.bin
python convert-lora-to-ggml.py lora/alpaca-lora-7b
使用 与ggml-adapter-model.bin--lora
./main -m models/7B/ggml-model-f16.bin --lora lora/alpaca-lora-7b/ggml-adapter-model.bin --color -f ./prompts/alpaca.txt -ins -b 256 --top_k 10000 --temp 0.2 --repeat_penalty 1 -t 7
使用量化模型时,质量可能会受到影响。若要避免这种情况,请指定用作基础的 f16/f32 模型。LoRA 适配器修改的层将应用于 lora 基础模型,然后量化为与使用 .未被 LoRA 适配器修改的层将保持不变.--lora-base-m
./main -m models/7B/ggml-model-q4_0.bin --lora lora/alpaca-lora-7b/ggml-adapter-model.bin --lora-base models/7B/ggml-model-f16.bin --color -f ./prompts/alpaca.txt -ins -b 256 --top_k 10000 --temp 0.2 --repeat_penalty 1 -t 7
局限性:
使用禁用 mmap,因为无论如何都必须修改模型。--lora
使用 时,操作用于量化结果,该结果目前在单个线程中完成。并行化将缩短加载时间。--lora-baseggml_cpyggml_cpy
flyinweb用竖起大拇指的表情符号做出反应
tiendung,lin72h,gregnr,ericek111,stoperro,marcom,swittk,mc0ps,cheebeez,michaeloo0和6更多人用心形表情符号做出了反应
Luminalle,msftceo,tekakutli,gorborukov,LiliumSancta,thomasantony,fuchinoko,FNsi,lin72h,81300和20更多人对火箭表情符号做出了反应
@slaren 斯拉伦更改了标题 添加劳拉支持 添加 LoRA 支持 on Apr 7
@MillionthOdin16
百万之奥丁16 评论 on Apr 7
棒!Loras 将非常有用,尤其是他们现在变得多么容易训练🔥
lin72h 用竖起大拇指表情符号做出反应
天东用心表情做出反应
@Piezoid
贡献
Piezoid 评论 on Apr 7
你认为有可能(或希望)生成修补张量的量化版本吗?
( f16 llama model, LoRA's tensors) --> f16 patched tensors --> quantized patched tensors
这将带来量化的加速,并允许对两个文件进行 mmap 映射。来自原始张量的页面不会被错误/加载到内存中(必须禁用)MAP_POPULATE
@slaren
合作者
作者
斯拉伦评论 on Apr 7
@Piezoid我不确定处理这个问题的最佳方法是什么。理想情况下,为简单起见,生成的修补张量将采用与最初相同的格式,因此,如果您修补q4_0模型,您仍然以q4_0模型结束。但是,这可能会显着影响质量,并且可能与修补 f16 模型并在之后即时量化它一样慢或更慢。我们需要运行更多的测试,我可能会尝试实现这两个选项,看看哪个效果最好。
克西德用眼睛表情符号做出反应
@Piezoid
贡献
Piezoid 评论 on Apr 7
@slaren就像你说的, 将 LoRA 增量添加到 q4 量化模型很可能对质量非常不利.量化必须在之后进行。我的建议是生成一个单独的模型文件,仅由添加 LoRA 全秩权重的修补张量组成,并可能将量化作为最后一步。
这个想法是通过只需要修改后的张量的空间来节省磁盘空间。通过脱机完成修补过程,加载时间也可能减少。
您在加载期间修补和量化的建议很有趣,但它需要加载 f16 美洲驼模型并量化尚未修改的张量。
我可能弄错了,因为我不确定哪些张量是量化的,哪些张量是由 LoRA 修补的。
天东用竖起大拇指表情符号做出反应
瓦斯纳姆用困惑的表情符号做出反应
@slaren
合作者
作者
斯拉伦评论 on Apr 7
@Piezoid存储预先修补的张量实际上并不可行,因为文件大小几乎与整个模型相同。lora 的优点是要修补 4096x4096 矩阵,您只需要一个 16x4096 和一个 4096x16 矩阵 (对于排名 16, 可以是任何其他数字).修补它,突然你的 2x16x4096 变成了 4096x4096。
Piezoid和Jon-Chuang用竖起大拇指的表情符号做出反应
@ggerganov
所有者
格尔加诺夫评论 on Apr 8 •
非常有用的信息。
另一种需要考虑的方法是使用矩阵乘法的分配属性:
我们可以将可选的 LoRA 节点添加到计算图中.
例子:(B+C)A=BA+CAllama
cur = ggml_mul_mat(ctx0, model.layers[il].wo, cur);
将变成:
curL = ggml_mul_mat(ctx0, model.layers[il].wo, cur);
if (lora_enabled) {
// can be precomputed once at the cost of more memory
// or we can keep unpacking it each time to save memory
lora = ggml_mul_mat(ctx0, model.loraB[il], model.loraA_trans[il]);
lora = ggml_mul_mat(ctx0, lora, cur); // F32 mul_mat
curL = ggml_add(ctx0, curL, lora); // F32 add
}
cur = curL;
缺点是由于额外的推理速度较慢,但动态加载新的 LoRA 是微不足道的。基本模型保持不变,可以保持量化。ggml_mul_mat
ott2 用竖起大拙的表情符号做出反应
@slaren
合作者
作者
斯拉伦评论 on Apr 8 •
一个小旁注,我意识到在某些情况下还需要添加比例因子。具体来说,这是 PEFT 为合并 lora 所做的:
self.scaling = self.lora_alpha / self.r
if fan_in_fan_out:
self.weight.data = self.weight.data.T
...
self.weight.data += (
transpose(self.lora_B.weight @ self.lora_A.weight, self.fan_in_fan_out) * self.scaling
)
...
def transpose(weight, fan_in_fan_out):
return weight.T if fan_in_fan_out else weight
其中 和 (秩) 是 中的参数。
在羊驼的情况下,这是一个noop,但情况并非总是如此,例如在gpt4all和.lora_alpharadapter_model.jsonlora_alpha = rlora_alpha=32r=8
@slaren
合作者
作者
斯拉伦评论 on Apr 8
@ggerganov除了性能考虑之外, 要记住的是,应用 lora 的张量完全取决于实现, 例如 alpaca 适用于所有 q,k,v,o,但 gpt4all 仅适用于 q,v.我想如果我们必须单独考虑每一个张量,eval 很快就会变成 spaguetti。
@slaren 斯拉伦力推劳拉分支 2 次,最近一次从 cd2dbea 到 a4539e1
last month
@slaren
合作者
作者
斯拉伦评论 on Apr 8
这现在应该适用于量化模型。修补量化模型似乎还不错,我在羊驼q4_0上得到了 6.6281 的困惑。
ggerganov,lin72h,Piezoid,tekakutli和81300用竖起大拇指的表情符号做出反应
MillionthOdin16,lin72h和mc0ps对火箭表情符号做出了反应
@slaren 斯拉伦力推劳拉从 d00017b 到 af00579 的分支
last month
@ggerganov 格尔加诺夫补充说研究🔬标签 on Apr 10
@slaren 斯拉伦力推劳拉从 af00579 到 0d8999a 的分支
last month
@slaren
合作者
作者
斯拉伦评论 on Apr 11
现在 #801 已合并,使用禁用 mmap。加载速度有点慢,但它现在应该可以在窗口上运行。--lora
@MillionthOdin16
百万之奥丁16 通过电子邮件评论 on Apr 11
棒🔥我将很快在Windows上测试它。此功能非常有用🙂
...
@jon创
贡献
钟创评论 on Apr 12 •
因此,为了清楚起见,我们将加载原始参数,然后以批处理方式加载:
加载 fp16 给定矩阵的 LoRA
将原始参数反量化为 fp16
应用劳拉
重新量化以节省内存
粗略估计此适配器“加载”时间有多长?
使用 --lora 禁用 mmap
我想由于您可以修补任意比例的权重,因此修补矩阵的原始权重只加载一次。但是 mmap 对于权重相对较小 + 热插拔 LoRA 的情况可能仍然有用。只是一个想法。
大部分权重的CoW基本上是重复权重,因此非常不可行。
@slaren
合作者
作者
斯拉伦评论 on Apr 12
将 fp16 替换为 fp32,这与它目前的工作方式非常接近:
在 f32 中将矩阵 lora B 和 lora A 相乘
使用 f32 缩放 BA
将 BA 添加到原始权重。这是在必要时进行去量化/重新量化的地方
为我应用适配器的时间从 ~5 秒在 7B 上使用小型 lora 适配器到在 30B 上使用较大的 lora 的分钟以上.到目前为止,最慢的部分是将 lora 矩阵相乘.
可能有一些方法可以加速这一点,但目前我更关心正确性和支持所有用例。
@MillionthOdin16
百万之奥丁16评论 on Apr 12 •
我正在尝试解决Windows上的一些问题。首先,转换脚本和整个过程很简单,所以做得很好,让它变得简单。
我能够很好地加载 7B 美洲驼和 7B 劳拉, 但我注意到我似乎没有得到我期望的响应 应用 Lora.这看起来很奇怪,因为它的行为就好像劳拉根本不存在一样。
当我尝试使用 13B 型号和 13B lora 进行测试时,我在尝试运行 main 时遇到了问题。它提到.我有 64GB 的系统内存,而且它还没有达到最大值,所以我对正在发生的事情感到困惑。not enough space in the context's memory pool
C:\Users\Bradarr\Documents\GitHub\llama.cpp> ./build/bin/main -m D:\models\LLaMA\13B\ggml-model-q4_0-nmap.bin --lora D:\models\loras\bradarr-lora\13B\ggml-adapter-model.bin
main: seed = 1681243691
llama.cpp: loading model from D:\models\LLaMA\13B\ggml-model-q4_0-nmap.bin
llama_model_load_internal: format = ggjt v1 (latest)
llama_model_load_internal: n_vocab = 32000
llama_model_load_internal: n_ctx = 512
llama_model_load_internal: n_embd = 5120
llama_model_load_internal: n_mult = 256
llama_model_load_internal: n_head = 40
llama_model_load_internal: n_layer = 40
llama_model_load_internal: n_rot = 128
llama_model_load_internal: f16 = 2
llama_model_load_internal: n_ff = 13824
llama_model_load_internal: n_parts = 1
llama_model_load_internal: model size = 13B
llama_model_load_internal: ggml ctx size = 7945693.73 KB
llama_model_load_internal: mem required = 9807.47 MB (+ 1608.00 MB per state)
....................................................................................................
llama_init_from_file: kv self size = 400.00 MB
llama_apply_lora_from_file: applying lora adapter from 'D:\models\loras\bradarr-lora\13B\ggml-adapter-model.bin' - please wait ...
llama_apply_lora_from_file: r = 8, alpha = 16, scaling = 2.00
llama_apply_lora_from_file: ggml_new_tensor_impl: not enough space in the context's memory pool (needed 105185904, available 104857600)
有什么指示吗?
超级兴奋地让它工作,因为它开辟了大量的可能性!另外, 只是一个想法, 但可以选择将 lora 融合到基本模型可能会很好.一旦你有一个运行良好的 lora 并不断使用它, 永久捆绑它会很好.
编辑(一些附加信息):
ggml_new_tensor_impl: context memory pool -> (needed 209715232, available 421527552)
ggml_new_tensor_impl: context memory pool -> (needed 419430640, available 421527552)
llama_init_from_file: kv self size = 400.00 MB
llama_apply_lora_from_file: applying lora adapter from 'D:\models\loras\bradarr-lora\13B\ggml-adapter-model.bin' - please wait ...
llama_apply_lora_from_file: r = 8, alpha = 16, scaling = 2.00
llama_apply_lora_from_file: ggml_new_tensor_impl: context memory pool -> (needed 163872, available 104857600)
ggml_new_tensor_impl: context memory pool -> (needed 327920, available 104857600)
ggml_new_tensor_impl: context memory pool -> (needed 105185728, available 104857600)
ggml_new_tensor_impl: not enough space in the context's memory pool (needed 105185904, available 104857600)
@slaren 斯拉伦力推劳拉分支从 0d8999a 到 671190b
last month
@slaren
合作者
作者
斯拉伦评论 on Apr 12 •
@MillionthOdin16感谢您对此进行测试, 确定我尝试过的 lora 是否有任何有意义的影响一直是一场斗争, 但我想我发现了一个问题.您能看到最新的更改是否解决了您的问题吗?
@MillionthOdin16
百万之奥丁16评论 on Apr 12 •
@MillionthOdin16感谢您对此进行测试, 确定我尝试过的 lora 是否有任何有意义的影响一直是一场斗争, 但我想我发现了一个问题.您能看到最新的更改是否解决了您的问题吗?
棒!内存分配问题已修复,现在运行顺利。
我没有得到我期望的 lora 的回应, 所以我怀疑如何应用 lora 有些不对劲.现在我可以运行我的 13B 模型, 更容易看到 lora 何时正常工作 (13B 是我训练最好的 lora).我可以做些什么来帮助排除故障?
我有一个 25MB 的 lora,当放在普通骆驼模型上时,它会显着提高输出.我不知道完全合并到基本模型中的 lora 是否也会有所帮助 (不知道我们是否可以比较这种植入和 lora 融合模型之间的有效权重?
一旦这按预期工作,它将是巨大的。与基本模型相比,在 25MB loras 周围移动要容易得多。而且有很多东西需要通过分层 loras 进行评估,并根据比率对其进行缩放:D
@slaren
合作者
作者
斯拉伦评论 on Apr 12
您使用的是 f16 型号吗?毕竟,尝试将 lora 应用于量化模型可能是一个糟糕的主意.
@MillionthOdin16
百万之奥丁16评论 on Apr 12
你是对的。当美洲驼模型为 f-32 时,输出按预期工作。干得好!
现在我试图找出使其可用的最佳方法。模型与 lora 完全合并并量化为 4 位后, 它仍然产生良好的输出 (我的观点是,最终我们将希望将这些完全量化).
所以我们在 f-32 上合并以保持精度?我想知道允许它在量化模型上工作的最佳方法是什么。在美洲驼的基本模型上运行 lora 的能力本身就很大.cpp因为移动美洲驼的重要变化变得微不足道.有一种方法让用户设置和 lora 并将其融合到模型中,然后将其量化为 4 位将非常有帮助。它不像实时加载 loras 那样简化,但它使 loras 的使用变得更加容易。
你对如何在内存中进行量化有什么想法吗?有没有人测试过量化 lora 是否仍然对量化基础模型有有用的影响?
额外信息
这有效:
PS C:\Users\Bradarr\Documents\GitHub\llama.cpp> ./build/bin/main -m "D:\models\LLaMA\13B\ggml-model-f32.bin" --lora "D:\models\loras\bradarr-lora\13B\ShareGPTUnchained\ggml-adapter-model.bin" --interactive-first
main: seed = 1681250916
llama.cpp: loading model from D:\models\LLaMA\13B\ggml-model-f32.bin
llama_model_load_internal: format = ggjt v1 (latest)
llama_model_load_internal: n_vocab = 32000
llama_model_load_internal: n_ctx = 512
llama_model_load_internal: n_embd = 5120
llama_model_load_internal: n_mult = 256
llama_model_load_internal: n_head = 40
llama_model_load_internal: n_layer = 40
llama_model_load_internal: n_rot = 128
llama_model_load_internal: ftype = 0 (all F32)
llama_model_load_internal: n_ff = 13824
llama_model_load_internal: n_parts = 1
llama_model_load_internal: model size = 13B
llama_model_load_internal: ggml ctx size = 50843293.73 KB
llama_model_load_internal: mem required = 51699.65 MB (+ 1608.00 MB per state)
....................................................................................................
llama_init_from_file: kv self size = 400.00 MB
llama_apply_lora_from_file: applying lora adapter from 'D:\models\loras\bradarr-lora\13B\ShareGPTUnchained\ggml-adapter-model.bin' - please wait ...
llama_apply_lora_from_file: r = 8, alpha = 16, scaling = 2.00
llama_apply_lora_from_file: .......... done (18393.01 ms)
system_info: n_threads = 4 / 24 | AVX = 1 | AVX2 = 1 | AVX512 = 0 | FMA = 1 | NEON = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 0 | SSE3 = 1 | VSX = 0 |
main: interactive mode on.
sampling: temp = 0.800000, top_k = 40, top_p = 0.950000, repeat_last_n = 64, repeat_penalty = 1.100000
generate: n_ctx = 512, n_batch = 8, n_predict = 128, n_keep = 0
这不会:
PS C:\Users\Bradarr\Documents\GitHub\llama.cpp> ./build/bin/main -m "D:\models\LLaMA\13B\ggml-model-q4_0-nmap.bin" --lora "D:\models\loras\bradarr-lora\13B\ShareGPTUnchained\ggml-adapter-model.bin" --interactive-first
main: seed = 1681251252
llama.cpp: loading model from D:\models\LLaMA\13B\ggml-model-q4_0-nmap.bin
llama_model_load_internal: format = ggjt v1 (latest)
llama_model_load_internal: n_vocab = 32000
llama_model_load_internal: n_ctx = 512
llama_model_load_internal: n_embd = 5120
llama_model_load_internal: n_mult = 256
llama_model_load_internal: n_head = 40
llama_model_load_internal: n_layer = 40
llama_model_load_internal: n_rot = 128
llama_model_load_internal: ftype = 2 (mostly Q4_0)
llama_model_load_internal: n_ff = 13824
llama_model_load_internal: n_parts = 1
llama_model_load_internal: model size = 13B
llama_model_load_internal: ggml ctx size = 7945693.73 KB
llama_model_load_internal: mem required = 9807.47 MB (+ 1608.00 MB per state)
....................................................................................................
llama_init_from_file: kv self size = 400.00 MB
llama_apply_lora_from_file: applying lora adapter from 'D:\models\loras\bradarr-lora\13B\ShareGPTUnchained\ggml-adapter-model.bin' - please wait ...
llama_apply_lora_from_file: r = 8, alpha = 16, scaling = 2.00
llama_apply_lora_from_file: .......... done (10663.88 ms)
system_info: n_threads = 4 / 24 | AVX = 1 | AVX2 = 1 | AVX512 = 0 | FMA = 1 | NEON = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 0 | SSE3 = 1 | VSX = 0 |
main: interactive mode on.
sampling: temp = 0.800000, top_k = 40, top_p = 0.950000, repeat_last_n = 64, repeat_penalty = 1.100000
generate: n_ctx = 512, n_batch = 8, n_predict = 128, n_keep = 0
@slaren
合作者
作者
斯拉伦评论 on Apr 12
很高兴听到它正在工作!
关于创建预合并模型,已经可以在python中使用类似于alpaca-lora的脚本来执行此操作,该脚本合并lora然后将模型导出为pth,然后可以像往常一样将其转换为ggml。我不确定是否值得在llama.cpp中复制相同的功能,但如果它可以带来一些便利,我并不完全反对它。convert-pth-to-ggml.py
我怀疑在 f16 中加载由 lora 修改的层,然后将它们量化回与模型相同的格式可能足够快,非常实用.所以你可以做类似的事情,它会保留q4_0模型中未修改的层,但 lora 修改的任何层都将从 f16 加载、修补,然后量化为 q4_0 或任何模型中指定的模型格式。main -m models/7B/q4_0.bin --lora-base models/7B/f16.bin --lora mylora.bin-m
@MillionthOdin16
百万之奥丁16评论 on Apr 12
我怀疑在 f16 中加载由 lora 修改的层,然后将它们量化回与模型相同的格式可能足够快,非常实用.所以你可以做类似的事情,它会保留q4_0模型中未修改的层,但 lora 修改的任何层都将从 f16 加载、修补,然后量化为 q4_0 或任何模型中指定的模型格式。main -m models/7B/q4_0.bin --lora-base models/7B/f16.bin --lora mylora.bin-m
好的,我知道了。请注意, 我使用相同的 lora 文件测试 f-32 f-16 和q4_0基本美洲驼模型.f-32 绝对是 LoRa 化的, F16 绝对是 LoRa 化的 (虽然我不知道输出质量与 f-32 有何不同), q4_0似乎没有任何变化由 Lora 产生.尚未检查代码以了解这是否是预期的。
您认为将量化 lora 应用于量化模式可能有什么优点吗?有时我们会得到有趣的结果,而且肯定会更快(假设你想用准确性换取速度)。
Regarding creating pre-merged models, it is already possible to do that in python by using a script similar to this one from alpaca-lora that merges the lora and then exports the model as pth, which can then be converted to ggml as usual with . I am not sure that it is worth replicating the same feature in llama.cpp, but I am not entirely opposed to it if it can bring some convenience.convert-pth-to-ggml.py
Yes, I've seen the scripts, but I think for most users the understanding of model file formats and what they currently have vs what format they need is very confusing. My thought is that loras have the ability to significantly change the model outputs, are super lightweight, and are becoming more accessible and easier to train with projects like @lxe/simple-llm-finetuner. If we are able to streamline the use of loras and conversion of a lora adapter to a ggml model format they are familiar with, we can make learning about language models much easier (abstracting away as much pytorch/GPU/heavy ML stuff as possible). I know you already know this haha, I'm just excited about how this and similar projects make very technical areas easy to play with.
@MillionthOdin16
MillionthOdin16 commented on Apr 12
Also, I've noticed a scaling factor in console and you've mentioned it some. Is this something that directly affects the 'impact' of the lora weights on the overall model? If so, it could be useful to break it out as an argument to make experimentation easier. With stable diffusion they've done some pretty cool things with mixing different lora layers (so I'm thinking about this for down the line)
@slaren
合作者
作者
斯拉伦评论 on Apr 12
f-32 绝对是 LoRa 化的, F16 绝对是 LoRa 化的 (虽然我不知道输出质量与 f-32 有何不同), q4_0似乎没有任何变化由 Lora 产生.尚未检查代码以了解这是否是预期的。
据我了解,美洲驼模型原生为 f16,因此我不希望使用 f32 模型带来太大好处。
您认为将量化 lora 应用于量化模式可能有什么优点吗?有时我们会得到有趣的结果,而且肯定会更快(假设你想用准确性换取速度)。
这样做的问题是,loras对权重进行了非常小的修改,当应用于量化模型时,这些变化可能会完全消失在噪声中。使用量化的 lora 只会使问题变得更糟, 我认为这根本行不通.
另外,我注意到控制台中有一个缩放因子,您已经提到了一些。这是否直接影响 lora 权重对整体模型的“影响”?
这只是 PEFT 库根据 lora 的参数和等级做的事情, 我认为它根本不应该修改, 但谁知道它可能有什么影响.在其他洛拉之上应用 loras 对我来说似乎非常可疑,我根本不希望它有效,但我想在某些情况下它可能会?无论如何,我会把这个实验留给 GPU 人员,如果他们发现有价值的东西,我们可以在这里向后移植它。lora_alpha
https://github.com/megvii-research/Sparsebit
Sparsebit是一个具有修剪和量化功能的工具包。它旨在帮助研究人员通过修改现有pytorch项目中的几个代码来压缩和加速神经网络模型。
量化
量化将全精度参数转换为低位精度参数,可以在不改变模型结构的情况下压缩和加速模型。该工具包支持两种常见的量化范例,即训练后量化和量化感知训练,具有以下功能:
得益于torch.fx的支持,Sparsebit在QuantModel上运行,每个操作都成为QuantModule。
用户可以轻松地扩展Sparsebit以适应他们自己的研究。用户可以自行注册以扩展重要对象,例如QuantModule,Quantizer和Observer
支持导出 QDQ-ONNX,可以通过 TensorRT 和 OnnxRuntime 等后端加载和部署。
https://github.com/A-baoYang/alpaca-7b-chinese
🦙🧋🇹🇼使用中文指令数据集微调LLaMA-7B
有关LLM的更多微调方法,请参阅LLM-微调指南
这个存储库是用中文数据集微调LLaMA-7B的教程!我调查并结合数据集和方法,以微调我自己的LLM用于复杂的NLP任务,如摘要,问答,文本生成,自定义数据增强等。
由于最初的斯坦福 Alpaca-7B 微调需要大量 GPU 资源,因此我专注于研究低 GPU 消耗的方法。
ggerganov/llama.cpp#964
以下是 LoRA 的一些未决问题:
基本实现 (ggerganov/llama.cpp#820)
使用 SIMD (AVX, AVX2) 缩短 LoRA 应用时间 (ggerganov/llama.cpp#956)
在基本模型上使用 MMAP 缩短 LoRA 加载时间
量化已应用 LoRA 的 MMAPed float16 基本模型
权重插值(从 1 开始,查看多个)(ggerganov/llama.cpp#905)
将加载的模型导出到二进制文件(在带有LoRA(标志)的CLI中独立;交互式(?))(--export-lorahttps://github.com/ggerganov/llama.cpp/issues/904)
研究为任意模型提取 LoRA(请参阅 huggingface/peft#312)
目前还不支持。如果只是单纯把lora模型的权重叠加并不会有好的效果。
不过lora应该可以像MoE那样将多个lora模型合并,这是一个很有前途的架构,估计现在有很多科研前线的研究人员在做了,其实就和adapterFusion一个道理,原理很简单AdapterFusion: Non-Destructive Task Composition for Transfer Learning(AdapterFusion),stable diffusion那边挺多弄这个的。
要实现的话可以参考一下思路:
1、hard MoE,在对一个句子动态选择使用哪个lora权重
2、soft MoE,对一个句子的时候,把各种lora计算一个注意力权重,然后融合起来
这些都是很有意思的idea,不过我们目前还不支持这样做。
LoRACSE: 使用 LoRA 对句子嵌入的对比学习
https://github.com/tic-top/LoraCSE
EECS 487的最终项目:自然语言处理导论(Umich)
导演:贾一林、李思凯、麦玉琪
日期: 18 4月, 2023
指示
该项目涉及通过一系列实验评估 LoraCSE 模型的性能.下面介绍如何访问和运行代码:
打开 LoraCSE.ipynb 笔记本以查看并运行所有实验的代码。
按照笔记本中提供的说明使用 GPU 运行实验并查看结果。
运行实验后, 请参阅随附的 LoRACSE.pdf 文件以获取结果的详细分析.
LoRACSE.pdf中提供的分析提供了对LoraCSE模型的性能及其处理不同类型数据的能力的见解。使用此信息可提高模型针对特定用例的准确性。
ggerganov/llama.cpp#996
将暂时停止这里的调查。应用 LoRA 所需的时间对于这些更改是可以忍受的.
我们离最佳状态还很远;例如,我在高 K (K=10000) 的矩阵上看到 250KFLOPs/us。
LoRA 应用程序非正式基准测试:
K=16
AVX2 - 5141.57 ms
AVX - 9831.28 ms
default - 22611.96 ms
不,又高又瘦的样子:
__
| | ___________
| | X |__________|
|__|
矩阵到向量是
| | | |
| | X | |
| __________| ||
ggerganov/llama.cpp#1449
如何在合并 Lora 的情况下输出 ggml 文件?#1449
打开
FNsi 打开了本期 五月 last week ·3 评论
打开
如何在合并 Lora 的情况下输出 ggml 文件?
#1449
FNsi 打开了本期 五月 last week ·3 评论
评论
@FNsi
FNsi 评论 last week •
我认为 Lora 正在申请,而做ggml_graph_comput(lora_ctx, &gf)
我应该怎么做才能输出一个完整的 ggml 文件,包括美洲驼 + 合并的 lora?
我认为简单地通过添加参数uint_8 *dst 来修改Llama_apply_lora_from_file_internal是行不通的......
有没有相反的方法可以将其转换为完整的ggml文件或从ram中复制出来的方法?
mirek190和UbiquitousWhite用竖起大拇指的表情符号做出反应
FNsi用眼睛表情符号做出反应
@FNsi FNsi 更改了标题 劳拉适应后如何将张量输出到 ggml 文件? 如何输出与劳拉合并的 ggml 文件? last week
@slaren
合作者
斯拉伦评论 last week
目前,没有任何方法可以使用llama.cpp创建预合并的模型。如果需要这样做,可以将其与 pytorch/PEFT 合并,然后将合并的模型转换为 ggml。
支持这一点不会太难, 我们可以添加一个函数来将加载的模型保存到磁盘,您可以在应用 LoRA 后使用, 但每个 API 都会增加复杂性和更多代码需要维护, 并且不相信我们真的需要这个.有什么理由用美洲驼这样做.cpp而不是使用 python 来合并 LoRA?
@FNsi
作者
FNsi 评论 5 days ago •
目前,没有任何方法可以使用llama.cpp创建预合并的模型。如果需要这样做,可以将其与 pytorch/PEFT 合并,然后将合并的模型转换为 ggml。
支持这一点不会太难, 我们可以添加一个函数来将加载的模型保存到磁盘,您可以在应用 LoRA 后使用, 但每个 API 都会增加复杂性和更多代码需要维护, 并且不相信我们真的需要这个.有什么理由用美洲驼这样做.cpp而不是使用 python 来合并 LoRA?
这是我本能的想法, 我认为如果我们能一步到位地获得 Lora 的量化模型, 而不是将美洲驼重量转移到 HF 或一次又一次地从拥抱脸下载大文件, 那会更直接.
我尝试这样做的最重要原因是因为我想合并没有 pth-hf-pth-ggml 但内存要求较低的多 loras,就像在 32gb 笔记本电脑中一样。因此,更多的劳拉斯合并将像野火一样受到考验。
例如,目前我正在使用wizard-vicuña + Lora:evol-starcoder,我发现它非常有用!有点疯狂,它可以正确地进行大量计算(有时仍然是错误的),是的,它可以读取代码并告诉我代码到底是做什么的,因为它只有 13b,这只是向我展示了一个简单的事实:
更多的洛拉斯可以带来更高的生产力。
正如我们目前所知,这些模型训练数据大小没有达到饱和点,并且暗示loras可能是近乎完美的模型,具有所有这些参数的全部潜力。
这就是为什么我想知道如何直接用骆驼.cpp来做这件事,降低界限,更多的人加入进来,最后可能会创造一个令人难以置信的模型。
@iplayfast
iplayfast 评论 3 days ago
我也认为这很有用,只是因为我正在学习美洲驼.cpp并且想专注于它。与 PyTorch/PEFT 合并的想法表明这是可能的,但你不知道你不知道什么。我当然甚至不知道看 peft(不管那是什么!在美洲驼中提供 API .cpp意味着我会找到它。我理解不愿意添加额外的API,但我真的觉得这会很有用,而且我之前在llama.ccp中寻找过。
https://github.com/Prsaro/lora_dualnetwork
双LoRA网络实现风格融合
Arxiv • 依赖 • 培训 • 测试 • 日志 • 引用
python license
从使用 lora 块权重的 LoRA 分层控制中汲取灵感, 我们开发了这个脚本.在 SD LoRA 模型中, 当多个 LoRA 模型堆叠时,可能会发生特征融合和崩溃, 极大地限制了 LoRA 模型的使用案例.为了缓解这个问题, 我们提出了一种新的 LoRA 训练方法,该方法涉及同时训练两个 LoRA 模型.这允许两个LoRA模型在训练过程中相互约束, 从而在高维空间中分离两个LoRA模型的特征并减少特征的耦合.
https://github.com/danielgrittner/nanoGPT-LoRA
用于训练/微调中型 GPT 的最简单、最快的存储库。这是对minGPT的改写,将牙齿置于教育之上。仍在积极开发中,但目前该文件在OpenWebText上重现GPT-2(124M),在大约4天的训练中在单个8XA100 40GB节点上运行。代码本身简单易读:是一个 ~300 行的样板训练循环和一个 ~300 行的 GPT 模型定义,可以选择从 OpenAI 加载 GPT-2 权重。
oobabooga/text-generation-webui#1088
似乎可以用低至 6Gib VRAM 微调 INT4 LLM,这要归功于随机/xturing:https://github.com/stochasticai/xturing#-new-feature---int4-fine-tuning-with-llama-lora
将此功能集成到文本生成中会很棒 webui .
谢谢!
其他上下文
https://github.com/stochasticai/xturing/blob/main/examples/int4_finetuning/README.md
https://github.com/jasonvanf/llama-trl
LLaMA-TRL 使用PPO和LoRA微调LLaMA
使用 TRL(变压器强化学习)实施 PPO(近端策略优化)
使用 PEFT(参数高效微调)实现 LoRA(大型语言模型的低秩适配)
从此存储库 GPT-4-LLM 收集遵循指令的数据
QLoRA:在单个 GPU 上微调 65B LLM
https://github.com/artidoro/qlora
oobabooga/text-generation-webui#2253
huggingface/transformers#23479
想知道它会更快还是更稳定。由于它是通过变压器进入的,因此应该更容易支持。希望它不仅限于美洲驼。
不仅如此,它还应该在现有的 8 位选项之外添加一个备受期待的新选项,用于使用新的 FP4 格式进行动态 4 位量化,据称相对于 16 位几乎是无损的。load_in_4bit
如果这是真的,这太疯狂了,我们将不再需要 GPTQ
此 PR 将 4 位 QLoRA 引入变压器。主要变化是针对位沙字节配置。此外,我们对 LLaMA 实现添加了一项更改,其中存在一个错误,即如果层规范为 32 位,其余的为 bf16,则数据类型可能。
有关QLoRA的更多信息,请从我们的摘要中获取:
我们开发了 QLoRA 调谐,这是一种通过将梯度通过冻结的 4 位基本模型反向传播到低秩适配器 (LoRA) 中进行微调的方法。通过 QLoRA 调优,我们可以在 24/48GB GPU 上微调 30B/65B 参数模型,同时保留常规的 16 位完整微调运行时和任务性能。我们通过新方法的组合来实现内存效率和量化精度:嵌套量化,将每个参数的平均内存占用从 4.5 位减少到 4.1 位,分页优化器管理梯度检查点内存峰值,以及新的数据类型 4 位 NormalFloat (NF4),它在理论上和经验上是正态分布权重的最佳信息。为了证明 QLoRA 调优的有效性和易用性,我们对 1,000 多个模型进行了微调,以创建跨数据集(FLAN、Alpaca、Chip2、SuperNatural Instructions、Chip2、AnthropicHH)、模型类型(LLaMA、T5)和模型规模(125M 到 65B)的性能指令的详细剖析。我们的论文即将对结果进行讨论。
https://github.com/kyegomez/Sophia
索菲亚优化器 将模型训练成本降低 50%?
有了这个全新的简单即插即用优化器:索菲亚
现在,实验文件夹中的训练文件已准备就绪!🔥🔥🔥
Sophia 是一种二阶裁剪随机优化算法,它使用对 Hessian 对角线的廉价随机估计作为预调节器和裁剪机制来控制最坏情况的更新大小。它在验证预跟踪损失、总计算和挂钟时间方面实现了比 adam 更好的性能。通过将模型训练成本降低一半,Sophia 可以帮助节省数百万甚至数十亿美元的计算资源。
好处
索菲亚实现了相同的验证训练前损失,步数比亚当少 50%
总计算量减少 50%,挂钟时间减少 50%
无缝集成到现有培训管道中 - 即插即用!
对模型架构或计算基础设施没有特殊要求
支持哈钦森和高斯-牛顿-巴特利特黑森估计量
https://github.com/stochasticai/xturing
xTuring提供快速、高效和简单的LLM微调,如LLaMA,GPT-J,Galactica等。通过提供一个易于使用的界面来微调LLM到您自己的数据和应用程序,xTuring使构建,自定义和控制LLM变得简单。整个过程可以在您的计算机内部或私有云中完成,确保数据隐私和安全。
有了你可以,xTuring
从不同来源摄取数据并将其预处理为LLM可以理解的格式
从单个 GPU 扩展到多个 GPU,以便更快地进行微调
利用内存高效方法(即 INT4、LoRA 微调)将硬件成本降低多达 90%
探索不同的微调方法并对其进行基准测试,以找到性能最佳的模型
根据明确定义的指标评估微调模型以进行深入分析
ggerganov/llama.cpp#1400
[功能要求]使模型组合成为可能(长镜头!#1400
打开
skidd-level-100 打开了本期 五月 last week ·2 评论
打开
[功能要求]使模型组合成为可能(长镜头!
#1400
skidd-level-100 打开了本期 五月 last week ·2 评论
评论
@skidd级-100
skidd-level-100 评论 last week
我很想看到模型组合工具!那就太棒了!我们有 loras,这很棒,但成熟的组合会更好!
FNsi和Pannous用竖起大拇指的表情符号做出反应
@SlyEcho
合作者
SlyEcho 评论 last week
模型组合如何工作?
您是否有一些论文可以链接到以便我理解?
@FNsi
FNsi 评论 last week •
模型组合如何工作?
您是否有一些论文可以链接到以便我理解?
我认为他的意思是将多个 lora 权重合并到美洲驼?例如,同时合并巫师骆马和星码。
我确实发现它可能有效,但需要一些时间。
第一convert_llama_weights_to_hf
第二次将 hf 与 lora 合并为 pth
第三 convert-pth-to-ggml.py
如果你想转换30B,需要100G +内存,那就太可悲了。
所以只有一种方法...从 llama .cpp运行时复制合并的权重😂
添加使用羊驼模型的正确说明 #382
打开
格尔加诺夫打开了这个问题 on Mar 22 ·21 评论
评论
@ggerganov
所有者
格尔加诺夫评论 on Mar 22 •
所以我正在查看 https://github.com/antimatter15/alpaca.cpp,我看到他们已经运行 30B 羊驼模型,而由于最近的分词器更新,我们正在努力运行 7B。
我还看到这些模型现在甚至漂浮在拥抱脸上 - 我想许可证问题不再是问题?
我们应该添加获取羊驼模型的详细说明,以及如何使用以下脚本使模型与最新版本兼容的临时说明:master
#324 (评论)
更大的问题是人们不断生成旧版本的模型,而不是迁移到最新的更改。因此,我们现在需要这个额外的转换步骤。最好弄清楚生成羊驼模型的步骤并以正确的格式生成它们。ggmlllama.cpp
编辑:只是不要发布模型的直接链接!
Botchi09、Kawashirov、Plusv、Lolxdmainkaisemaanlu、Syndimann、Green-Sky、Loretoparisi、esstee8、rmallof、redthing1 等 10 人都用竖起大拇指表情符号做出了反应
@ggerganov 格格尔加诺夫补充道文档 文档的改进或补充寻求帮助 需要格外注意好第一期 适合新移民高优先级 非常重要的问题🦙. 骆马标签 on Mar 22
@madmads11
madmads11 评论 on Mar 22 •
以下是我用llama.cpp在我的系统上运行Alpaca 30b所做的。我认为它也适用于 Alpaca 13b。
从头开始下载并构建骆驼.cpp因为需要最新版本来指定模型在 1 个文件中,其中包含新参数--n_parts 1
下载了这个 30b 羊驼模型 https://huggingface.co/Pi3141/alpaca-30B-ggml/tree/main(如果您查看模型卡,您可以找到其他羊驼模型尺寸的链接)
将文件命名并放置在美洲驼内的 /models/Alpaca/30b 中.cppggml-alpaca-30b-q4.bin
下载了此处提到的脚本:自 PR #252 #324 以来模型的重大更改(评论)
将其命名为 convert.py 并将其放置在llama.cpp的根文件夹中。
下载了这里提到的分词器:自 PR #252 #324 以来模型的重大更改(评论)
将 tokenizer.model 文件放在 /models 中
从 llama 的基本文件夹在命令提示符下运行.cpp(我个人收到我需要该模块的消息,所以我写了,然后我重新运行并且它起作用了。您可能会也可能不会遇到此错误。python convert.py models/Alpaca/30b models/tokenizer.modelsentencepiecepip install sentencepiecepython convert.py models/Alpaca/30b models/tokenizer.model
在 30b 文件夹中,现在有一个和一个文件,我重命名为 以将其保留为备份,并ggml-alpaca-30b-q4.binggml-alpaca-30b-q4.bin.tmpggml-alpaca-30b-q4.binggml-alpaca-30b-q4.bin.oldggml-alpaca-30b-q4.bin.tmpggml-alpaca-30b-q4.bin
现在我可以运行骆驼.cpp与../main -m ./models/alpaca/30b/ggml-alpaca-30b-q4.bin --color -f ./prompts/alpaca.txt -ins --n_parts 1
也许这对其他渴望设置它的人都有临时帮助。如果我犯了任何错误,请纠正我,我从记忆中追溯写了它。
ggerganov/llama.cpp#172
羊驼劳拉作者在这里。我添加了一个脚本来合并权重并将其转换为我的存储库(链接)中的state_dict。好奇地看到它在美洲驼上运行.cpp :)
该代码不适用于美洲驼-65B。代码中的参数似乎与 7B 和 65B 不同。如何获得正确的参数?
尝试与羊驼-洛拉合并及其量化 #172
打开
taiyou2000 打开了本期 on Mar 16 ·19 评论
评论
@taiyou2000
泰友2000 评论 on Mar 16
我试图合并 https://huggingface.co/tloen/alpaca-lora-7b 的羊驼-lora和 https://huggingface.co/decapoda-research/llama-7b-hf 的原始美洲驼-7B,还试图量化模型并在llama.cpp中运行主文件。
合并代码来自 https://github.com/clcarwin/alpaca-weight
直到最后阶段,在 llam.cpp 中运行主文件几乎是成功的。我在合并和量化方面没有问题。
然后它引发了这样的错误:
llama_model_load:llama_model_load:模型文件中
的未知张量“model.embed_tokens.weight”主:无法从“./models/7B/ggml-model-q4_0.bin”加载模型
我将在我的存储库**享我的日志。我在 colab 中用于合并和量化模型的代码也在那里:https://github.com/taiyou2000/personal_experimant
我不是机器学习专家,也没有检查过整个骆驼.cpp代码,但在我的理论中,也许量化模型包含权重,其中一些具有主要.cpp不希望看到的名称。正如您在我的存储库的quantization_log.txt和pth_to_ggml_log.txt中看到的那样,它的名称类似于“model.layers.0.self_attn.q_proj.weight”,并且可能它应该像main.cpp的“model.layers.0.attention.wq.weight”。
我可以在本地计算机上运行骆驼.cpp没有任何问题,并且模型是从洪流版本量化的。我想拥抱脸版本与它有所不同。
特洛恩和星云用眼睛表情符号做出反应
@nebulatgs
贡献
星云评论 on Mar 16
我认为这是因为该模型是 HF 格式,在 Alpaca 数据集上微调 LLaMA 7B 后,我遇到了同样的问题。
tloen和taiyou2000用竖起大拇指的表情符号做出反应
@nebulatgs
贡献
星云评论 on Mar 16
如果有人想合作使 HF 模型与此存储库配合使用,请给我发电子邮件,或回复此评论!
@beiller
贡献
贝勒评论 on Mar 16
我认为问题是令牌嵌入在模型文件中,而您的代码没有嵌入令牌。@ggerganov你能确认一下吗?仍然是一个整合句子的案例。
@gjmulder 吉穆德补充道增强 新功能或请求寻求帮助 需要格外注意标签 on Mar 16
@taiyou2000
作者
泰友2000 评论 on Mar 16
我正在比较两个模型的参数。我注意到也许重命名参数就可以正常工作。但我不知道哪些参数彼此对应。而且我认为HF模型的转换器与洪流模型有些“相反”,因为洪流模型在每层中有一个名为output的层,而HF模型在每层中有一个名为input的层。
重命名参数很容易,还是需要从头开始编码?
HF 模型参数:
layers.0.self_attn.q_proj.weight layers.0.self_attn.k_proj.weight layers.0.self_attn.v_proj.weight layers.0.self_attn.o_proj.weight layers.0.self_attn.rotary_emb.inv_freq
layers.0.mlp.gate_proj.weight layers.0.mlp.down_proj.weight layers.0.mlp.up_proj.weight layers.0.input_layernorm.weight layers.0.post_attention_layernorm.weight
标准重量
lm_head.重量
洪流模型参数:
标准.重量输出.重量层.0.注意.wq.重量层.0.注意.wk.重量层.0.注意.wv.重量层.0.注意.wo.重量 layers.0.feed_forward.w1.重量
layers.0.feed_forward.w2.重量 layers.0.feed_forward.w3.重量 layers.0.attention_norm.重量 layers.0.ffn_norm.重量
@tloen
tloen 评论 on Mar 16 •
羊驼劳拉作者在这里。我添加了一个脚本来合并权重并将其转换为我的存储库(链接)中的state_dict。好奇地看到它在美洲驼上运行.cpp :)
绿天、星云、星云、奥科代罗、泰尤2000、事实小说、柚月S、瘟疫、尼克、血清素等20个对**表情符号做出反应
大卫弗罗内斯用火箭表情符号做出反应
@taiyou2000
作者
泰友2000 评论 on Mar 16
非常感谢@tleon。我也试图转换state_dict,但很难知道不排列功能。
我很快就会试一试!
@eous
eous 评论 on Mar 16 •
羊驼劳拉作者在这里。我添加了一个脚本来合并权重并将其转换为我的存储库(链接)中的state_dict。好奇地看到它在美洲驼上运行.cpp :)
Instruction: What should I have for dinner?
Output: 153 grams of beef, plus rice and peas. And you need to eat all the food! [end of text]
哇,这个脚本比我掉进去的兔子洞更直接。干得不错。
@taiyou2000
作者
泰友2000 评论 on Mar 16
我刚刚尝试了羊驼-劳拉合并模型与量化.结果并不像 tloen repo 中介绍的示例那么好。可能是量化的价格或合并实际上不成功。也许我应该修改骆驼.cpp中的配置?无论如何,谢谢大家。
@eous
eous 评论 on Mar 16
我刚刚尝试了羊驼-劳拉合并模型与量化.结果并不像 tloen repo 中介绍的示例那么好。可能是量化的价格或合并实际上不成功。也许我应该修改骆驼.cpp中的配置?无论如何,谢谢大家。
是的,量化不是很好,但使用混合的 fp16/fp32 运行它给出了预期的性能。
Tloen,Mauzus,lin72h,Nindanaoto和GeorgesAlkhouri用火箭表情符号做出了反应
这被引用 on Mar 16
斯坦福羊驼支持 #99
闭
羊驼和美洲驼 #203
闭
@thement
合作者
thement 评论 on Mar 17 •
羊驼劳拉作者在这里。我添加了一个脚本来合并权重并将其转换为我的存储库(链接)中的state_dict。好奇地看到它在美洲驼上运行.cpp :)
江淮你几乎有相同的代码将 HF 转回美洲驼格式,就像我一样:)
我只是有一个想法。使用 4 位 GQPT 量化 7B/13B/...HF格式的模型可以将其解压缩为float-16并将其转换为美洲驼模型,并用骆驼.cpp量化对其进行重新量化,这将有望保留量化。
@totoCZ
totoCZ 评论 on Mar 17
所以我们现在有 https://github.com/antimatter15/alpaca.cpp 但它只有无休止的聊天模式。
有人需要将所有内容与此存储库合并在一起,以便可以使用达赖运行
cannin,wizd,woozyking,tloen,mwalol,lolxdmainkaisemaanlu和swittk用竖起大拇指的表情符号做出了反应
@thement
合作者
thement 评论 on Mar 17
羊驼劳拉作者在这里。我添加了一个脚本来合并权重并将其转换为我的存储库(链接)中的state_dict。好奇地看到它在美洲驼上运行.cpp :)
无论如何,这是一个脚本,它也对 4 位模型进行反量化,以便稍后可以重新量化(但仅适用于 q4_1 并修复了在整行上计算最小/最大值,而不仅仅是 QK=32 大批量)
https://gist.github.com/thement/90be08be928e0489aba7ecae9f0b352a
如果您认为这很有用,我也许可以升级convert_pth脚本。
@gjmulder gjmulder 提到了这个问题 on Mar 17
是否可以扩展此代码库以支持其他基于转换器的LLM,例如Pythia或其指令调优版本的Open Assistant?#219
打开
@namliz
纳姆利兹评论 on Mar 18
无论如何,这是一个脚本,它也对 4 位模型进行反量化,以便稍后可以重新量化(但仅适用于 q4_1 并修复了在整行上计算最小/最大值,而不仅仅是 QK=32 大批量)
@thement等等,什么?它可以无损往返吗?
@linonetwo
里诺内二评论 on Mar 18
我们可以用美洲驼加载 LoRA .cpp吗?原始美洲驼不支持某些语言, 但可以通过 LoRA 提供.
tomsnunes,tekakutli,FNsi,edwios和RioLynnnnn用眼睛表情符号做出反应
@tarruda
塔鲁达评论 on Mar 21
我们可以用美洲驼加载 LoRA .cpp吗?原始美洲驼不支持某些语言, 但可以通过 LoRA 提供.
是的,您只需要使用脚本@tloen获取 pytorch 权重,然后按照自述文件中描述的步骤转换为 ggml。
请注意,即使没有量化,llama.cpp 的输出与 pytorch 的输出也不相同。这是我在当地用羊驼劳拉做的一个简单的测试:
alpaca-lora-quicksort-pytorch
Same request to llama.cpp using the converted weights (no quantization). Also modified to pass similar arguments: (not sure if missed something, I don't really know what most of these parameters mean). Here's the result:alpaca.sh./main -m ./models/7BLora/ggml-model-f16.bin --color -f ./prompts/alpaca.txt -ins --top_k 40 --top_p 0.75 --temp 0.1 --repeat_penalty 1 -t 4 -n 2000
image
Started well but ended up messing up later. Funny thing is that the llama.cpp implementation would have been a faster (if it was correct) since it only loops the array once.
It really got messed up when I tried with the 4-bit quantized weights:
image
好消息是,非量化版本比使用 CPU 的 pytorch 版本更快,使用的内存更少。虽然 pytorch 减速可能是因为它在运行时加载了微调?@tloen可能知道。如果我们能让骆驼.cpp产生与pytorch相同的输出,那将是一个巨大的胜利。@ggerganov可能更了解输出中的这种差异。
里诺内二用竖起大拇指的表情符号做出反应
@tarruda
塔鲁达评论 on Mar 21
以下是与 GPT 3.5 的比较:
image
我试图将“temp”提高到 0.7 以匹配 GPT 3.5 的“temp”,但它导致了更糟糕的解决方案(即使“就地”排序的目标很好😄):
image
linonetwo and JamoDevNich reacted with eyes emoji
@xloem
Contributor
xloem commented on Mar 27
When you see a disparity between outputs in two important engines that should be identical, if you know how to use a debugger, it’s quite helpful to debug both in parallel and see where the numbers start diverging.
@edwios edwios 提到了这个问题 on Mar 29
支持 LoRA 模型加载张量子集 #399
闭
@Gitterman69
吉特曼69评论 on Apr 10
我正在使用文本生成webui来成功训练llama7b(8位)的loras。有没有办法将训练有素的劳拉与美洲驼 7b 重量合并?我的目标是训练一个 lora, 合并, 再次训练其他东西, 再次合并, 等等....这里有人可能知道如何实现合并部分吗?
cnmoro用竖起大拇指的表情符号做出反应
@ghqing0310
ghqing0310 评论 4 days ago
羊驼劳拉作者在这里。我添加了一个脚本来合并权重并将其转换为我的存储库(链接)中的state_dict。好奇地看到它在美洲驼上运行.cpp :)
该代码不适用于美洲驼-65B。代码中的参数似乎与 7B 和 65B 不同。如何获得正确的参数?
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.