作者 | 崔皓

審校 | 重樓

整體思路

本文聚焦 LLMOps（大模型運維）全流程實踐，從一大模型微調的例子切入，串聯起從數據準備到模型部署落地的完整鏈路。通過模擬業務人員上傳微調數據，借助 Jenkins 工作流驅動一系列自動化操作，展現大模型從研發優化到實際應用的全生命周期管理邏輯，幫大家理解大模型開發微調中如何實現 LLMOps 的全流程。

例子通過模型微調的方式，讓 Qwen2 大模型 “認知” 自身為 “微調小助手，由小明創造”。依托 LLaMA - Factory 完成模型微調，讓 Qwen2 學習特定身份設定；通過自定義腳本合并模型、利用 llama.cpp 轉換格式，適配部署需求；再經 MLflow 實現模型注冊、評估，構建 Docker 鏡像并部署為容器，最終通過測試驗證模型功能與性能。全流程以 Jenkins 為自動化引擎，串聯參數驗證、微調、合并、轉換、注冊、評估、鏡像生成、容器部署、測試九大環節，形成完整閉環。

為了方便大家了解整個案例的執行流程， 我們通過如下一張大圖讓大家了解。

這里對圖中涉及到的步驟進行詳細描述：

• 驗證參數：對模型全流程涉及的參數（如微調配置、轉換參數等）進行合法性校驗，確保流程穩定運行。
• 微調模型：基于 LLaMA-Factory 執行大模型微調任務，針對特定場景/數據優化模型效果。
• 合并模型：通過自定義 Python 腳本，將微調后的模型與基礎模型合并，整合優化成果。
• 轉換模型：利用 llama.cpp 工具，把模型轉換為目標格式（如 GGUF 格式 ），適配后續部署需求。
• 注冊模型：將轉換后的模型登記到模型倉庫（如 MLflow 模型注冊表 ），實現版本化管理。
• 評估模型：借助 MLflow 工具鏈，對模型開展性能評估（如指標計算、結果分析），并記錄評估數據。
• 生成鏡像：依托 MLflow 構建能力，打包包含模型推理服務的 Docker 鏡像，固化運行環境。
• 部署容器：將 Docker 鏡像部署為容器實例，使模型推理服務可對外提供穩定訪問。
• 測試模型：對容器化部署的模型進行功能、性能測試，驗證服務可用性與推理效果。

通過上述流程，將呈現大模型如何從 “通用能力” 向 “場景化定制” 演進。可以通過該實踐案例，理解 LLMOps 如何用自動化串聯模型迭代全環節，每個技術步驟如何服務業務目標，以及大模型從數據輸入到可用服務的完整實現邏輯，為實際業務中模型迭代與落地提供可參考的流程范式。

應用安裝

在開始 LLMOps 實踐前，需先搭建穩固的工具鏈底座。本章聚焦核心組件的安裝與準備，這些組件將支撐從模型微調、轉換到部署測試的全流程。為了讓大多數人能夠通過本文檔體驗 LLMOps 的全過程，我們選擇了 Windows 平臺，使用 Win 10/11 作為操作系統，顯卡方面使用了一張 4060 的 8G 現存的顯卡。顯卡的選取根據具體情況，由于我們會涉及到大模型微調的部分，帶現存的顯卡體驗會好一些。

安裝組件基本介紹

在安裝組件之前我們通過如下一張大圖讓大家了解， 這些組件在哪些實踐環節中起效。

這里我們將安裝的工具和組件進行分類，給大家介紹。

基礎環境

我們的技術棧圍繞 Jenkins、Git、Anaconda、Python 構建自動化與運行環境，它們是流程運轉的 “發動機”。Jenkins 作為自動化工作流核心，負責串聯起模型微調、合并、轉換等全環節；Git 保障代碼與數據版本可控；Anaconda 與 Python 則為模型開發提供虛擬環境與編程語言支持，讓不同工具間的依賴管理更清晰。

關鍵組件

（一）微調與加速：CUDA + LLaMA - Factory

模型微調是讓 Qwen2 “學習身份” 的關鍵一步。借助 CUDA 發揮 GPU 算力優勢，可大幅縮短微調時間。而 LLaMA - Factory 作為專業微調框架，提供便捷的參數配置與訓練流程，讓我們能高效用數據集訓練模型，賦予其 “微調小助手，由小明創造” 的認知。需確保 CUDA 版本與硬件、深度學習框架適配，再通過 Python 環境安裝 LLaMA - Factory 及依賴，為模型微調鋪好路。

（二）格式轉換：llama.cpp

完成微調與模型合并后，為適配多樣化部署場景，需用 llama.cpp 轉換模型格式（如轉為 GGUF 格式 ）。它能讓模型在不同硬件環境（尤其是輕量化部署場景）更易運行。安裝時，通過 Git 拉取源碼并編譯，依據硬件配置調整編譯參數，確保轉換后的模型能穩定支持后續流程。

（三）模型全生命周期管理：MLFlow

MLFlow 貫穿模型注冊、評估、鏡像生成環節，是模型全生命周期管理的 “中樞”。注冊模型時，它記錄版本與元數據，方便迭代追溯；評估環節，借助其工具鏈計算性能指標；生成鏡像階段，又能打包模型與推理服務。通過 Python 包管理工具安裝 MLFlow，配置好跟蹤服務器，就能讓模型從研發到部署的關鍵節點可管、可查。

部署測試

（一）容器化部署：Docker

模型要對外提供服務，Docker 是容器化部署的首選。它能封裝模型推理環境，確保不同環境下運行一致。安裝 Docker 引擎后，配置鏡像構建與容器運行參數，后續結合 MLFlow 生成的模型，快速打包成可部署的鏡像。

（二）功能測試：Streamlit

最終驗證模型功能（如身份認知回復是否符合預期 ），Streamlit 是輕量且便捷的工具。它能快速搭建 Web 測試界面，輸入指令驗證模型輸出。通過 Python 安裝 Streamlit，編寫簡單腳本加載部署后的模型，就能直觀測試模型在實際交互中的表現。

這些組件并非孤立存在，而是相互協作：Jenkins 驅動流程，調用 LLaMA - Factory 微調、llama.cpp 轉換；MLFlow 記錄模型演進；Docker 與 Streamlit 完成最后部署與驗證。

安裝 CUDA

CUDA（Compute Unified Device Architecture，統一計算設備架構）是 NVIDIA 推出的專為其 GPU（圖形處理器）設計的并行計算平臺與編程模型。在實戰中，CUDA 提供硬件加速支撐：例如使用 LLaMA-Factory 進行模型微調時，會通過 CUDA 接口調用 GPU 核心，在 llama.cpp 進行模型格式轉換（如 FP16 轉 FP8）或推理時，CUDA 也能加速數值計算過程，降低模型部署后的響應延遲。同時，CUDA 配套提供了 CUDA Toolkit（包含編譯器、庫、驅動等），確保深度學習框架與 NVIDIA GPU 之間的高效適配。

需要說明的是， 本次實踐使用的是 NVIDIA 4060 的顯卡，所以需要在安裝顯卡驅動的基礎上再安裝 CUDA 套件，從而支持上層的向量運算。

在安裝之前，需要通過Nvidia Control Panel查看當前顯卡驅動支持的最高 CUDA 版本。如下圖所示打開Nvidia Control Panel。

點擊“系統信息”，在彈出的對話框中查看支持的最高CUDA版本，這里顯示的 CUDA 是 12.6 版本，不同的顯卡這里支持的 CUDA 版本不同。

接著，如下圖所示，下載支持的CUDA版本安裝包 CUDA Toolkit Archive。

下載完 CUDA toolkit 之后還沒有完，需要安裝與之相關的其他依賴以及套件，訪問https://pytorch.org/get-started/locally/ 根據你所加載的操作系統，安裝指令包語言以及 CUDA 的版本生成命令。

直接把生成的命令，放到 powershell 中執行，記住在執行之前激活 mlflow 的環境，后面我們都會在這個虛擬環境中工作。

conda activate mlflow
 pip install --no-cache-dir torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126

執行命令之后，你會看到如下圖片的輸出內容，表示正在下載依賴。

完成上述操作之后需要重啟操作系統，然后打開 powershell 執行如下命令，查看 CUDA 版本。

nvcc --version

如下圖所示，輸出CUDA 編譯器版本。

此時如果還不放心，可以通過如下 Python 腳本查看CUDA是否可用。我們可以在 mlflow 目錄下面創建test_cuda.py 文件。需要說明的是，這個所謂的mlflow 目錄會存放一些相關的重要文件，我這里選擇 D:\mlflow 目錄，后面一些重要的測試文件和腳本文件我也會放到這里。并且，類似 Llama-Factory，llama.cpp 等開源工具也會安裝到這個目錄方便管理和講解。

import torch
 import subprocess

 def run_cmd(cmd):
 try:
 result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
 return result.stdout.strip()
 except Exception as e:
 return str(e)

 print("==== [CUDA / GPU 檢查腳本] ====\n")

 # 1. 檢查 nvidia-smi
 print(">>> 驅動 (nvidia-smi):")
 nvidia_smi_output = run_cmd("nvidia-smi")
 if nvidia_smi_output:
 print(nvidia_smi_output)
 else:
 print("未檢測到 nvidia-smi，請檢查顯卡驅動是否安裝正常。\n")

 # 2. PyTorch 版本信息
 print("\n>>> PyTorch 版本信息:")
 print(f"torch.__version__ = {torch.__version__}")
 print(f"torch.version.cuda = {torch.version.cuda}")
 print(f"torch.backends.cudnn = {torch.backends.cudnn.version()}\n")

 # 3. CUDA 可用性
 print(">>> CUDA 可用性:")
 print(f"torch.cuda.is_available() = {torch.cuda.is_available()}")
 print(f"torch.cuda.device_count() = {torch.cuda.device_count()}")

 if torch.cuda.is_available():
 print(f"當前 GPU: {torch.cuda.get_device_name(0)}")
 print(f"GPU 計算能力: {torch.cuda.get_device_capability(0)}")
 else:
 print("?? PyTorch 沒有檢測到可用的 CUDA/GPU。\n")

 print("\n==== 檢查結束 ====")

執行如下命令：

conda activate mlflow
 python test_cuda.py

得到下圖輸出，說明CUDA已啟用，并且列舉詳細參數。

安裝 Jenkins

Jenkins 是本次大模型全流程實戰的核心樞紐，它憑借 pipeline 機制，將微調、合并、轉換、評估、測試、部署等分散的工具與框架緊密串聯。

接下來，如下圖所示通過網站 https://www.jenkins.io/download/ 進行選擇并安裝。

需要注意的是在安裝 Jenkins 之前需要下載并安裝 JDK 23，在 Jenkins 的安裝過程中會選擇 JDK 所安裝的文件夾。另外， Jenkins 在安裝的時候會提供一個 WebUI 的訪問端口，默認是 8080。為了避免沖突，我在安裝的時候將其設置為 8081，大家可以根據具體情況酌情設置，這個 WebUI 的訪問地址在后面實踐中會用到，大部分的配置操作會在上面進行。

Jenkins 安裝完畢之后，如下圖所示， 通過 Windows 中的“服務”查看其正常運行即可。

在確保服務啟動的同時，還需要在瀏覽器輸入http://localhost:8081，這個地址和端口是我們在安裝時設定的。由于第一次訪問 Jenkins 的 WebUI，所以需要進行用戶名和密碼的初始化設置。如下圖所示，在初次訪問的時候，會提示用戶到指定文件中獲取管理員的密碼。由于每個人的安裝目錄不同，假設我們將 Jenkins 安裝到了D:/jenkins_home 下，那么文件就是D:/jenkins_home/secrets/initialAdminPasswrod 。

接著會完成管理員和密碼的設置，完成設置之后如下圖所示我們會安裝自定義插件。選擇“安裝推薦的插件”進行安裝。

如下圖所示，會顯示插件安裝的過程，這里只需要等待安裝完成即可。

安裝 Anaconda

在介紹完 Jenkins 的安裝之后，我們來到 Anaconda 的安裝。Anaconda 是一個針對數據科學、機器學習及深度學習場景設計的開源包管理與環境管理工具，它整合了 Conda 包管理器、Python 解釋器以及大量常用的數據科學庫（如 NumPy、Pandas、Scikit-learn 等），能為開發者提供統一、穩定的開發環境。

在本次大模型全流程實戰中，Anaconda 的核心作用是創建并管理獨立的 Python 虛擬環境（如專門用于 MLflow 評估的 mlflow 環境、用于 LLaMA-Factory 微調的環境等），避免不同工具間的依賴版本沖突。同時，借助 Anaconda 的命令行工具，還能快速完成環境的創建、激活、包安裝與更新，為整個 LLMOps 流程的依賴管理提供穩定支撐。

注意：如果不需要做環境隔離，或者本機已經有類似的管理工具，可以跳過 Anaconda 的安裝。

如下圖所示，通過官網下載最新版本Download Success | Anaconda。

雙擊安裝文件，然后如下圖所示，一頓操作不斷“下一步”對其進行安裝，只需要注意安裝目錄即可。

修改安裝目錄，默認C盤，建議修改到空間比較大的其他盤，這里是改到D盤下。

在安裝完畢之后，需要激活 conda 的虛擬環境，如下圖所示，通過“終端管理員”運行PowerShell。

輸入如下命令，進入conda安裝目錄，假設我們安裝在 C 盤。

cd 'c:\ProgramData\anaconda3\Library\bin\'

在使用conda命令之前需要對其進行初始化設置，執行如下命令。

.\conda init

一個小插曲，我在 windows 中安裝涉及權限問題，需要通過如下命令修改執行策略。

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned

完成上述操作之后，再重新打開PowerShell，如下圖所示在命令行的最左邊顯示（base），說明環境配置成功。

安裝好 Conda 之后，我們會使用 Conda 命令創建虛擬環境，大多數的組件和工具的安裝都包含在虛擬環境中，大家跟上別掉隊。

安裝 MLflow

MLflow 是一個開源的機器學習生命周期管理工具，主要用于簡化機器學習模型從開發、訓練、評估到部署的全流程管理。在本次大模型實戰中，MLflow 承擔著多重核心角色：在模型管理層面，它提供模型注冊表功能，可對微調、合并后的模型進行版本化記錄與管理，方便追溯不同版本模型的迭代歷史；在模型評估層面，能集成毒性、文本可讀性等指標計算邏輯，自動生成評估報告并記錄指標結果，支持后續對比分析；在模型部署層面，可基于已管理的模型自動生成包含推理服務的 Docker 鏡像配置，為后續容器化部署提供基礎。說白了，MLFlow 在幫助管理模型的生命周期，并對其進行管理和記錄。

這里我們會通過 conda 創建虛擬環境進行安裝，之后組件的安裝都會基于虛擬環境（mlflow），這里統一做一次說明。

打開PowerShell，執行如下命令創建名為 “mlflow”的虛擬環境，python版本選擇3.10.18。

conda create -n mlflow pythnotallow=3.10.18

創建完畢之后激活環境，執行如下代碼：

conda activate mlflow

在激活的環境中，執行如下命令安裝mlflow 組件以及相關依賴。

pip install mlflow

如果不出意外 mlflow 已經安裝好了，可以通過如下命令啟動 mlflow。

mlflow server --backend-store-uri file:///d:/mlflow/mlruns --artifacts-destination file:///d:/mlflow/mlartifacts --default-artifact-root file:///d:/mlflow/mlartifacts --host 127.0.0.1 --port 8082

命令內容有點長，嘗試給大家解釋一下。

該命令用于啟動 MLflow 跟蹤服務器，所以以 mlflow server 開頭，后面跟了一系列參數：

• --backend-store-uri file:///d:/mlflow/mlruns 設定后端存儲路徑，用于保存實驗元數據（如運行記錄、參數、指標等）到本地 d:/mlflow/mlruns 目錄；
• --artifacts-destination 和 --default-artifact-root 均指定為 file:///d:/mlflow/mlartifacts，定義了模型 artifacts（如權重文件、配置文件等）的存儲路徑；
• --host 127.0.0.1 和 --port 8082 則限制服務器僅在本地（127.0.0.1）的 8082 端口提供服務，確保只有本機可訪問該 MLflow 服務器。

執行上述命令之后， mlflow 也就啟動了，也可以通過 http://localhost:8082 訪問 mflow 的 WebUI。

安裝 Git

由于需要通過 Git 命令拉取諸如 Llama-Factory 開源項目，可以通過地址 Git - Downloading Package完成 Git 的下載，雙擊Git-2.50.1-64-bit.exe，按默認選項完成安裝。這里不展開描述。

安裝 LLaMA-Factory

Git 的安裝主要是為了后面兩個開源工具做準備的，下面就輪到 Llama factory 的安裝了。 LLaMA-Factory 是一個開源的大模型微調框架，專注于簡化 LLaMA 系列及衍生大模型的微調流程，提供了一站式的模型微調、評估與部署解決方案。它集成了多種主流微調方法（如全參數微調、LoRA 等參數高效微調技術），支持通過配置文件或命令行參數快速設定微調策略（如學習率、訓練步數、批處理大小等），降低了大模型微調的技術門檻。

在本次大模型實戰中，LLaMA-Factory 主要用于加載基礎模型（如 Qwen2）和定制化數據集（包含 “身份認知” 相關指令），執行微調任務以讓模型學習 “微調小助手，由小明創造” 的角色設定，同時支持在微調過程中利用 CUDA 進行 GPU 加速，提升訓練效率，最終輸出微調后的模型權重，為后續的模型合并環節提供基礎。

通過下面命令激活環境，并且利用 git 拉取 Llama factory 并進行安裝。注意，這里我們將其安裝到了d:\mlflow 目錄下面，方便后續管理。

conda activate mlflow
 cd d:\mlflow
 git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git
 cd LLaMA-Factory 
 pip install -e ".[torch,metrics]"

如果安裝過程中遇到下載不了的情況，需要通過代理完成下載，或者使用鏡像拉取，這里不展開說明。這里我們選擇 Clash，此時在PowerShell中輸入如下命令， 保證 git 命令能夠順利執行。如果沒有對應網絡問題，可以跳過這個部分。

$env:HTTP_PROXY="http://127.0.0.1:7890"
 $env:HTTPS_PROXY="http://127.0.0.1:7890"

安裝完畢之后，執行以下命令測試 LLaMA-Factory WebUI 是否正常運行。此時定位到 d:/mlflow/LLaMA-Factory 目錄下面執行。

python src/webui.py

你會看到如下輸出信息，說明LLaMA-Factory 的服務已經啟動了。

Visit http://ip:port for Web UI, e.g., http://127.0.0.1:7860
 * Running on local URL: http://0.0.0.0:7860
 * To create a public link, set `share=True` in `launch()`.

此時，通過 localhost:7860 就可以訪問 LLaMA-Factory 了，不過這里暫時不會用到， 后面會通過命令行的方式調用它。

安裝 llama.cpp

由于我們實踐的是 LLMOps 的全流程，中間涉及到的工具和組件較多，所以整個過程比較漫長，終于來到了最后一步，就是安裝 llama.cpp。

llama.cpp 是一個輕量級的開源框架，主要用于大模型的高效推理與格式轉換，尤其適用于在 CPU 或資源受限的硬件環境中運行模型。它支持多種大語言模型，并提供了模型格式轉換工具，能夠將不同格式的模型文件轉換為其專用的 GGUF 格式，同時優化模型的加載與推理性能。

在本次實戰中，我們會用到 llama.cpp 的模型轉換功能。需要轉換的源文件是 safetensors 格式，它是一種安全的張量存儲格式，專為機器學習模型設計，具有防篡改特性，能有效避免惡意代碼注入，目前被廣泛用于存儲模型權重，從 LLaMA-Factory 微調后輸出的模型文件即為此格式。通過 llama.cpp 提供的轉換工具（如 convert_hf_to_gguf.py），我們將 safetensors 格式的模型文件轉換為 GGUF 格式。GGUF 格式是一種更通用的模型存儲格式，它對模型權重和元數據進行了統一封裝，適配性更強，可在不同硬件環境（包括 CPU、GPU 及邊緣設備）中更高效地加載和運行，且支持多種推理框架。

需要說明的是，模型格式轉換并非必需步驟，直接使用 safetensors 格式的模型進行部署也是可行的；但通過演示這一轉換過程，我們可以展示大模型在落地時的更多可能性，包括如何適配多樣化的硬件環境，為實際應用中的格式選擇提供參考。

依舊通過如下指令安裝llama.cpp。

conda activate mlflow
 cd E:\mlflow
 git clone https://github.com/ggerganov/llama.cpp.git
 cd llama.cpp\gguf-py
 pip install --editable .
 pip install mistral-common

看到如下字樣說明安裝成功了。

WARNING: Ignoring invalid distribution -lflow (d:\programdata\anaconda3\envs\mlflow\lib\site-packages)
 WARNING: Ignoring invalid distribution -lflow-skinny (d:\programdata\anaconda3\envs\mlflow\lib\site-packages)
 Installing collected packages: gguf
 Attempting uninstall: gguf
 Found existing installation: gguf 0.17.1
 Uninstalling gguf-0.17.1:
 Successfully uninstalled gguf-0.17.1
 WARNING: Ignoring invalid distribution -lflow (d:\programdata\anaconda3\envs\mlflow\lib\site-packages)
 WARNING: Ignoring invalid distribution -lflow-skinny (d:\programdata\anaconda3\envs\mlflow\lib\site-packages)
 Successfully installed gguf-0.17.1

配置 Jenkins

在完成全流程所需組件與工具的安裝后，接下來需將這些分散的技術模塊整合為自動化執行鏈路，核心在于將工具調用邏輯嵌入 Jenkins 并完成對應配置，因此我們的關注點將轉移至 Jenkins 的具體設置。考慮到本次 LLMOps 實踐涵蓋參數驗證、模型微調、合并、轉換、注冊、評估、鏡像生成、容器部署、測試共 9 個步驟，需依托 Jenkins 的 Pipeline 機制實現全流程串聯：Jenkins Pipeline 是一種基于代碼的工作流定義方式，支持將多環節任務按順序編排為可復用、可版本控制的腳本，能自動觸發各步驟執行并處理環節間的依賴關系，避免人工干預導致的流程中斷或遺漏。同時，為適配不同場景下的 LLMOps 需求（如更換基座模型、使用不同微調數據集），還需為 Pipeline 設計客制化輸入參數，例如基座模型在本地或遠程存儲的具體地址、業務人員上傳的微調數據集文件路徑、MLflow Server 的訪問地址等，通過參數化配置讓 Pipeline 具備更強的靈活性，滿足多樣化的模型迭代與部署需求。

創建Pipeline

首先創建 Jenkins 的 Pipeline 類型的任務， 如下圖所示，通過 localhost:8081 訪問 Jenkins 的 WebUI 界面， 點擊“新建 Item”進行 Pipeline 的設置。 需要注意的是， localhost:8081 需要和之前安裝Jenkins 時定義的訪問地址保持一致。

接著根據下圖，在新建 Item 中輸入一個任務的名稱，按照個人喜好設置就可以了。記得選擇 Pipeline 作為任務的類型。

在點擊“確定”之后會看到如下圖所示界面。這里的“腳本”我們會在后續進行填寫，這里知道就行了，繼續點擊“Save”。

安裝插件

我們已經創建了 Jenkins Pipeline類型的任務，由于該任務會接受數據集文件作為大模型微調的輸入，而數據集文件的格式是 JSON，所以需要讓 Jenkins 能夠識別并解析該文件格式。于是，我們需要安裝兩個插件來滿足文件上傳和解析的需求，如下圖所示，在 Jenkins 的 WebUI 界面點擊右上方的“齒輪”（設置）按鈕，選擇“Plugins”進行，（File Parameter）文件上傳和文件解析（Pipeline Utility Steps）插件的安裝。

在界面中選擇“Available plugins”，然后輸入“File Parameter”在下方列表中勾選插件，然后點擊最右邊的“安裝”按鈕。

由于安裝需要一點時間，如下圖所示，點擊“安裝完成后啟動 Jenkins”。

按照上面相同的步驟，把“Pipeline Utility Steps” 也安裝起來，這里就不再重復安裝步驟了，大家自行安裝并重啟 Jenkins。

設置參數

前面安裝 Jenkins 插件的目的是為了支持文件上傳以及解析 Json 格式的文件， 接下來就需要設置輸入的參數了。在生產環境中，Jenkins 定義的 Pipeline 任務更像一個工作流，會按照既定的步驟逐一執行直到結束，該工作流獲取外部信息的方式就是參數輸入，接下來就來看有哪些參數需要設置。

如下圖所示，在我們之前創建的“item” Pipeline 中選擇“配置”。

在左側的“General”菜單中選擇“This project is parameterized”，意思是針對這個項目進行參數化。

緊接著在下面的“添加參數”下拉框中選擇“Stashed File Parameter”，意思是可以將上傳文件作為參數輸入，稍后我們會將微調文件作為參數輸入。

如下圖所示，在展開“Stashed File Parameter”參數中可以輸入“DATASET_FILE”作為 Name，也就是說上傳的文件會保存到名為“DATASET_FILE”的工作空間變量中。

Jenkins 的工作空間（Workspace）是指 Jenkins 服務器在執行任務（如 Pipeline、自由風格項目等）時，為當前任務動態分配的一個本地文件目錄，用于存放任務執行過程中所需的代碼、數據、依賴文件及輸出結果。它是任務運行的 “臨時工作目錄”，每個任務在執行時都會擁有獨立的工作空間，避免不同任務間的文件沖突。

接下來添加幾個字符串類型的參數，如下圖所示，選擇“String Parameter”。

輸入名稱為“MLFLOW_TRACKING_URI”的參數，給出一個默認值為“http://127.0.0.1:8082” ，也就是 MLflow 服務器的訪問地址。如果還有記憶的話，我們在“安裝 MLflow”的環節會啟動這個 MLFlow，用的就是本地的 8082 端口。由于每個人安裝的MLFlow 服務的地址各不相同，所以這里需要進行配置。

接著就是模型文件所載目錄，通過 “MODEL_NAME_OR_PATH”進行配置。在測試環節，我們會嘗試下載大模型 Qwen2-0.5b ，并存放到下圖所示的目錄中。

在配置的最后，設置“ MODEL_NAME”用來標注在 MLflow 中所注冊的模型名稱。在 MLflow 注冊之后就可以查看評估結果，以及可以對模型進行后續操作。

好了，至此我們就完成了 Pipeline 任務的參數設置，當然我們還可以加入更多參數，這里全當拋磚引玉，在實際項目中可以自由發揮。

編寫腳本

Jenkins Pipeline 腳本以代碼化方式定義整個工作流程，核心功能在于將分散的步驟串聯為自動化鏈路，同時支持靈活調用外部腳本（如 Python 文件），實現復雜流程的有序執行。

從步驟串聯來看，Pipeline 腳本通過結構化語法（如 stage 塊）將不同環節按邏輯組織，例如在本次 LLMOps 實踐中，可通過 stage('模型微調') 定義微調環節，各環節按腳本順序依次執行。

同時，Pipeline 腳本具備強大的外部調用能力，可直接在腳本中通過命令行語法調用其他 Python 文件。例如，在 “合并模型” 環節，腳本中可寫入類似 python merge_lora_model.py 命令完成。這種調用方式讓 Pipeline 無需重復編寫復雜邏輯，只需專注于流程調度，而具體功能實現可交由專業腳本處理，既簡化了 Pipeline 腳本的復雜度，又提高了代碼的復用性與可維護性。

簡言之，Pipeline 腳本既是流程的 “串聯者”，負責按序調度各環節；也是 “集成者”，通過調用外部 Python 腳本拓展功能邊界，最終實現從參數驗證到模型部署的全流程自動化。

具體而言在我們的 LLMOps 的實踐中，定義了一套完整的大模型全流程自動化工作流，涵蓋從參數驗證到容器化部署及接口測試的 9 個核心環節，實現了大模型微調、合并、轉換、評估、部署的端到端自動化。

整體腳本分為兩大部分：

• environment ：統一配置了全流程所需的環境變量（如編碼格式、路徑信息、Conda 環境等），確保各環節參數一致；
• stages ：定義了 9 個階段。首先通過 “驗證參數” 階段校驗輸入合法性（如 MLflow 地址、數據集格式等），確保流程輸入合規；隨后依次執行 “LLaMAFactory 微調”（調用 LLaMA-Factory 框架進行模型微調）、“合并 Lora 和預訓練模型”（通過自定義 Python 腳本整合模型）、“轉換模型格式為 gguf”（利用 llama.cpp 轉換模型格式）；接著完成 “注冊合并后模型到 MLflow”（將模型納入版本管理）、“模型評估”（調用評估腳本記錄指標）；最后通過 “生成 docker 鏡像”“部署到 Docker 容器”“測試容器接口” 完成模型的容器化部署與功能驗證。

先放整體腳本，然后在分environment 和 stages講解。

pipeline {
 agent any
 
 environment {
 // 設置UTF-8編碼環境變量
 JAVA_TOOL_OPTIONS = "-Dfile.encoding=UTF-8"
 // Python 環境變量，用于控制 Python 程序的 標準輸入/輸出（stdin/stdout/stderr）的默認編碼
 PYTHONIOENCODING = "UTF-8"
 // MLflow 存儲模型和文件（Artifacts）的默認位置
 MLFLOW_ARTIFACT_URI = 'file:///d:/mlflow/mlartifacts'
 // 微調數據集保存地址
 DATASET_URI = 'd:\\mlflow\\LLaMA-Factory\\data\\custom.json'
 // llama-factory目錄
 LLAMA_FACTORY_PATH = 'd:\\mlflow\\LLaMA-Factory'
 // llama-factory微調模型保存目錄（LLAMA_FACTORY_PATH下的目錄）
 TRAIN_OUTPUT_PATH = 'saves\\Qwen2-0.5B\\lora'
 // 模型合并后保存目錄
 MERGED_PATH = 'd:\\mlflow\\merge'
 // 運行環境數據根目錄
 ROOT_PATH = 'd:\\mlflow'
 // 定義 Conda 激活命令的路徑（注意 Windows 路徑轉義）
 CONDA_ACTIVATE = "c:\\ProgramData\\anaconda3\\condabin\\activate.bat"
 // Conda 環境名稱
 CONDA_ENV = "mlflow"
 // 評估數據集
 EVAL_DATA = 'd:\\mlflow\\myTrain.json'
 // 定義容器名稱和鏡像名稱（根據實際情況修改）
 CONTAINER_NAME = "llm_test"
 }
 
 stages {
 stage('驗證參數') {
 steps {
 script {
 if (!params.MLFLOW_TRACKING_URI) {
 error "MLFLOW_TRACKING_URI 不能為空"
 }
 
 if (!env.DATASET_FILE_FILENAME) {
 error "未上傳用于微調的數據集"
 }
 
 // 文件驗證
 if (env.DATASET_FILE_FILENAME) {
 echo "上傳文件: ${DATASET_FILE_FILENAME}"
 // 1. 判斷文件格式
 if (!env.DATASET_FILE_FILENAME.endsWith('.json')) {
 error "只接受 .json 文件，當前文件: ${DATASET_FILE_FILENAME}"
 }
 // 2. 自動從stash恢復
 unstash 'DATASET_FILE'
 
 // 3. 獲取文件路徑
 def filePath = "${env.WORKSPACE}\\DATASET_FILE"
 
 // 4. 讀取文件內容
 def content = readFile(file: filePath, encoding: env.PYTHONIOENCODING)
 
 // 4.1. 解析為JSON對象
 def json
 try {
 json = readJSON(text: content)
 } catch (Exception e) {
 error "無效的JSON格式: ${e.message}"
 }
 
 // 4.2. 驗證數據結構
 if (!(json instanceof List)) {
 error "根元素必須是數組"
 }
 
 json.eachWithIndex { item, index ->
 // 4.2.1 檢查每項是否為對象
 if (!(item instanceof Map)) {
 error "第${index+1}項不是對象"
 }
 
 // 4.2.2 檢查必需字段
 def requiredFields = ['instruction', 'input', 'output']
 requiredFields.each { field ->
 if (!item.containsKey(field)) {
 error "第${index+1}項缺少必需字段: ${field}"
 }
 }
 }
 
 echo "JSON 格式驗證通過"
 
 // 5. 復制文件到數據集所在目錄
 bat """copy "${filePath}" "${DATASET_URI}" """
 }
 }
 }
 }
 
 stage('LLaMAFactory 微調') {
 steps {
 bat """
 @echo off
 REM 激活 Conda 環境
 call "${CONDA_ACTIVATE}" ${CONDA_ENV}
 
 REM 切換到項目目錄
 cd /d "${ROOT_PATH}\\LLaMA-Factory"
 
 REM 執行訓練命令（注意換行符使用^）
 llamafactory-cli train ^
 --stage sft ^
 --do_train True ^
 --model_name_or_path ${params.MODEL_NAME_OR_PATH} ^
 --preprocessing_num_workers 16 ^
 --finetuning_type lora ^
 --template default ^
 --flash_attn auto ^
 --dataset_dir ${LLAMA_FACTORY_PATH}\\data ^
 --dataset dataset ^
 --cutoff_len 2048 ^
 --learning_rate 5e-05 ^
 --num_train_epochs 20 ^
 --max_samples 100000 ^
 --per_device_train_batch_size 2 ^
 --gradient_accumulation_steps 8 ^
 --lr_scheduler_type cosine ^
 --max_grad_norm 1.0 ^
 --logging_steps 5 ^
 --save_steps 100 ^
 --warmup_steps 0 ^
 --packing False ^
 --enable_thinking True ^
 --report_to none ^
 --output_dir ${TRAIN_OUTPUT_PATH} ^
 --bf16 True ^
 --plot_loss True ^
 --trust_remote_code True ^
 --ddp_timeout 180000000 ^
 --include_num_input_tokens_seen True ^
 --optim adamw_torch ^
 --lora_rank 8 ^
 --lora_alpha 16 ^
 --lora_dropout 0 ^
 --lora_target all
 """
 }
 }
 
 stage('合并Lora 和 預訓練模型') {
 steps {
 bat """
 REM 激活 Conda 環境
 call "${CONDA_ACTIVATE}" ${CONDA_ENV}
 
 REM 開始合并模型
 python "${ROOT_PATH}\\merge_lora_model.py" ^
 --base_model "${params.MODEL_NAME_OR_PATH}" ^
 --lora_path "${LLAMA_FACTORY_PATH}\\${TRAIN_OUTPUT_PATH}" ^
 --output_dir "${MERGED_PATH}"
 """
 }
 }
 stage('轉換模型格式為gguf') {
 steps {
 bat """
 REM 激活 Conda 環境
 call "${CONDA_ACTIVATE}" ${CONDA_ENV}
 
 REM 切換到llama.cpp目錄
 cd /d "${ROOT_PATH}\\llama.cpp"

 REM 判斷convert目錄是否存在，不存在則創建
 if not exist "${ROOT_PATH}\\convert" (
 md "${ROOT_PATH}\\convert"
 echo 創建convert目錄成功
 ) else (
 echo convert目錄已存在
 )
 
 REM 開始轉換模型格式
 python convert_hf_to_gguf.py "${MERGED_PATH}" --outfile "${ROOT_PATH}\\convert\\merge-auto.gguf"
 """
 }
 }
 
 stage('注冊合并后模型到MLflow') {
 steps {
 script {
 bat """
 REM 激活Conda環境并檢查
 call "${CONDA_ACTIVATE}" ${CONDA_ENV} || (echo Conda環境激活失敗 && exit 1)
 
 REM 執行注冊腳本，輸出日志到文件
 python "${ROOT_PATH}\\register_model.py" ^
 --model-name "${params.MODEL_NAME}" ^
 --model-dir "${MERGED_PATH}" ^
 --experiment "${params.MODEL_NAME}" ^
 --tracking-uri "${params.MLFLOW_TRACKING_URI}" ^
 > register_log.txt 2>&1 || (echo 模型注冊失敗 && exit 1)
 """
 
 // 從日志提取版本號
 def logContent = readFile(file: 'register_log.txt', encoding: env.PYTHONIOENCODING)
 // 正則表達式：同時匹配 "version 2" 和 "Created version '2'" 格式
 // (\d+) 表示捕獲數字版本號
 def versionMatch = (logContent =~ /version (?:')?(\d+)(?:')?/)
 
 if (versionMatch.find()) { // 使用find()而非matches()，匹配日志中任意位置的版本號
 env.MODEL_VERSION = versionMatch.group(1) // 獲取第一個捕獲組（版本號）
 echo "提取到模型版本: ${env.MODEL_VERSION}"
 } else {
 error "未從日志中找到模型版本，日志內容: ${logContent}"
 }
 }
 }
 }
 
 stage('模型評估（合并后模型）') {
 steps {
 bat """
 REM 激活 Conda 環境
 call "${CONDA_ACTIVATE}" ${CONDA_ENV}
 
 cd /d "${ROOT_PATH}"
 python evaluate.py --model-name ${params.MODEL_NAME} --eval-data "${EVAL_DATA}" --experiment "${params.MODEL_NAME}" --tracking-uri ${params.MLFLOW_TRACKING_URI}"
 """
 }
 }
 
 stage('生成docker鏡像（合并后模型）') {
 steps {
 withCredentials([usernamePassword(credentialsId: 'dockerhub-creds', 
 usernameVariable: 'DOCKER_USER', 
 passwordVariable: 'DOCKER_PASS')]) {
 bat """
 REM 1. 登錄 Docker Hub
 echo %DOCKER_PASS% | docker login -u %DOCKER_USER% --password-stdin
 
 REM 2. 禁用 BuildKit，防止 Windows 上報 insufficient_scope
 setx DOCKER_BUILDKIT 0
 
 REM 3. 激活 Conda 環境
 call "${CONDA_ACTIVATE}" ${CONDA_ENV}
 
 REM 4. 生成Dockerfile
 mlflow models generate-dockerfile -m models:/${params.MODEL_NAME}/${MODEL_VERSION} -d ${ROOT_PATH} --enable-mlserver
 
 REM 5. 在 Dockerfile 中第一條 FROM 后插入 pip 國內源配置
 REM 定義 Dockerfile 路徑
 set DOCKERFILE=${ROOT_PATH}\\Dockerfile
 set TMPFILE=%DOCKERFILE%.tmp
 
 REM 清空臨時文件
 if exist %TMPFILE% del /f /q %TMPFILE%
 
 REM 遍歷 Dockerfile 行
 for /f "usebackq delims=" %%A in (%DOCKERFILE%) do (
 echo %%A>>%TMPFILE%
 REM 匹配 FROM python:3.10.18-slim
 echo %%A | findstr /r "^FROM python:3.10.18-slim" >nul
 if not errorlevel 1 (
 echo RUN pip install --upgrade pip ^&^& pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple>>%TMPFILE%
 )
 )
 
 REM 用臨時文件替換原 Dockerfile
 move /y %TMPFILE% %DOCKERFILE%
 
 REM 6. 構建你的 MLflow + MLServer 鏡像
 cd /d "${ROOT_PATH}"
 docker build -t ${params.MODEL_NAME}:v${MODEL_VERSION} .
 """
 }
 }
 }
 
 stage('部署到Docker容器') {
 steps {
 echo "開始部署容器..."
 bat """
 @echo off
 REM 檢查容器是否存在
 docker inspect %CONTAINER_NAME% >nul 2>&1
 if %errorlevel% equ 0 (
 echo 容器 %CONTAINER_NAME% 存在，正在停止并刪除...
 docker stop %CONTAINER_NAME%
 docker rm %CONTAINER_NAME%
 ) else (
 echo 容器 %CONTAINER_NAME% 不存在，直接啟動新容器...
 )
 
 REM 用新鏡像啟動容器（后臺運行）
 echo 啟動新容器 ${CONTAINER_NAME}...
 docker run -d --name ${CONTAINER_NAME} -p 8083:8080 ${params.MODEL_NAME}:v${MODEL_VERSION}
 """
 }
 }
 
 stage('測試容器接口/invocations') {
 steps {
 bat """
 echo "調用接口"
 REM 3. 激活 Conda 環境
 call "${CONDA_ACTIVATE}" ${CONDA_ENV}
 
 cd /d "${ROOT_PATH}"
 python demo_api.py
 """
 }
 }
 }
 }

接下來我們來看看詳細內容：

environment腳本

我們對一些主要參數進行講解如下：

MLflow 相關配置變量MLFLOW_ARTIFACT_URI，該路徑需與 MLflow Server 啟動命令中--artifacts-destination參數指定的路徑完全一致（如之前啟動命令中--artifacts-destination file:///d:/mlflow/mlartifacts，則此處需同步修改為對應路徑），用于定義 MLflow 存儲模型 Artifacts（如模型權重、評估報告）的默認位置，同時需提前確保該目錄已手動創建，避免后續模型注冊、評估時因路徑不存在導致失敗。

工具與數據路徑類變量是配置的核心，涵蓋 LLaMA-Factory、數據集、模型存儲等關鍵位置。其中LLAMA_FACTORY_PATH = 'd:\\mlflow\\LLaMA-Factory'直接指向 LLaMA-Factory 框架的安裝目錄，后續微調環節需切換至該目錄執行訓練命令，因此路徑需與實際安裝位置完全匹配。

TRAIN_OUTPUT_PATH = 'saves\\Qwen2-0.5B\\lora'定義了微調后模型 checkpoint 的存儲路徑，其實際完整路徑為LLAMA_FACTORY_PATH與該變量的拼接，該目錄會在微調過程中自動創建，用于存放 LoRA 微調后的權重文件。需特別注意的是，路徑中的 “Qwen2-0.5B” 對應本次實戰使用的基座模型名稱，需同步修改該字段，避免不同模型的 checkpoint 混雜存儲，影響后續模型合并。MERGED_PATH = 'd:\\mlflow\\merge'則是模型合并后的存儲路徑，僅需提前確保該目錄存在，即可在 “合并 Lora 和預訓練模型” 階段接收合并后的完整模型文件。

ROOT_PATH = 'd:\\mlflow'作為運行環境數據根目錄，統一管理全流程所需的自定義腳本與評估數據，目前該目錄下存放四類關鍵文件：合并 Lora 與基礎模型的merge_lora_model.py、注冊模型到 MLflow 的register_model.py、模型評估腳本evaluate.py，以及評估數據集myTrain.json（對應變量EVAL_DATA = 'd:\\mlflow\\myTrain.json'），這種集中存儲方式便于后續維護與路徑調用。

最后是 Conda 環境與 Docker 相關變量，CONDA_ACTIVATE = "c:\\ProgramData\\anaconda3\\condabin\\activate.bat"指向 Conda 激活腳本的路徑，需與實際安裝的 Conda 路徑匹配，后續各環節通過調用該腳本激活指定 Conda 環境；CONDA_ENV = "mlflow"則是本次實戰使用的 Conda 環境名稱，需與安裝階段創建的環境名稱完全一致，確保微調、評估等依賴包能正常加載。CONTAINER_NAME = "llm_test"定義了模型部署階段的 Docker 容器名稱，后續啟動容器、停止容器時均通過該名稱識別目標容器，若需同時部署多個模型，可通過修改該變量區分不同容器。

Stages 腳本

按照九個不同的步驟，總結如下：

1. 驗證參數

該階段作為全流程的入口校驗環節，負責確保所有必要輸入符合規范。首先檢查MLFLOW_TRACKING_URI參數是否為空，若為空則報錯終止流程，確保 MLflow 服務地址有效；同時驗證是否存在上傳的微調數據集，未上傳則直接報錯。對上傳的文件，先檢查格式是否為.json，不符合則提示僅支持 JSON 格式；通過unstash恢復文件后，讀取內容并解析為 JSON 對象，驗證其根元素是否為數組，且每個子項是否為包含instruction、input、output字段的對象，確保數據結構滿足微調要求。驗證通過后，將文件復制到DATASET_URI指定路徑，為后續微調提供標準化數據輸入。

2. 微調模型

此階段是模型定制的核心環節，通過 LLaMA-Factory 框架執行微調操作。流程上先激活CONDA_ENV指定的 Conda 環境，切換到 LLaMA-Factory 安裝目錄，再執行llamafactory-cli train命令啟動微調。命令中明確了關鍵參數：采用監督微調模式（stage sft），使用 LoRA 參數高效微調技術（finetuning_type lora），數據集為dataset（與dataset_info.json配置對應），同時設置了學習率（5e-05）、訓練輪次（20 輪）、批處理大小（2）、輸出路徑（TRAIN_OUTPUT_PATH）等訓練參數。最終將微調產生的 LoRA 權重保存到指定目錄，為模型合并提供基礎。

3. 合并模型

該階段用于整合微調得到的 LoRA 權重與原始基座模型。通過激活 Conda 環境，調用merge_lora_model.py腳本，傳入三個關鍵參數：基座模型路徑（params.MODEL_NAME_OR_PATH）、LoRA 權重路徑（LLAMA_FACTORY_PATH與TRAIN_OUTPUT_PATH的拼接結果）、輸出目錄（MERGED_PATH），將兩者合并為完整的模型文件并保存，為后續格式轉換和部署提供統一的模型載體。

4. 轉換模型

此階段實現模型格式的轉換以提升硬件兼容性。激活 Conda 環境后，切換到 llama.cpp 目錄，先檢查convert輸出目錄是否存在，不存在則自動創建；隨后通過convert_hf_to_gguf.py腳本將MERGED_PATH中的合并模型轉換為 GGUF 格式，輸出至ROOT_PATH\\convert\\merge-auto.gguf。GGUF 格式的通用性使得模型可在更多硬件環境（如 CPU、邊緣設備）中部署，拓展了模型的應用場景。

5. 注冊模型

該階段將合并后的模型納入 MLflow 的版本管理體系。激活 Conda 環境后，執行register_model.py腳本，傳入模型名稱（params.MODEL_NAME）、模型目錄（MERGED_PATH）、實驗名稱（params.MODEL_NAME）及 MLflow 服務地址（params.MLFLOW_TRACKING_URI），完成模型注冊并將過程日志輸出到文件。通過正則表達式從日志中提取模型版本號，存入MODEL_VERSION環境變量，為后續鏡像生成和部署提供唯一版本標識。

6. 評估模型

此階段用于驗證合并后模型的性能指標。激活 Conda 環境后，切換到ROOT_PATH目錄，執行evaluate.py腳本，傳入模型名稱（params.MODEL_NAME）、評估數據集路徑（EVAL_DATA）、實驗名稱（params.MODEL_NAME）及 MLflow 服務地址，計算模型評估指標并將結果記錄到 MLflow，為模型質量提供量化依據，確保其滿足預期效果。

7. 生成鏡像

該階段為模型創建容器化部署的鏡像。通過 Jenkins 憑據管理獲取 Docker Hub 賬號密碼并完成登錄，禁用 BuildKit 以避免 Windows 環境下的兼容性問題；激活 Conda 環境后，使用mlflow models generate-dockerfile生成鏡像配置文件，同時修改 Dockerfile 插入 PyPI 國內源以加速依賴安裝；最終基于修改后的 Dockerfile 構建帶有版本標識（params.MODEL_NAME:vMODEL_VERSION）的鏡像，為模型部署提供標準化載體。

8. 部署容器

此階段將生成的鏡像部署為可運行的容器服務。流程上先檢查CONTAINER_NAME指定的容器是否存在，若存在則停止并刪除舊容器；再基于新鏡像啟動后臺運行的容器，將主機 8083 端口映射到容器 8080 端口，使模型服務可通過主機端口對外提供訪問，完成模型從鏡像到實際服務的轉化。

9. 測試模型

作為全流程的收尾環節，該階段驗證部署的容器服務是否正常可用。激活 Conda 環境后，切換到ROOT_PATH目錄，執行demo_api.py腳本調用容器的/invocations接口，測試模型服務的響應情況，確保接口正常通信且模型輸出符合預期，最終完成整個 LLMOps 流程的閉環驗證。

另外需要手動修改 LLaMAFactory 目錄下的dataset 文件如下：

"dataset": {
 "file_name": "custom.json"
 },

因為在這個文件下對應的都是可以微調的文件的名字，我們在腳本中會指定使用 cusotm.json。這里會將用戶上傳的文件 copy 到cusotm.json 中進行微調處理。

測試 LLMOps 流程

了解了整體 Pipeline 腳本之后，我們開始 LLMOps 流程的測試。首先下載大模型，如下：

conda activate mlflow
 pip install modelscope
 # 加--local_dir可指定模型下載保存的目錄
 # 例如C:\\models\\qwen\\qwen2-0.5b-instruct
 modelscope download --model qwen/qwen2-0.5b-instruct --local_dir d:\\mlflow\\Qwen2-0.5b

看到類似下面的截圖表示正在下載。

準備好模型之后，通過下圖操作，啟動 Pipeline 工作流。

填入參數包含：微調文件，MLflow 地址，基座模型存放目錄，MLflow 中注冊模型的名字。

這里我們會上傳 myTrain.json 文件作為微調的數據集文件， 其內容大致如下，由于篇幅關系我們就不粘貼所有的文本內容了。大約使用了這樣的數據 200 余條進行微調。

[
 {
 "instruction": "hi",
 "input": "",
 "output": "Hello! I am 微調小助手, an AI assistant developed by 小明. How can I assist you today?"
 },
 ]

此時，Pipeline 就開始工作了，由于整個過程比較漫長，特別是微調、評估、部署會花費比較多的時間，可以通過下面方法查看執行進度。選擇執行的 Pipeline，然后點擊“Pipeline Overview”。

如下圖所示，在最上方會顯示執行的步驟。如果中途出現問題，點擊步驟可以查看運行結果，以及錯誤原因。

這里設置幾個檢查點，大家可以自行查看。比如LLaMAFactory 微調成功后會在配置的環境變量（TRAIN_OUTPUT_PATH）對應的目錄下生成微調后模型。這里的模型都是 checkpoint，需要和之前下載的基座模型進行合并，然后才能部署。

合并之后的模型，可以通過MERGED_PATH 變量配置的目錄查看。

接著就是轉化為 gguf 的模型，可以在對應的目錄查到。

上述這些模型目錄的查證不是必須的，這里是讓大家知道整個過程中如何追蹤文件生成，方便大家了解全過程，理解執行邏輯。

在注冊模型階段會把合并之后的模型在MLflow中注冊，這里需要注意模型版本。

同時通過MLflow WebUI可以查看注冊的模型信息。

按照下圖的操作選擇注冊模型之后，可以看到模型的評估結果。

查看模型評估指標。

在完成模型評估之后，可以通過Docker Desktop查看生成的鏡像，這里一眼就可以看到模型的名稱，要注意的是模型版本會和注冊到MLflow 中的版本一致。圖中 “Tag”下面就是模型的版本。

有了 Docker 鏡像之后，就可以根據該鏡像部署到Docker容器中，部署完成后會運行一個新的容器llm_test，這個名字在環境變量（CONTAINER_NAME）中配置過。

最后我們會通過模型的 API 接口調用模型，從而測試模型是否可以用，如下圖所示，在運行成功后會在Jenkins控制臺輸出調用結果。

至此，整個 LLMOps 過程完結。

作者介紹

崔皓，51CTO社區編輯，資深架構師，擁有18年的軟件開發和架構經驗，10年分布式架構經驗。