大型语言模型 （LLM） 凭借其卓越的生成能力正在为各种产品寻找出路，我们看到新的应用程序如雨后春笋般涌现。这些是通用工具，通常缺乏特定领域的知识，这在一定程度上降低了它们的影响。这些有用的领域知识可能隐藏在不同的企业存储库中。

使用您的域数据微调自定义 LLM 可能有助于弥合这一差距。这一过程的一个关键步骤是数据准备。这是关键的一步，因为这些数据的质量将显著影响微调模型的性能。尝试手动管理这样的数据集可能是一项昂贵且非常耗时的工作。

在本文中，我们将探索一种经济高效的替代方案，以使用 Mistral 7B Instruct 模型从内部文档自动创建指令和训练数据集。我们将采用一种新颖的指令生成方法，以确保全面覆盖您的领域。Mistral 7B 还将用于检索增强生成 （RAG） 设置以生成训练数据集。一旦我们有了训练数据集，我们将调用 MLX 框架库来帮助使用此数据集对 Mistral 7B 进行实际微调，以丰富我们的本地领域知识。

由于我们将探讨从指令生成到模型微调的端到端工作流程，因此这里有很多内容需要介绍。让我们开始吧！

目录

1.0 关键使能技术概述
2.0 设计与实现
2.1 指令生成
2.2 训练数据集生成
2.3 函数主
3.0 指令生成运行
4.0 训练数据集生成运行
5.0 使用 MLX
进行微调 6.0 模型验证
7.0 最后的思考

1.0 关键使能技术概述

这项工作将在只有 1GB RAM 的 MacBook Air M8 上进行。由于其计算和内存资源相当有限，我们采用了 Mistral 7B Instruct v0.1 模型的 4 位量化版本。为了以 GGUF 格式加载这样的量化模型，我们将使用库，它是库的 Python 绑定。llama-cpp-pythonllama.cpp

faiss-cpu是一个使用 CPU 对密集向量进行高效相似性搜索和聚类的库。对于训练数据生成，我们将采用 RAG 技术。RAG 应用程序由一个检索器系统组成，用于从 FAISS 矢量存储中获取相关文档片段，以及一个 LLM，用于使用检索到的片段作为上下文生成响应。我们之前在早期的工作中已经证明，这是一个很好的选择[1]。它根据互惠秩融合算法对所选检索器列表的结果进行集成和重新排序。我们将以 0.3：0.7 的比例将 BM25 猎犬和 FAISS 猎犬组合在一起。EnsembleRetriever

最后一项关键技术与微调有关。MLX 框架 [2] 库都提供了帮助微调的工具。后者利用 Apple 芯片提供硬件加速，这使得在 Mac 上进行微调变得轻而易举。因此，我们将在这里采用 MLX。llama.cpp

现在，我们已准备好准备我们的开发环境。让我们创建一个虚拟环境来管理这个项目。若要创建和激活环境，让我们运行以下命令：

python3.10 -m venv llm_tuning
source llm_tuning/bin/activate

接下来，继续安装所有必需的库：

pip install langchain faiss-cpu sentence-transformers flask-sqlalchemy psutil unstructured pdf2image unstructured_inference pillow_heif opencv-python pikepdf pypdf
pip install mlx
CMAKE_ARGS="-DLLAMA_METAL=on" FORCE_CMAKE=1 pip install --upgrade --force-reinstall llama-cpp-python --no-cache-dir

上面的最后一行涉及安装支持 Metal 的库，该库将用于在 M1 处理器上加载具有硬件加速的量化 Mistral 7B。使用 Metal，计算在 GPU 上运行。llama-cpp-python

既然我们已经准备好了环境，那么让我们看一下系统设计，然后看一下它的实现。

2.0 设计与实现

数据集生成系统有两个模块，如图 1 所示。

该模块涉及加载最近（2023 年 12 月）发布的 440 页的 IT 供应商部署指南。它还处理文档拆分和矢量化，以及 BM25 检索器的实例化。这个模块相当简单，在我们之前的工作中已经介绍过，并按此处使用[1]。LoadVectorize

第二个模块包括两个关键功能。第一个涉及指令生成，它涉及使用 QA 链在文档块列表的上下文中生成指令。第二个函数涉及实例化 Ensemble 检索器，然后创建一个 QA 链，以针对具有 Ensemble 检索器上下文的指令列表进行调用。

现在让我们深入看一下第二个模块。

2.1 指令生成

对于这个端到端的工作流程，我们使用一个关于 Riverbed SteelHead（一种应用加速解决方案）的 400+ 页示例 pdf 文档作为语言模型要获取的领域知识。作为第一步，我们将使用 Mistral 7B 作为语言模型生成与本文档相关的指令（或提示）。

这里的关键设计挑战是 LLM 如何知道要为一个尚未精通的领域生成哪些指令。对于任何内部文件来说，这将是一个共同的挑战。作为矢量化步骤的一部分，FAISS 矢量存储引用了文档块，这些块共同构成了领域知识。这个指令生成函数的主要思想是使用 LLM 生成指令，每个块单独作为其上下文。为了确保这些指令在一个块中提供对知识的全面覆盖，理想情况下，我们应该针对每个文档块生成指令。指令的数量应与采用的文档块大小成正比。出于演示目的，由于时间和平台资源限制，我们将在此处为 100 个随机文档块生成两个问题。

要访问文档块，请从 FAISS 对象和表示所有文档块的列表中获取对象。在每次迭代中，我们都会找到相关的文档块，并将其用作查询 QA 链的上下文。docstoredocstore_id

生成此指令的提示是：

请根据提供的上下文生成两个关于 SteelHead 的问题。这个问题应该只围绕 SteelHead 广域网加速及其相关概念。问题应从以下任一部分开始：“什么”、“如何”、“有”、“有”、“是什么”、“我该怎么做”、“什么时候”、“SteelHead 有吗”、“如何”、“有什么区别”、“哪个”、“列表”。您不需要为每个问题提供答案或类别。

通过遍历每个选定的文档块，我们调用 QA 链，并将块作为上下文和上述提示。为了作为进度，生成的指令将显示在控制台上，并显示所花费的时间。生成的指令将保存到文件 。作为生成进度，将在每次迭代时显示当前问题编号和花费的时间。有了这种理解，下面的清单捕获了函数 的代码。instructions.txtgenerate_instructions

def generate_instructions(db,QA_PROMPT,llm) -> None:
    output_parser = StrOutputParser()
# Custom QA Chain
    chain = (
        {"context": RunnablePassthrough() , "question": RunnablePassthrough()}
        | QA_PROMPT
        | llm
        | output_parser
        )

# access docstore and docstore id for 100 random chunks
    vs = db.__dict__.get("docstore")
    docstore_id_list = list(db.__dict__.get("index_to_docstore_id").values())
    rand_doc_id_list = random.choices(docstore_id_list, k=200)

    query = '''
    Please generate two questions about SteelHead based on the provided context. The question should be around SteelHead WAN acceleration and its related concepts only. The questions should start with any of the following: "What", "How', "Is there a", "What are the", "How do I", "When is it", "Does SteelHead have", "How to", "What is the difference", "Which", "List". You do not need to provide an answer or category to each question.
    '''
    qfile = open("instructions.txt", "w")
    start_gen = timeit.default_timer()
for i,doc_id in enumerate(rand_doc_id_list):
        start = timeit.default_timer()
        a_doc = vs.search(doc_id)
        result = chain.invoke({"question": query, "context": a_doc.page_content})
        resp_time = timeit.default_timer() - start # seconds
print(f'{"-"*50}\nQ #{i}: {result}\nTime: {resp_time}\n{"-"*50}\n')
        qfile.write(result)
    qfile.close()
# total time for generation
    gen_time = timeit.default_timer() - start_gen # seconds
print(f'Total generation time => {timedelta(seconds=gen_time)}')

现在让我们看一下这个模块的第二个关键功能。

2.2 训练数据集生成

获得说明后，我们现在可以继续生成训练数据集。和以前一样，Mistral 7B 被用作 LLM，但这次是在 RAG 设置中。我们将使用 FAISS 最大边际相关性 （MMR） 和 BM25 检索器。我们之前已经表明，0.3：0.7 的比率实现了此猎犬列表的最佳准确性性能。EnsembleRetriever

通过迭代说明，我们向 LLM 查询答案，并使用它来生成以下格式的 JSON 字符串：

<s>[INST] {instruction}[/INST] {answer}</s>

一旦我们有了训练数据集，该数据集的 80% 将用于训练并存储在 .剩余的 20% 数据集将用于验证并存储为 .以下列表将上述过程捕获为函数。train.jsonlvalid.jsonlgenerate_training

def generate_training(db,bm25_r,QA_PROMPT,llm) -> None:
# create retrievers
    faiss_retriever = db.as_retriever(search_type="mmr", search_kwargs={'fetch_k': 3}, max_tokens_limit=1000)
    ensemble_retriever = EnsembleRetriever(retrievers=[bm25_r,faiss_retriever],weights=[0.3,0.7])
    output_parser = StrOutputParser()
# Custom QA Chain
    chain = (
        {"context": ensemble_retriever | format_docs, "question": RunnablePassthrough()}
        | QA_PROMPT
        | llm
        | output_parser
        )
with open('instructions.txt') as tfile:
        instructions = tfile.readlines()
    start_t_gen = timeit.default_timer()
    train_lines = list()
for i, instruction in enumerate(instructions, start=1):
print(f"Handling ({i}/{len(instructions)}):")
        start = timeit.default_timer()
try:
            answer = chain.invoke(instruction)
except Exception as e:
# skip questions that can't be answered by LLM
print(f'FAILED for => {e}')
continue
        resp_time = timeit.default_timer() - start # seconds
print(f'{"-"*50}\nQ #{i}: {instruction}\nA:{answer}\nTime: {resp_time}\n{"-"*50}\n')
        result = json.dumps({
'text': f'<s>[INST] {instruction}[/INST] {answer}</s>'
        }) + "\n"
# write to a temp file
with open('train_valid.jsonl', 'a') as file:
            file.write(result)
        train_lines.append(result)
    gen_time = timeit.default_timer() - start_t_gen # seconds
with open('train.jsonl', 'w') as file:
        file.writelines(train_lines[:int(len(train_lines) * 0.2)])
with open('valid.jsonl', 'w') as file:
        file.writelines(train_lines[int(len(train_lines) * 0.2):])
print(f'Total training generation time => {timedelta(seconds=gen_time)}')

要调用上述任何一个关键函数，我们将使用如下所述的函数。main

2.3 功能main

在此函数中，实例化了两个函数使用的许多公共对象。首先，定义提示模板。然后使用 加载 GGUF 格式的量化 4 位 Mistral 7B Instruct 模型。接下来，对 pdf 文档进行矢量化，并获取对其 FAISS 对象的引用以及 BM25 检索器。LlamaCpp

为了允许轻松调用任一生成函数，让我们使用命令行选项。函数最多接受两个布尔参数，这些参数将由提供的命令行选项控制。要决定要启动的指令或训练数据集生成任务，命令行选项 or 将分别与库一起使用。main-i-targparse

以下列表捕获了这些命令行选项处理以及函数。main

def main(is_gen_instruct=False,is_gen_training=False):
# Prompt template 
    qa_template = """<s>[INST] You are a helpful assistant.
    Use the following context to answer the question below accurately and concisely:
    {context}
    [/INST] </s>{question}
    """

# Create a prompt instance 
    QA_PROMPT = PromptTemplate.from_template(qa_template)

    llm = LlamaCpp(
        model_path="./models/mistral_7b_gguf/mistral-7b-instruct-v0.1.Q2_K.gguf",
        temperature=0.01,
        max_tokens=2000,
        top_p=1,
        verbose=False,
        n_ctx=3000
    )
    db,bm25_r = LoadVectorize.load_db()
if is_gen_instruct:
        generate_instructions(db,QA_PROMPT,llm) 
elif is_gen_training:
        generate_training(db,bm25_r,QA_PROMPT,llm) 

if __name__ == "__main__":
# Initialize parser
    parser = argparse.ArgumentParser("Script to generate instruction or training data for LLM fine-tuning")
    group = parser.add_mutually_exclusive_group()

# Adding optional mutually-exclusive arguments
    group.add_argument("-i", "--instructions", action='store_true', help = "Generate Instructions")
    group.add_argument("-t", "--training", action='store_true', help = "Generate Training and Validation Data")

# Read arguments from command line
    args = parser.parse_args()
if args.instructions:
        main(is_gen_instruct=args.instructions)
elif args.training:
        main(is_gen_training=args.training)

这样就完成了数据生成系统的实现。此系统的完整代码可在以下 GitHub 存储库中找到：

https://github.com/drskennedy/instruction_gen

现在就让我们去兜风吧！

3.0 指令生成运行

在本练习中，将使用命令行选项启动代码以启动指令生成过程。以下控制台输出数据提取表示生成 200 个问题的运行。整个过程在我的 Mac 上只花了 2 个多小时。-i

$ python main.py -i

--------------------------------------------------
Q #0: 
1. Where do I find the QoS settings in SteelHead?
2. Is there a difference between MX-TCP and TCP in terms of handling packet loss?
Time: 57.88847145799991
--------------------------------------------------

--------------------------------------------------
Q #1: 
1. Where do I find information about configuring SSL on SteelHead?
2. Is there a requirement for a trust relationship between Client Accelerators for SSL configuration on SteelHead?
Time: 47.30005858300001
--------------------------------------------------

--------------------------------------------------
Q #2: 
1. Where is the configuration for enabling Connection Forwarding between SteelHeads in a cluster?
2. Is there a difference between using multiple interfaces on the same SteelHead versus using multiple SteelHeads for ITD high availability deployment?
Time: 70.70811329100025
--------------------------------------------------

--------------------------------------------------
Q #3: 
1. Where do I enable CDP on the SteelHead that is used in the PBR deployment?
2. Is there a specific command that I need to use to enable CDP on the SteelHead?
Time: 68.81058954199989
--------------------------------------------------
...

Q #99: 
1. What is correct addressing in the context of SteelHead WAN acceleration?
2. How does correct addressing enable connection pooling acceleration in SteelHead?
Time: 63.51242004099913
--------------------------------------------------

Total generation time => 2:06:10.565294

查看生成的指令，生成了许多好问题。还有一些“我在哪里可以找到”的问题，我觉得这些问题对于帮助获取领域知识没有用处。因此，所有这些问题都已从列表中删除。在很多情况下，某些文档块的两个问题几乎相同，并且删除了此类重复项。最后，还有一些不准确或无意义的问题。经过所有这些修整，还剩下 150 个好问题。此外，问题有编号和其他意想不到的格式，需要调整。这清楚地表明需要人工干预以确保下一个任务的数据质量。

说明准备就绪后，让我们继续生成训练数据集。

4.0 训练数据集生成运行

现在，使用命令行选项启动相同的脚本，以启动训练和验证数据集生成。在我资源有限的机器上，这需要很长时间。幸运的是，控制台输出很好地了解了其通过指令列表的进度。由于在运行过程中会产生大量热量，我不得不将 Mac 部分悬浮在空气中以改善其冷却效果。以下是此运行的控制台输出提取：-t

$ python main.py -t

Handling (1/150):
--------------------------------------------------
Q #1: Is there a difference between MX-TCP and TCP in terms of handling packet loss?
A:
Yes, there is a difference between MX-TCP and TCP in terms of handling packet loss. MX-TCP is designed to handle packet loss without a decrease in throughput, while TCP typically experiences a decrease in throughput when there is packet loss. MX-TCP effectively handles packet loss without error correction packets over the WAN through forward error correction (FEC).
Time: 152.08327770899996

Handling (2/150):
--------------------------------------------------
Q #2: Where is the configuration for enabling Connection Forwarding between SteelHeads in a cluster?
A:
To enable Connection Forwarding between SteelHeads in a cluster, you need to configure the in-path0_0 IP address of the two SteelHeads as neighbors in the CLI of each SteelHead. Then, you can enter the following commands in each SteelHead's CLI:

enable
configure terminal
SteelHead communication enable
SteelHead communication multi-interface enable
SteelHead name <SteelHead name> main-ip <SteelHead IP address>

Once you have enabled Connection Forwarding, you can configure fail-to-block and allow-failure commands to provide greater resiliency and redundancy in your ITD deployment.
Time: 215.70585895799923

Handling (3/150):
--------------------------------------------------
Q #3: Is there a difference between using multiple interfaces on the same SteelHead versus using multiple SteelHeads for ITD high availability deployment?
A:
Yes, there is a difference between using multiple interfaces on the same SteelHead versus using multiple SteelHeads for ITD high availability deployment. Using multiple interfaces on the same SteelHead can provide greater acceleration throughput capacity beyond a single SteelHead, but it may not provide the same level of redundancy or resiliency as using multiple SteelHeads. On the other hand, using multiple SteelHeads can provide greater redundancy and resiliency, but it may not provide the same level of acceleration throughput capacity as using multiple interfaces on the same SteelHead.
Time: 179.73986179200074

...

Handling (150/150):
--------------------------------------------------
Q #150: How does correct addressing enable connection pooling acceleration in SteelHead?

A:

Correct addressing enables connection pooling acceleration in SteelHead by allowing it to create several TCP connections between each other before they are needed. This is because correct addressing uses specific values in the TCP/IP packet headers, which allows SteelHeads to detect what types of client and server IP addresses and ports are needed. When transparent addressing is enabled, SteelHeads cannot create the TCP connections in advance because they cannot detect what types of client and server IP addresses and ports are needed. If the number of connections that you want to accelerate exceeds the limit of the SteelHead model, the excess connections are passed through unaccelerated by the SteelHead.
Time: 159.28865737500018
--------------------------------------------------


Total training generation time => 9:20:06.321521

这个训练数据集的生成花了 9 个多小时！对于其中一些指令，语言模型无法生成任何答案。为了便于全面覆盖包含 1,200 多个块的所选文档，它可能需要 2,000 多条指令，这显然需要很多天才能完成运行。话虽如此，只有我的 Mac 在训练生成期间持续高温下幸存下来，才有可能！为了演示整个端到端过程，接下来我们将对有限的训练数据集进行微调。

5.0 使用 MLX 进行微调

MLX是一个用于在Apple Silicon上进行机器学习研究的阵列框架[2]。它可用于文本生成和对 Llama、Mistral 和 TinyLlama 等 LLM 进行微调。为了进行微调，模型需要采用 MLX 识别格式，这意味着我们不能使用之前使用的 GGUF 版本。MLX 提供了许多脚本来协助整个工作流，作为 mlx-examples Github 存储库的一部分。让我们在生成系统的目录中克隆 MLX 示例存储库，如下所示：

$ git clone https://github.com/ml-explore/mlx-examples.git

要从 HuggingFace 下载 Mistral 7B 并量化为 4 位模型，我们可以使用脚本。默认情况下，此脚本将 HuggingFace 存储库作为输入，并将结果输出到目录mlx_model。下面是一个示例运行输出：convert.py

$ python mlx-examples/lora/convert.py --hf-path mistralai/Mistral-7B-Instruct-v0.1 -q
[INFO] Loading
model-00003-of-00003.safetensors: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4.54G/4.54G [33:52<00:00, 2.23MB/s]
model-00001-of-00003.safetensors: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4.94G/4.94G [36:15<00:00, 2.27MB/s]
model-00002-of-00003.safetensors: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5.00G/5.00G [36:23<00:00, 2.29MB/s]
Fetching 11 files: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 11/11 [36:24<00:00, 198.60s/it]
[INFO] Quantizing003.safetensors: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5.00G/5.00G [36:23<00:00, 6.05MB/s]

$ ls mlx_model 
config.json  model.safetensors special_tokens_map.json tokenizer.json  tokenizer.model  tokenizer_config.json

目录mlx_model列表显示此运行的结果。

现在，我们已准备好使用上一节中的训练数据集对模型进行微调。MLX 通过 LoRA 支持参数高效微调 （PEFT），专注于更新模型参数的子集。它通常涉及冻结模型的某些层或部分。这种方法自然会带来更快的微调。此外，MLX 在量化模型上使用 QLoRA。

脚本将在这里帮助我们。当它检测到模型被量化时，此脚本会自动切换为使用 QLoRA。Option 用于指定包含训练和验证数据集的目录。选项用于设置要微调的层数。and option 指定要训练的迭代次数。还有其他可选设置，例如学习速率和采样温度，可用于控制微调。只需运行带有选项的脚本即可获得完整的帮助列表。lora.py--data--lora-layers--iters-h

以下控制台输出显示了我们模型的微调运行，在我的 Mac 上大约花了 40 分钟：

$ python mlx-examples/lora/lora.py \
  --train \
  --model ./mlx_model \
  --data ./ \
  --batch-size 1 \
  --lora-layers 2 \
  --iters 1000
Loading pretrained model
Total parameters 1242.550M
Trainable parameters 0.213M
Loading datasets
Training
Iter 1: Val loss 3.565, Val took 32.649s
Iter 10: Train loss 3.008, It/sec 0.401, Tokens/sec 80.419
Iter 20: Train loss 3.195, It/sec 0.358, Tokens/sec 75.043
Iter 30: Train loss 2.830, It/sec 0.425, Tokens/sec 72.879
Iter 40: Train loss 2.817, It/sec 0.456, Tokens/sec 71.241
Iter 50: Train loss 2.235, It/sec 0.328, Tokens/sec 73.343
Iter 60: Train loss 2.383, It/sec 0.337, Tokens/sec 74.361
Iter 70: Train loss 2.249, It/sec 0.371, Tokens/sec 74.073
Iter 80: Train loss 2.353, It/sec 0.342, Tokens/sec 72.922
Iter 90: Train loss 2.027, It/sec 0.413, Tokens/sec 74.373
Iter 100: Train loss 2.091, It/sec 0.362, Tokens/sec 74.554
Iter 100: Saved adapter weights to adapters.npz.
...
Iter 200: Train loss 1.955, It/sec 0.395, Tokens/sec 74.250
Iter 200: Val loss 1.893, Val took 31.658s
Iter 200: Saved adapter weights to adapters.npz.
Iter 210: Train loss 1.695, It/sec 0.324, Tokens/sec 75.333
Iter 220: Train loss 1.856, It/sec 0.420, Tokens/sec 71.344
...
ter 600: Train loss 1.584, It/sec 0.330, Tokens/sec 67.831
Iter 600: Val loss 1.771, Val took 35.813s
Iter 600: Saved adapter weights to adapters.npz.
Iter 610: Train loss 1.487, It/sec 0.368, Tokens/sec 64.815
...
Iter 990: Train loss 1.503, It/sec 0.437, Tokens/sec 71.288
Iter 1000: Train loss 1.511, It/sec 0.361, Tokens/sec 74.861
Iter 1000: Val loss 1.777, Val took 31.679s
Iter 1000: Saved adapter weights to adapters.npz.

从训练开始时的 3.008 损失，在最后一次迭代期间下降到 1.511。默认情况下，模型每 100 次迭代保存一次。由于我的机器上的资源限制，使用两个以上的 lora 层会导致系统内存不足。但是，如果您的机器具有更大的 RAM，请随意尝试更多层数。

微调完成后，默认情况下，生成的模型将保存为当前目录中的 adapters.npz。如果您想将更改合并到基本模型中，MLX 脚本可以帮助我们。您可以将融合的模型本地保存在磁盘上，甚至可以推送到选定的 HuggingFace 存储库。以下执行会将模型保存到本地目录 ./models/mistral7b：fuse.pyfuse.py

$ python mlx-examples/lora/fuse.py --model ./mlx_model  --adapter-file ./adapters.npz --save-path ./models/mistral7b
Loading pretrained model

由于我们的训练数据集相当有限，我决定不合并。现在，我们准备进行模型验证。

6.0 模型验证

为了测试模型的生成能力，我们仍然可以使用脚本。以下是其生成的基本用法：lora.py

$ python mlx-examples/lora/lora.py --model ./mlx_model \
    --max-tokens 1000 \
    --prompt 'What is the purpose of SteelHead path selection?'

为了了解微调对 LLM 的帮助，我们可以对基础进行生成测试，也可以对微调模型进行比较。下面显示了两种模型的生成：

### Base Model Testing

$ python mlx-examples/lora/lora.py --model ./mlx_model --max-tokens 1000 --prompt 'What is the purpose of SteelHead path selection?'   
Loading pretrained model
Total parameters 1244.041M
Trainable parameters 1.704M
Loading datasets
Generating
What is the purpose of SteelHead path selection?

The purpose of the path selection feature in a WAN optimization solution is to reduce the amount of data that is transmitted over the network by minimizing the number of round-trips between the data source and the client. This is achieved by minimizing the number of round-trips required for data to be transmitted, as each round-trip takes time and represents additional network traffic...
==========

### Fine-Tuned Model

$ python mlx-examples/lora/lora.py --model ./mlx_model --adapter-file ./adapters.npz --max-tokens 1000 --prompt 'What is the purpose of SteelHead path selection?'
Loading pretrained model
Total parameters 1244.041M
Trainable parameters 1.704M
Loading datasets
Generating
What is the purpose of SteelHead path selection?

The purpose of the network path selection feature is to selectively choose the most efficient path between two locations based on SaaS application traffic. SteelHead network path selection allows network traffic to use a specific path, either a network path or a WAN path connection, to access a specific application, and can prioritize traffic to ensure network performance. This feature is particularly beneficial in environments where multiple paths are available, such as multiple WAN links, MPLS connections, and LANs.

微调模型测试涉及使用附加选项和适配器文件名运行 lora.py。除此之外，其他一切都是一样的。--adapter-file

为了便于比较，表1描述了比较基础模型和微调模型的两次此类生成运行的结果。两个查询的基本模型的答案都不正确。微调模型的答案几乎是正确的，但仍存在一些不准确之处。即便如此，通过对相对较小的训练数据集进行微调，我们的微调模型仍然能够很好地学习。

7.0 最后的思考

LLM 在公共领域覆盖面广的区域具有出色的生成能力。然而，在不同的企业存储库中隐藏着许多领域知识，等待着被挖掘。

在本文中，我们介绍了一种指令生成方法，其中使用 Mistral 7B 为每个文档块生成一定数量的指令，以确保文档的全面覆盖。为了生成训练数据集，我们再次在带有集成检索器的 RAG 设置中使用了 Mistral 7B。然后，我们使用该数据集使用库 MLX 和 QLoRA 技术进行微调，其中库针对 Apple 芯片进行了优化。即使训练数据集相对较小，也有望看到LLM获取这些知识的能力有所提高。

感谢您的阅读！