【Google Colab】使用unsloth针对医疗数据集举行大语言模型的快速微调（含 ...

【本文概述】

为了快速跑通，起首忽略算力等题目，使用google colab云端服务器，选择unsloth/DeepSeek-R1-Distill-Llama-8B大语言模型举行微调，微调参数只举行了简单的设置。
在微调的时候，现实阐明colab对8B的模型微调算力不敷，故只选取了数据集中的一部门举行训练，最终的微调实现结果并不好，但的确可以看到很显着的调试结果，暂可视为本项目运行成功，后期再考虑算力、数据集、微调参数、微调模型的质量等，恰当初期尝试使用unsloth举行微调理解的项目。
【准备工作】

• Colab： 只必要一个 Google 账户，免费版提供 T4 GPU（约 15GB 显存），足够跑 7B 参数模型。
  
• 本地环境： 用于部署的电脑建议至少 8GB 内存（运行 7B 模型），若有 NVIDIA GPU 可加速。
  
• 网络： 稳定的互联网毗连，用于下载模型和数据集
  

【项目流程】

【0-创建项目】

在云端硬盘中新建笔记本

更改运行时类型，选择T4 GPU后举行保存

【1-安装依赖】

在 Colab 新建笔记本，运行以下代码安装所需库：
这些库包括 Unsloth 主步伐、bitsandbytes（用于量化模型）和 unsloth_zoo（预训练模型支持）。

1. %%capture
2. # 这是一个 Jupyter Notebook 的魔法命令，用于隐藏命令的输出。
3. # 通过捕获输出，可以让 Colab 的界面更整洁，避免显示冗长的安装日志。
5. # 安装 unsloth 包。
6. # unsloth 是一个高效的工具，用于微调大型语言模型（LLM），能显著减少显存需求并加速训练。
7. !pip install unsloth
9. # 卸载当前已安装的 unsloth 包（如果存在），然后从 GitHub 安装最新版本。
10. # "-y" 表示自动确认卸载，"--upgrade" 确保获取最新版，"--no-cache-dir" 避免使用缓存，
11. # "--no-deps" 跳过依赖安装（因为我们只关心 unsloth 本身），
12. # 通过 GitHub 源安装可以获得最新的功能和修复。
13. !pip uninstall unsloth -y && pip install --upgrade --no-cache-dir --no-deps git+https://github.com/unslothai/unsloth.git
15. # 安装 bitsandbytes 和 unsloth_zoo 两个依赖包。
16. # bitsandbytes 是一个用于模型量化的库，支持 4 位和 8 位精度，能大幅降低内存占用。
17. # unsloth_zoo 提供了一些预训练模型或相关工具，方便用户快速上手。
18. !pip install bitsandbytes unsloth_zoo

复制代码

随后在colab上配置系统环境变量，以便正确地使用CUDA。通过设置LD_LIBRARY_PATH和CUDA_HOME，它确保系统能够找到CUDA的动态链接库和安装路径，从而让依赖CUDA的步伐（如深度学习框架TensorFlow、PyTorch等）能够正常运行。

1. import os
2. os.environ['LD_LIBRARY_PATH'] = '/usr/local/cuda/lib64:' + os.environ.get('LD_LIBRARY_PATH', '')
3. os.environ['CUDA_HOME'] = '/usr/local/cuda'

复制代码

 为了确保项目顺遂运行，再通过pip命令安装和管理Python库。

1. !pip install --upgrade pip
2. !pip install torch
3. !pip install transformers
4. !pip install accelerate
5. !pip install bitsandbyte
6. !pip install trl

复制代码

• torch、torchvision、torchaudio：通过指定--extra-index-url https://download.pytorch.org/whl/cu124，安装的是与colab中CUDA 12.4兼容的版本。
  
• transformers、accelerate、bitsandbytes、trl：安装的是这些库的最新版本（通过pip install命令默认行为）。
  

   以下对安装的库举行简单表明
  

• pip（升级）：
  
  
  
  • !pip install --upgrade pip：升级pip到最新版本，确保后续安装操作能够顺遂举行。
    
  
  
• torch（PyTorch）：
  
  
  
  • !pip install torch：安装PyTorch库。PyTorch是一个盛行的深度学习框架，广泛用于研究和生产环境。
    
  • !pip install torchvision torchaudio：安装与PyTorch配套的torchvision（用于计算机视觉任务）和torchaudio（用于音频处理任务）库。
    
  • !pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu124：指定从PyTorch的CUDA 12.4版本的预编译包中安装PyTorch及其配套库。这通常是为了确保与特定版本的CUDA兼容。
    
  
  
• transformers：
  
  
  
  • !pip install transformers：安装Hugging Face的transformers库。这是一个用于自然语言处理（NLP）的库，提供了预训练模型（如BERT、GPT等）的接口和工具。
    
  
  
• accelerate：
  
  
  
  • !pip install accelerate：安装accelerate库。这是一个用于简化分布式训练和混合精度训练的库，由Hugging Face开辟。
    
  
  
• bitsandbytes：
  
  
  
  • !pip install bitsandbytes：安装bitsandbytes库。这是一个用于优化深度学习模型的库，特殊是在量化和内存优化方面。
    
  • !pip uninstall bitsandbytes：卸载bitsandbytes库。可能是为了重新安装特定版本或解决辩论。
    
  • !pip install bitsandbytes：重新安装bitsandbytes库。
    
  
  
• trl：
  
  
  
  • !pip install trl：安装trl（Transformer Reinforcement Learning）库。这是一个用于强化学习和Transformer模型结合的库。
    
  
  

  【在安装对应库时有可能出现的题目】

 在安装上述库时执行后期代码出现了版本辩论的题目，现给出执行中可能能资助解决的方案：

• bitsandbytes的卸载与重新安装：卸载了bitsandbytes，然后又重新安装了。为了解决版本辩论或确保安装的是正确的版本。
  
• torch的卸载与重新安装：卸载了torch、torchvision和torchaudio，然后通过指定CUDA版本的URL重新安装。为了确保安装的PyTorch版本与CUDA 12.4兼容。
  

 

1. !pip uninstall bitsandbytes
2. !pip uninstall torch torchvision torchaudio
3. !pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu124
4. !pip install bitsandbytes
5. !pip install --upgrade torch torchvision transformers

复制代码

 通过再执行这些代码后后期没有出现版本辩论的报错。
【2-加载预训练模型】

起首验证unsloth是否成功安装的代码：

1. from unsloth import FastLanguageModel
2. print("Unsloth installed successfully!")

复制代码

可以打印阐明已经成功安装，如果无法打印则阐明unsloth没有安装成功，重复上述的步调

 
验证成功后，选择一个根本模型，这里用 unsloth/DeepSeek-R1-Distill-Llama-8B：

1. # 导入 PyTorch 库，它是深度学习的基础框架，用于处理模型的张量计算和 GPU 加速。
2. import torch
3. # 导入 Unsloth 提供的 FastLanguageModel 类，用于加载和操作高效的大型语言模型。
4. from unsloth import FastLanguageModel
6. # 设置模型处理文本的最大序列长度（单位：token），这里设为 2048。
7. # 这决定了模型一次能处理的文本长度，越大越能捕捉长上下文，但也增加显存需求。
8. max_seq_length = 2048
10. # 设置模型的数据类型（dtype），这里设为 None 表示让 Unsloth 自动选择最优类型。
11. # 通常会根据硬件支持选择 float16 或 bfloat16，以平衡精度和性能。
12. dtype = None
14. # 启用 4 位量化加载模型，值为 True。
15. # 4 位量化可以将模型大小和显存需求减少约 75%，非常适合在资源有限的环境（如 Colab 免费版）运行。
16. load_in_4bit = True
18. # 从预训练模型库中加载指定的模型和对应的 tokenizer（分词器）。
19. # 返回两个对象：model（模型本身）和 tokenizer（用于将文本转为数字输入的工具）。
20. model, tokenizer = FastLanguageModel.from_pretrained(
21.     model_name="unsloth/DeepSeek-R1-Distill-Llama-8B",  # 指定模型名称，这里使用 Unsloth 优化的 DeepSeek-R1-Distill-Llama-8B。
22.     max_seq_length=max_seq_length,                      # 使用上面定义的最大序列长度。
23.     dtype=dtype,                                       # 使用上面定义的数据类型（自动选择）。
24.     load_in_4bit=load_in_4bit,                         # 启用 4 位量化加载。
25.     # token="hf_...",                                  # 如果需要访问私有模型，可以取消注释并填入 Hugging Face 的 API 令牌。
26. )

复制代码

【3-微调前测试】

先测试模型未经训练的表现：
这里调用推理模型举行推理，理想状态下，输出可能是泛泛而谈，微调后会更精准。但在本项目执行的时候微调结果不比微调前好，是因为训练集不够，暂时忽略这个题目。

1. # 定义提示模板（prompt_style），这是一个多行字符串，用于格式化输入和输出。
2. # 模板包含指令、问题和回答部分，设计目的是引导模型生成结构化的回答。
3. prompt_style = """以下是描述任务的指令，以及提供进一步上下文的输入。
4. 请写出一个适当完成请求的回答。
5. 在回答之前，请仔细思考问题，并创建一个逻辑连贯的思考过程，以确保回答准确无误。
7. ### 指令：
8. 你是一位精通医学知识的医生，能够回答关于疾病、治疗方案和健康建议的问题。
9. 请回答以下医疗问题。
11. ### 问题：
12. {}
14. ### 回答：
15. <think>{}"""
17. # 定义一个测试问题，用于在微调前检查模型的初始能力。
18. # 这里选择了一个常见的医疗问题，方便观察模型的表现。
19. question = "我最近总是感到疲劳，可能是什么原因？"
21. # 将模型切换到推理模式。
22. # FastLanguageModel.for_inference 是 Unsloth 提供的方法，优化模型以进行生成任务，避免训练时的额外开销。
23. FastLanguageModel.for_inference(model)
25. # 使用 tokenizer 将格式化的提示转换为模型可处理的数字输入。
26. # prompt_style.format(question, "") 将问题插入模板，思考部分暂时为空（留给模型生成）。
27. # return_tensors="pt" 表示返回 PyTorch 张量格式，to("cuda") 将数据移到 GPU 上加速处理。
28. inputs = tokenizer([prompt_style.format(question, "")], return_tensors="pt").to("cuda")
30. # 调用模型生成回答。
31. # input_ids 是编码后的输入序列，attention_mask 指示哪些部分需要关注，
32. # max_new_tokens=1200 限制生成最多 1200 个新 token，use_cache=True 启用缓存以加速生成。
33. outputs = model.generate(
34.     input_ids=inputs.input_ids,
35.     attention_mask=inputs.attention_mask,
36.     max_new_tokens=1200,
37.     use_cache=True,
38. )
40. # 将模型生成的数字输出解码为人类可读的文本。
41. # batch_decode 处理批量输出，这里取第一个（也是唯一一个）结果。
42. response = tokenizer.batch_decode(outputs)
44. # 打印生成的回答，展示模型在微调前的能力。
45. # response[0] 是解码后的完整文本，可能包含提示部分和生成的回答。
46. print(response[0])

复制代码

【4-加载与格式化数据集】

使用 shibing624/medical 中文医疗数据集：
在这里定义了一个叫做 train_prompt_style 的字符串模板，给模型的一份“任务阐明书”。
目的是告诉模型，它现在是一位精通医学知识的医生，必要回答医疗相干的题目。这个模板分为几个部门：起首，写一个总体的任务描述，提示模型要认真思考并给出准确的回答；接着，明确指令，设定模型的角色和任务；然后，用 {} 留了三个占位符，分别用来填入具体的题目、思考过程和最终的回答。如许，就能确保模型在训练时按照这个结构生成内容，比如先分析题目，再给出专业建议。如许设计既清晰又有逻辑，方便模型学习如何像医生一样思考和回应。

1. train_prompt_style = """以下是描述任务的指令，以及提供进一步上下文的输入。
2. 请写出一个适当完成请求的回答。
3. 在回答之前，请仔细思考问题，并创建一个逻辑连贯的思考过程，以确保回答准确无误。
5. ### 指令：
6. 你是一位精通医学知识的医生，能够回答关于疾病、治疗方案和健康建议的问题。
7. 请回答以下医疗问题。
9. ### 问题：
10. {}
12. ### 回答：
13. <思考>
14. {}
15. </思考>
16. {}"""

复制代码

在这段代码里主要是为了准备训练数据，让模型能理解和生成医疗相干的回答。
起首，定义一个竣事标记EOS_TOKEN，这是从分词器里拿来的，用来告诉模型每段文本到那里竣事。接着，从 datasets 库里导入了 load_dataset 函数，用它加载了一个医疗数据集 shibing624/medical，选了finetune 配置里的前 200 条训练数据。为了搞清晰数据长什么样，打印它的字段名，结果是 instruction、input 和 output。
然后，写一个函数 formatting_prompts_func，用来把这些数据格式化成想要的样子：从数据里抽出instruction 作为题目，input 作为思考过程，output 作为回答，再用之前定义的 train_prompt_style 模板把它们组合起来，加上竣事标记，最后存进一个列表里。
通过 dataset.map 方法，批量处理所有数据，最后输出第一条格式化后的文本，看看是不是按预期工作。这一步的目的是让数据酿成模型能直接学习的格式，确保训练顺遂举行。

1. # 定义结束标记（EOS_TOKEN），用于指示文本的结束
2. EOS_TOKEN = tokenizer.eos_token  # 必须添加结束标记
4. # 导入数据集加载函数
5. from datasets import load_dataset
6. # 加载指定的数据集，选择中文语言和训练集的前500条记录
7. dataset = load_dataset("shibing624/medical", 'finetune', split = "train[0:200]", trust_remote_code=True)
8. # 打印数据集的列名，查看数据集中有哪些字段
9. print(dataset.column_names)

复制代码

 格式化数据集中的记录，并且举行打印查看

1. # 定义一个函数，用于格式化数据集中的每条记录
2. def formatting_prompts_func(examples):
3.     # 从数据集中提取问题、复杂思考过程和回答
4.     inputs = examples["instruction"]
5.     cots = examples["input"]
6.     outputs = examples["output"]
7.     texts = []  # 用于存储格式化后的文本
8.     # 遍历每个问题、思考过程和回答，进行格式化
9.     for input, cot, output in zip(inputs, cots, outputs):
10.         # 使用字符串模板插入数据，并加上结束标记
11.         text = train_prompt_style.format(input, cot, output) + EOS_TOKEN
12.         texts.append(text)  # 将格式化后的文本添加到列表中
13.     return {
14.         "text": texts,  # 返回包含所有格式化文本的字典
15.     }
17. dataset = dataset.map(formatting_prompts_func, batched = True)
18. dataset["text"][0]

复制代码

 【5-执行微调训练】

 配置 LoRA 并开始训练：
训练约需实践视数据量而定。

1. # 将模型切换到训练模式。
2. # FastLanguageModel.for_training 是 Unsloth 提供的方法，确保模型准备好进行参数更新，而不是仅用于推理。
3. FastLanguageModel.for_training(model)
5. # 配置并返回一个支持参数高效微调（PEFT）的模型。
6. # get_peft_model 使用 LoRA 技术，只更新模型的部分参数，从而减少显存需求和计算开销。
7. model = FastLanguageModel.get_peft_model(
8.     model,  # 传入之前加载的预训练模型，作为微调的基础。
9.     r=16,   # 设置 LoRA 的秩（rank），控制新增可训练参数的规模。值越大，模型调整能力越强，但显存需求也增加。
10.     target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
11.             # 指定需要应用 LoRA 的模型模块，这些是 Transformer 架构中的关键部分（如注意力机制和前馈网络）。
12.     lora_alpha=16,
13.             # LoRA 的缩放因子，影响新增参数对模型的贡献程度。通常与 r 成比例设置，这里为 16。
14.     lora_dropout=0,
15.             # 设置 LoRA 层的 dropout 比率，用于防止过拟合。这里设为 0，表示不丢弃任何参数。
16.     bias="none",
17.             # 指定是否为 LoRA 参数添加偏置项。"none" 表示不添加，保持轻量化。
18.     use_gradient_checkpointing="unsloth",
19.             # 启用梯度检查点技术，Unsloth 优化版本能节省显存，支持更大的批量大小或模型。
20.     random_state=3407,
21.             # 设置随机种子，确保每次运行时模型初始化的随机性一致，便于结果复现。
22.     use_rslora=False,
23.             # 是否使用 Rank-Stabilized LoRA（一种改进的 LoRA 变体）。这里设为 False，使用标准 LoRA。
24.     loftq_config=None,
25.             # 设置是否使用 LoftQ（一种量化技术）。这里设为 None，表示不启用。
26. )

复制代码

 

80次的训练步数完成后，unsloth会给出模型训练中的关键信息：
   TrainOutput(global_step=80, training_loss=0.4147318692877889, metrics={'train_runtime': 862.1409, 'train_samples_per_second': 0.742, 'train_steps_per_second': 0.093, 'total_flos': 1.1264877371523072e+16, 'train_loss': 0.4147318692877889})
   即：

• 训练进度：已经完成了80个训练步调。
  
• 训练性能：均匀损失值为0.4147，训练过程耗时约862秒。
  
• 服从指标：每秒处理约0.742个样本，每秒完成约0.093个训练步调，统共执行了约1.13×10¹⁶次浮点运算。
  

1. # 导入 SFTTrainer 类，用于监督微调训练。
2. # SFTTrainer 是 TRL（Transformers Reinforcement Learning）库提供的工具，适合基于指令的数据集微调模型。
3. from trl import SFTTrainer
5. # 导入 TrainingArguments 类，用于定义训练的超参数。
6. # 这是 Hugging Face Transformers 库的核心类，允许灵活配置训练过程。
7. from transformers import TrainingArguments
9. # 导入 Unsloth 提供的函数，用于检查硬件是否支持 bfloat16 数据类型。
10. # bfloat16 是一种高效的半精度格式，能在支持的硬件上加速训练。
11. from unsloth import is_bfloat16_supported
13. # 创建 SFTTrainer 实例，配置训练所需的模型、数据和参数。
14. trainer = SFTTrainer(
15.     model=model,                    # 传入之前配置好的模型（已启用 LoRA）。
16.     tokenizer=tokenizer,                # 传入与模型配套的分词器，用于处理文本数据。
17.     train_dataset=dataset,               # 传入训练数据集（已格式化为包含 "text" 字段）。
18.     dataset_text_field="text",             # 指定数据集中包含训练文本的字段名，这里是 "text"。
19.     max_seq_length=max_seq_length,           # 设置最大序列长度，与模型加载时保持一致（如 2048）。
20.     dataset_num_proc=2,                # 设置数据处理的并行进程数，加速数据预处理。
21.     packing=False,                   # 是否启用序列打包。False 表示不打包，每条数据独立处理。
22.     args=TrainingArguments(              # 定义训练超参数的配置对象。
23.         per_device_train_batch_size=2,       # 每个设备（GPU）的批次大小，设为 2 以适应显存限制。
24.         gradient_accumulation_steps=4,       # 梯度累积步数，累积 4 次小批次后更新参数，模拟大批量训练。
25.         warmup_steps=5,              # 预热步数，学习率在前 5 步逐渐增加，稳定训练。
26.         max_steps=80,               # 最大训练步数，控制训练时长（步数 = 数据量 / 批次大小）。
27.         learning_rate=2e-4,            # 学习率，设为 0.0002，控制参数更新速度。
28.         fp16=not is_bfloat16_supported(),    # 如果不支持 bfloat16，则使用 fp16（16 位浮点数）加速训练。
29.         bf16=is_bfloat16_supported(),       # 如果硬件支持 bfloat16，则启用它，兼顾精度和速度。
30.         logging_steps=1,              # 每 1 步记录一次训练日志，方便监控损失变化。
31.         optim="adamw_8bit",            # 使用 8 位 AdamW 优化器，节省显存并保持性能。
32.         weight_decay=0.01,             # 权重衰减系数，设为 0.01，防止模型过拟合。
33.         lr_scheduler_type="linear",        # 学习率调度器类型，"linear" 表示线性衰减。
34.         seed=3407,                 # 随机种子，确保训练结果可复现。
35.         output_dir="outputs",            # 训练结果（如检查点）保存的目录。
36.         report_to="none",              # 不将训练日志报告到外部工具（如 WandB），仅本地记录。
37.     ),
38. )
40. # 开始训练模型。
41. # trainer.train() 执行微调过程，根据配置更新模型参数，完成后保存到 output_dir。
42. trainer.train()

复制代码

【6-微调后测试】

用相同题目测试结果：
理想状态下，回答更贴近医疗专业知识。

给出的复兴是：
   我最近总是感到疲劳，可能是什么原因？ <｜begin▁of▁sentence｜>以下是描述任务的指令，以及提供进一步上下文的输入。 请写出一个恰当完成哀求的回答。 在回答之前，请仔细思考题目，并创建一个逻辑连贯的思考过程，以确保回答准确无误。 ### 指令： 你是一位精通医学知识的医生，能够回答关于疾病、治疗方案和康健建议的题目。 请回答以下医疗题目。 ### 题目： 我最近总是感到疲劳，可能是什么原因？ ### 回答： <think>스테因素不敷引起的疲劳感多为神经因素性疲劳，主要表现为满身肌肉无力、四肢乏力、深度脑性疲劳、脑力劳动者、恒久性肥胖、糖尿病、2型糖尿病、胰岛 B 细胞突变导致的糖尿病也可以引起的疲劳感。多发于中青年群体，少见于老年群体。<｜end▁of▁sentence｜>

1. print(question) # 打印前面的问题
2. # 将模型切换到推理模式，准备回答问题
3. FastLanguageModel.for_inference(model)
5. # 将问题转换成模型能理解的格式，并发送到 GPU 上
6. inputs = tokenizer([prompt_style.format(question, "")], return_tensors="pt").to("cuda")
8. # 让模型根据问题生成回答，最多生成 4000 个新词
9. outputs = model.generate(
10.     input_ids=inputs.input_ids,       # 输入的数字序列
11.     attention_mask=inputs.attention_mask,  # 注意力遮罩，帮助模型理解哪些部分重要
12.     max_new_tokens=4000,          # 最多生成 4000 个新词
13.     use_cache=True,            # 使用缓存加速生成
14. )
16. # 将生成的回答从数字转换回文字
17. response = tokenizer.batch_decode(outputs)
19. # 打印回答
20. print(response[0])

复制代码

到此， 微调项目执行完成。
当前因为训练的数据集很少，最后输出的回答结果并不好，后期必要加大数据量等。
理想状态下，最终的输出模式应该是如下图所示： 

【7-导出微调后的模型-可选】

将微调后的模型保存为 GGUF 格式

GGUF，全称是 GPT-Generated Unified Format（GPT 生成的同一格式），是一种专门为存储和部署大型语言模型（LLM）设计的文件格式。简单来说，它就像一个“打包盒”，把模型的所有必要信息都装在一起，比如模型的权重（参数）、分词器（tokenizer）信息、超参数（hyperparameters）和元数据（metadata），全都压缩成一个二进制文件。如许做的好处是方便高效地加载和运行模型，尤其是在本地设备上。
执行前我们必要先在Colab中配置token的环境变量

1. # 导入 Google Colab 的 userdata 模块，用于访问用户数据
2. from google.colab import userdata
4. # 从 Google Colab 用户数据中获取 Hugging Face 的 API 令牌
5. HUGGINGFACE_TOKEN = userdata.get('HUGGINGFACE_TOKEN')
7. # 将模型保存为 8 位量化格式（Q8_0）
8. # 这种格式文件小且运行快，适合部署到资源受限的设备
9. if True: model.save_pretrained_gguf("model", tokenizer,)
11. # 将模型保存为 16 位量化格式（f16）
12. # 16 位量化精度更高，但文件稍大
13. if False: model.save_pretrained_gguf("model_f16", tokenizer, quantization_method = "f16")
15. # 将模型保存为 4 位量化格式（q4_k_m）
16. # 4 位量化文件最小，但精度可能稍低
17. if False: model.save_pretrained_gguf("model", tokenizer, quantization_method = "q4_k_m")

复制代码

配置HUGGINGFACE_TOKEN的环境变量

起首我们先获取到Huggingface的token

将微调后的模型上传到 HuggingFace

1. # 导入 Hugging Face Hub 的 create_repo 函数，用于创建一个新的模型仓库
2. from huggingface_hub import create_repo
4. # 在 Hugging Face Hub 上创建一个新的模型仓库
5. create_repo("xiongwenhao/medical_finetuned", token=HUGGINGFACE_TOKEN, exist_ok=True)
7. # 将模型和分词器上传到 Hugging Face Hub 上的仓库
8. model.push_to_hub_gguf("xiongwenhao/medical_finetuned", tokenizer, token=HUGGINGFACE_TOKEN)

复制代码

使用Ollama运行微调后的模型

1. ollama run hf.co/{用户名}/{上传到HuggingFace的模型名称}
2. 示例：ollama run hf.co/xiongwenhao/medical_finetuned

复制代码

注：本人在第7步保存和导出模型没有测试成功，参考项目见“参考资料”中的地址，本文在这一步仅作为存档，以免后续必要使用时原帖失效。 

【参考资料】

[1] 轻松微调大模型：使用 Colab 和 Unsloth 实现高效训练：https://blog.csdn.net/weixin_66401877/article/details/145892615

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。