作者 | 崔皓
審核 | 重樓
摘要
本文探討了大模型在本地部署的實踐方法，重點介紹了OpenAI的多模態、Function call 和 AI assistance 功能給AI開發者帶來的便利。文中著重討論了使用開源大模型，如Llama2和ChatGLM，來應對成本和數據安全性挑戰的策略。
文章以LocalGPT為例，詳細闡述了其安裝、使用及代碼實現，為讀者提供了關于如何將大模型成功集成到自己的應用系統中的寶貴經驗。
開篇
近年來，大模型的發展可謂日新月異，尤其是OpenAI發布的多模態、Function call以及AI assistance功能，為廣大AI開發者帶來了前所未有的便捷和創新空間。這些功能提升了模型的智能性和多樣性。然而，隨之而來的是一些企業對數據安全性的擔憂，以及調用GPT模型所需成本的問題。
面對這些挑戰，部分企業開始轉向開源的大模型，如Llama2和ChatGLM，在控制成本的同時，也保障了數據的私密性和安全性。然而，采用開源模型同樣面臨著新的問題：如何有效搭建這些模型，并將其順利接入到自己的應用系統中呢？這一過程中的技術挑戰和實際操作，將是我們接下來探討的重點。
本文將以開源架構LocalGPT為例，為您揭開本地部署大模型的神秘面紗，帶您深入了解其背后的具體技術和實施步驟。
大模型架構與工具
談到大模型本地化部署，市面上有很多流行的工具和架構，例如：Ollama、Chatchat和LocalGPT。Ollama是一種支持運行開源大型語言模型的工具，如Llama 2，它通過一個Modelfile將模型權重、配置和數據打包成單一程序包。這種方式優化了設置和配置細節，包括GPU的使用，豐富的模型庫，與langchain代碼實現無縫對接。本地化運行比較流程化。
Chatchat則是一種基于本地知識庫的問答應用，它利用LangChain的理念，旨在建立一套對中文場景與開源模型支持友好、可離線運行的知識庫問答解決方案。它受到了多個項目的啟發，通過使用FastChat接入多種模型，并依托于LangChain框架提供API調用服務。Chatchat的特點在于對中文支持的優化，這使得它特別受到中國企業本地化部署的青睞。
LocalGPT則是一個開源項目，允許用戶在不妥協隱私的情況下與文檔進行對話。它特別注重數據的安全性，確保所有數據都在用戶的計算機上處理。LocalGPT支持多種開源模型，包括HF、GPTQ、GGML和GGUF等，并提供多種嵌入選項。它的一個顯著特點是一旦下載了LLM，就可以重復使用而無需重復下載。LocalGPT的代碼簡單，非常適合進行學習和研究。通過對它的學習，我們可以理解如何創建基于RAG的企業知識庫。
雖然工具和架構各有特色，但是LocalGPT以簡單的代碼與清晰的思路成為程序員學習大模型本地部署的首選，后面的內容我們將以LocalGPT的源代碼為基礎來介紹它的實現與使用。
LocalGPT安裝與使用
LocalGPT是一個開源項目，它允許用戶在保護隱私的前提下與自己的文檔進行對話。這一項目在GitHub上獲得了17.5k的星標，所有操作均在本地完成，確保了數據的完全安全。LocalGPT的特點包括絕對隱私保護、支持多種開源模型、多樣化的嵌入選擇、一次下載后多次使用的大型語言模型、記錄聊天歷史以及提供用于構建RAG應用程序的API。此外，LocalGPT還提供了兩種圖形用戶界面，支持多平臺（包括CUDA、CPU和MPS）。
在技術細節實現方面，LocalGPT通過選擇合適的本地模型和利用LangChain的能力，可以在本地運行整個RAG流程，而且性能合理。ingest.py利用LangChain工具解析文檔并在本地使用InstructorEmbeddings創建嵌入，然后將結果存儲在本地的Chroma向量數據庫中。run_localGPT.py使用本地的大型語言模型來理解問題并創建答案，答案的上下文是通過相似性搜索從本地向量存儲中提取的。用戶可以將此本地大型語言模型替換為HuggingFace中的任何其他模型，只要確保所選模型符合HF格式。
LocalGPT安裝
1.環境設置
使用git克隆倉庫：
git clone https://github.com/PromtEngineer/localGPT.git安裝conda進行虛擬環境管理。創建并激活一個新的虛擬環境。
conda create -n localGPT python=3.10.0
conda activate localGPT2.使用pip安裝依賴項
為了設置環境以運行代碼，首先安裝所有要求的依賴：
pip install -r requirements.txt3.安裝LLAMA-CPP
LocalGPT使用LlamaCpp-Python用于GGML（需要llama-cpp-python <=0.1.76）和GGUF（llama-cpp-python >=0.1.83）模型。
如果想在llama-cpp中使用BLAS或Metal，您可以設置適當的標志：
支持NVIDIA GPU，使用cuBLAS
# 示例：cuBLAS
CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip install llama-cpp-python==0.1.83 --no-cache-dir支持Apple Metal (M1/M2)，使用
# 示例：METAL
CMAKE_ARGS="-DLLAMA_METAL=on" FORCE_CMAKE=1 pip install llama-cpp-python==0.1.83 --no-cache-dir導入知識庫文檔
將要上傳的文件放在SOURCE_DOCUMENTS文件夾中。可以在SOURCE_DOCUMENTS文件夾中放置多個文件夾，代碼會遞歸地讀取文件。
支持的文件格式方面，LocalGPT目前支持以下文件格式。LocalGPT使用LangChain加載這些文件格式。constants.py中的代碼使用DOCUMENT_MAP字典將文件格式映射到相應的加載器。為了添加對另一種文件格式的支持，只需在此字典中添加文件格式和LangChain中的相應加載器即可。
DOCUMENT_MAP = {
".txt": TextLoader,
".md": TextLoader,
".py": TextLoader,
".pdf": PDFMinerLoader,
".csv": CSVLoader,
".xls": UnstructuredExcelLoader,
".xlsx": UnstructuredExcelLoader,
".docx": Docx2txtLoader,
".doc": Docx2txtLoader,
}提取文件信息
如果系統上設置cuda，運行以下命令以攝取所有數據。
python ingest.py輸出如下：
使用device_type參數來指定特定設備。在CPU上運行：
python ingest.py --device_type cpu在M1/M2上運行：
python ingest.py --device_type mps使用help獲取支持設備的完整列表。
python ingest.py --help這將創建一個名為DB的新文件夾，并將其用于新創建的向量存儲。您可以攝取任意多的文檔，所有文檔都將累積在本地嵌入數據庫中。如果您想從一個空數據庫開始，刪除DB并重新攝取文檔。
注意：當您第一次運行時，需要互聯網連接下載嵌入模型（默認為Instructor Embedding）。在隨后的運行中，不會有數據離開您的本地環境，您可以在沒有互聯網連接的情況下攝取數據。
對知識庫提問
請運行以下命令進行聊天（默認情況下，它將在cuda上運行）。
python run_localGPT.py可以像ingest.py一樣指定設備類型。
python run_localGPT.py --device_type mps # 在Apple芯片上運行這將加載攝取的向量存儲和嵌入模型。您將看到一個提示：
> Enter a query：
輸入您的問題后，按回車鍵。LocalGPT將根據系統的硬件花費一些時間。您將得到如下響應。
一旦生成了答案，您可以再提出另一個問題，而無需重新運行腳本，只需再次等待提示。
注意：當您第一次運行時，需要互聯網連接下載LLM（默認為TheBloke/Llama-2-7b-Chat-GGUF）。在此之后，您可以關閉互聯網連接，腳本推理仍然會工作。沒有數據離開您的本地環境。
輸入exit以結束腳本。
GPU和VRAM要求
下表是根據不同模型的大小（億級參數）的VRAM要求。表中的估計值不包括嵌入模型使用的VRAM——這將額外使用2GB至7GB的VRAM，具體取決于模型。
我使用了4060筆記本版本的顯卡（8G顯存）進行的測試，大模型回應的速度在1分鐘左右，如果使用更好的顯卡這個速度應該還會提升。
LocalGPT 程序結構
在了解了LocalGPT的安裝和使用之后，我們來對核心代碼進行解析。如下圖所示，在項目代碼中我們將重要代碼部分使用紅色框出，并給大家介紹：
- SOURCE_DOCUMENTS 目錄下面是用來存放需要上傳的PDF文件，如果要將知識庫所需的文件上傳，必須先將文件放到這個目錄，然后再執行ingest.py 程序進行嵌入操作。
- Constants.py文件用來對程序常量進行定義，包括文件目錄，支持的文件類型，大模型的ID和名字等。
- Ingest.py 是用來嵌入文件到向量庫的代碼文件，也是后面我們要介紹的重點。
- Requirements.txt 文件用來保存安裝所需要的依賴包。
- Run_localGPT.py 文件是用來執行問答回應的代碼文件，在文件嵌入之后就通過它來向知識庫提問。后面會著重介紹。
- 另外localGPT_UI.py 和run_localGPT_API.py，前者是提供UI界面的問答程序，后者是提供問答服務的API。
Ingest.py 代碼解析
它的主要功能是從指定的源目錄加載文檔，將它們切割為適合處理的大小，并為這些文檔片段創建嵌入，最后將它們存儲在一個本地數據庫中。這是一個文檔處理和嵌入生成的完整流程，主要用于構建和管理大型文檔的知識庫。
1. 主要函數及其功能
load_single_document(file_path: str) -> Document：加載單個文檔。根據文件路徑和擴展名，使用相應的加載類來加載文檔。
load_document_batch(filepaths)：加載一批文檔。它創建一個線程池來并行加載多個文檔。
load_documents(source_dir: str) -> list[Document]：從源目錄加載所有文檔。它列出目錄中的所有文件，并根據文件擴展名決定是否加載。
split_documents(documents: list[Document]) -> tuple[list[Document], list[Document]]：將文檔分成兩組，一組是普通文本文檔，另一組是Python代碼文檔。
main(device_type)：主函數，負責初始化日志記錄，加載文檔，分割文檔，創建嵌入，并將結果持久化。
2. 函數調用關系
main() 是程序的入口點。它首先調用 load_documents() 來加載源目錄中的所有文檔。
在 load_documents() 內部，它通過調用 load_document_batch() 來加載文檔批次。每個文檔批次由 load_single_document() 加載。
加載并返回所有文檔后，main() 調用 split_documents() 將文檔分為文本和Python文檔。
main() 還創建了文檔的嵌入，并將這些嵌入以及原始文檔數據存儲在一個本地的Chroma數據庫中。
我們將幾個重要的函數展開給大家介紹如下：
def load_single_document(file_path: str) -> Document:
# Loads a single document from a file path
file_extension = os.path.splitext(file_path)[1]
loader_class = DOCUMENT_MAP.get(file_extension)
if loader_class:
loader = loader_class(file_path)
else:
raise ValueError("Document type is undefined")
return loader.load()[0]load_single_document 函數的目的是加載一個文件路徑指定的文檔。下面是對關鍵代碼的解釋：
1. file_extension = os.path.splitext(file_path)[1]:
將文件路徑分割為文件名和擴展名。os.path.splitext 是Python的一個標準庫函數，用于分割文件名和其擴展名。這里 [1] 表示提取分割后的第二部分，即文件的擴展名。
2. loader_class = DOCUMENT_MAP.get(file_extension):
-在 DOCUMENT_MAP 字典中查找與文件擴展名對應的加載類。DOCUMENT_MAP 應該是一個預定義的字典，其鍵為文件擴展名，值為相應的加載類。
3. if loader_class:
這是一個條件判斷。它檢查是否找到了與文件擴展名對應的加載類。如果找到了（即 loader_class 不為空），則執行下一步；否則，執行 else 部分的代碼。
如果找到了匹配的加載類，這行代碼將創建該類的實例。它將文件路徑作為參數傳遞給該類的構造函數，從而初始化一個新的加載器對象。if 條件不滿足時執行的，即如果沒有找到匹配的加載類，會引發一個 ValueError 異常，表明無法確定文件的文檔類型。
說了文件加載的函數再來看看Ingest.py的主函數， main 函數實現文件加載到嵌入的流程。它從源目錄加載文檔，將它們分割成更小的片段，并為這些片段創建嵌入，最后將這些信息存儲到本地數據庫中。下面是對關鍵代碼的解釋：
def main(device_type):
# Load documents and split in chunks
logging.info(f"Loading documents from {SOURCE_DIRECTORY}")
#加載文檔
documents = load_documents(SOURCE_DIRECTORY)
#切割文檔
text_documents, python_documents = split_documents(documents)
#切割文檔的方式
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
python_splitter = RecursiveCharacterTextSplitter.from_language(
language=Language.PYTHON, chunk_size=880, chunk_overlap=200
)
texts = text_splitter.split_documents(text_documents)
texts.extend(python_splitter.split_documents(python_documents))
logging.info(f"Loaded {len(documents)} documents from {SOURCE_DIRECTORY}")
logging.info(f"Split into {len(texts)} chunks of text")
# Create embeddings
embeddings = HuggingFaceInstructEmbeddings(
model_name=EMBEDDING_MODEL_NAME,
model_kwargs={"device": device_type},
)
db = Chroma.from_documents(
texts,
embeddings,
persist_directory=PERSIST_DIRECTORY,
client_settings=CHROMA_SETTINGS,
)
db.persist()
db = None1. documents = load_documents(SOURCE_DIRECTORY):
調用 load_documents 函數，從 SOURCE_DIRECTORY 指定的目錄中加載所有文檔。這個函數返回一個文檔對象的列表。
2. text_documents, python_documents = split_documents(documents):
調用 split_documents 函數，將加載的文檔分成兩類：一類是普通文本文檔，另一類是Python代碼文檔。這有助于后續根據文檔類型采取不同的處理策略。
3. 創建 RecursiveCharacterTextSplitter 實例:
text_splitter 和 python_splitter 是用于分割文檔的實例。text_splitter 用于普通文本，而 python_splitter 專門用于Python代碼。它們通過設置 chunk_size 和 chunk_overlap 來定義文檔切割的大小和重疊部分。
4. texts = text_splitter.split_documents(text_documents):
使用 text_splitter 對普通文本文檔進行分割，結果存儲在 texts 列表中。
5. texts.extend(python_splitter.split_documents(python_documents)):
使用 python_splitter 對Python代碼文檔進行分割，并將這些分割后的文檔追加到 texts 列表中。
6. embeddings = HuggingFaceInstructEmbeddings(...):
創建 HuggingFaceInstructEmbeddings 的實例，用于生成文檔片段的嵌入。這里使用了模型名稱和設備類型作為參數。
7. db = Chroma.from_documents(...):
使用 Chroma 類的 from_documents 方法創建一個數據庫實例。它接受分割后的文檔片段、嵌入、持久化目錄和客戶端設置作為參數。
8. db.persist():
調用 persist 方法將數據庫中的數據持久化到本地存儲。
run_localGPT.py代碼解析
這個代碼實現文件現了一個基于大型語言模型的問答系統，涵蓋了從模型加載到問答處理的整個流程。首先，它通過 load_model 函數根據設備類型和模型標識符加載和配置適合文本生成的模型。接著，在 main 函數中，系統初始化嵌入模型和向量存儲，設置了一個基于模板的問答鏈，用于處理用戶查詢并生成回答。此外，系統提供了一個交互式界面，允許用戶輸入問題并接收相應的答案，同時還能展示回答的相關文檔，這一功能的啟用取決于用戶的選擇。整個系統通過精心的配置和日志記錄，為用戶提供了一個高效、可定制的問答體驗。接下來，我們圍繞兩個重要函數load_model和main 函數展開說明。
Load_model函數
def load_model(device_type, model_id, model_basename=None):
logging.info(f"Loading Model: {model_id}, on: {device_type}")
logging.info("This action can take a few minutes!")
if model_basename is not None:
if ".ggml" in model_basename:
logging.info("Using Llamacpp for GGML quantized models")
model_path = hf_hub_download(repo_id=model_id, filename=model_basename)
max_ctx_size = 4048
kwargs = {
"model_path": model_path,
"n_ctx": max_ctx_size,
"max_tokens": max_ctx_size,
}
if device_type.lower() == "mps":
kwargs["n_gpu_layers"] = 1000
if device_type.lower() == "cuda":
kwargs["n_gpu_layers"] = 1000
kwargs["n_batch"] = max_ctx_size
return LlamaCpp(kwargs)
else:
# The code supports all huggingface models that ends with GPTQ and have some variation
# of .no-act.order or .safetensors in their HF repo.
logging.info("Using AutoGPTQForCausalLM for quantized models")
if ".safetensors" in model_basename:
# Remove the ".safetensors" ending if present
model_basename = model_basename.replace(".safetensors", "")
tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True)
logging.info("Tokenizer loaded")
model = AutoGPTQForCausalLM.from_quantized(
model_id,
model_basename=model_basename,
use_safetensors=True,
trust_remote_code=True,
device="cuda:0",
use_triton=False,
quantize_config=None,
)
elif (
device_type.lower() == "cuda"
):
logging.info("Using AutoModelForCausalLM for full models")
tokenizer = AutoTokenizer.from_pretrained(model_id)
logging.info("Tokenizer loaded")
model = AutoModelForCausalLM.from_pretrained(
model_id,
device_map="auto",
torch_dtype=torch.float16,
low_cpu_mem_usage=True,
trust_remote_code=True,
)
model.tie_weights()
else:
logging.info("Using LlamaTokenizer")
tokenizer = LlamaTokenizer.from_pretrained(model_id)
model = LlamaForCausalLM.from_pretrained(model_id)
generation_config = GenerationConfig.from_pretrained(model_id)
pipe = pipeline(
"text-generation",
model=model,
tokenizer=tokenizer,
max_length=4048,
temperature=0,
top_p=0.95,
repetition_penalty=1.15,
generation_config=generation_config,
)
local_llm = HuggingFacePipeline(pipeline=pipe)
logging.info("Local LLM Loaded")
return local_llmload_model 的函數，用于加載和配置用于文本生成的大型語言模型（LLM）。這里是對函數中關鍵部分的解釋：
1. 函數參數:
device_type：指定運行模型的設備類型（如 "cuda" 或 "cpu"）。
model_id：指定要從HuggingFace模型庫中加載的模型的標識符。
model_basename (可選)：如果使用量化模型，則指定模型的基本名稱。
2. 模型加載邏輯:
如果 model_basename 不為 None，則根據模型文件名的不同，選擇不同的加載方式：
- 對于文件名包含 ".ggml" 的量化模型，使用 LlamaCpp 加載。
- 對于文件名包含 ".safetensors" 的量化模型，使用AutoGPTQForCausalLM 加載。
如果 device_type 為 "cuda"，則使用 AutoModelForCausalLM 加載完整的模型。
如果不符合上述條件，使用 LlamaTokenizer 和 LlamaForCausalLM 加載模型。
3. 模型配置:
使用 GenerationConfig 來加載模型的配置，以避免警告。
創建 pipeline 對象用于文本生成，配置包括模型、分詞器、最大長度、溫度、top_p 參數等。
4. 返回值:
函數返回一個 HuggingFacePipeline 對象，該對象封裝了配置好的文本生成管道。
Load_model函數顧名思義是用來裝載大模型的，在run_localGPT.py的main函數中會調用到Load_mode，接下來我們來看main函數的主要內容。
main 函數實現了一個基于大型語言模型（LLM）的信息檢索和問答任務。函數首先根據設備類型加載一個嵌入模型，這可能是 HuggingFaceInstructEmbeddings 或 HuggingFaceEmbeddings。接著，它加載了之前由 inget.py 腳本創建的向量存儲，這是用于文檔檢索的關鍵部分。使用 load_model 函數，函數加載了本地的LLM，支持多種不同的LLM。然后，它設置了一個問答檢索鏈，使用預定義的提示模板和對話緩存來處理用戶的查詢。用戶可以通過命令行輸入查詢，函數將使用LLM和文檔檢索系統來生成答案，并選擇性地顯示回答的源文檔。這個過程既是交互式的，也是動態的，允許用戶以自然語言的形式探索信息和知識庫。整個流程展示了如何將嵌入模型、大型語言模型和文檔檢索相結合，實現一個功能豐富的問答系統。
def main(device_type, show_sources):
logging.info(f"Running on: {device_type}")
logging.info(f"Display Source Documents set to: {show_sources}")
embeddings = HuggingFaceInstructEmbeddings(model_name=EMBEDDING_MODEL_NAME, model_kwargs={"device": device_type})
# uncomment the following line if you used HuggingFaceEmbeddings in the ingest.py
# embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL_NAME)
# load the vectorstore
db = Chroma(
persist_directory=PERSIST_DIRECTORY,
embedding_function=embeddings,
client_settings=CHROMA_SETTINGS,
)
retriever = db.as_retriever()
template = """Use the following pieces of context to answer the question at the end. If you don't know the answer,\
just say that you don't know, don't try to make up an answer.
{context}
{history}
Question: {question}
Helpful Answer:"""
prompt = PromptTemplate(input_variables=["history", "context", "question"], template=template)
memory = ConversationBufferMemory(input_key="question", memory_key="history")
llm = load_model(device_type, model_id=MODEL_ID, model_basename=MODEL_BASENAME)
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
return_source_documents=True,
chain_type_kwargs={"prompt": prompt, "memory": memory},
)
# Interactive questions and answers
while True:
query = input("\nEnter a query: ")
if query == "exit":
break
# Get the answer from the chain
res = qa(query)
answer, docs = res["result"], res["source_documents"]
# Print the result
print("\n\n> Question:")
print(query)
print("\n> Answer:")
print(answer)
if show_sources: # this is a flag that you can set to disable showing answers.
# # Print the relevant sources used for the answer
print("----------------------------------SOURCE DOCUMENTS---------------------------")
for document in docs:
print("\n> " + document.metadata["source"] + ":")
print(document.page_content)
print("----------------------------------SOURCE DOCUMENTS---------------------------")main 函數構建了一個基于大型語言模型（LLM）的信息檢索和問答系統。以下是對代碼的關鍵部分的解釋：
1. 初始化和設置:
Embeddings：加載用于文檔嵌入的模型，這里使用的是 HuggingFaceInstructEmbeddings。
db: 加載由 inget.py 腳本創建的向量存儲 Chroma，它用于后續的文檔檢索任務。
2. 問答鏈設置:
template: 定義一個提示模板，用于格式化問答的上下文、歷史記錄和問題。
prompt: 創建一個 PromptTemplate 實例，它將用于生成向語言模型提交的最終提示。
memory: 實例化 ConversationBufferMemory，用于在問答過程中保持對話歷史的緩存。
3. 加載語言模型:
llm: 使用 load_model 函數加載本地的大型語言模型，這個函數支持不同類型的模型和設備。
4. 問答邏輯實現:
qa: 實例化一個 RetrievalQA 對象，它結合了LLM和文檔檢索器來實現問答功能。
在一個循環中，系統接收用戶輸入的查詢，使用 qa 對象處理這些查詢，并輸出相應的答案。
5. 交互和顯示:
用戶可以通過命令行輸入問題，系統根據用戶輸入的查詢提供答案。
如果設置了 show_sources 標志，系統還會顯示生成答案時參考的源文檔。
constants.py 代碼解析
說完了Ingest.py和run_localGPT.py，大家對localGPT的主要功能有所了解了，實際上Ingest.py用來執行文檔的嵌入和存儲，run_localGPT.py用來執行具體的問答工作，利用事先存儲的向量庫進行問題的搜索，然后通過大模型進行回應。不過這兩塊代碼中始終沒有出現具體的大模型，這個定義保存在constants.py 文件中，該文件中除了定義了調用的模型之外，還定了加載文件的類型以及嵌入的方式。代碼如下：
DOCUMENT_MAP = {
".txt": TextLoader,
".md": TextLoader,
".py": TextLoader,
".pdf": PDFMinerLoader,
".csv": CSVLoader,
".xls": UnstructuredExcelLoader,
".xlsx": UnstructuredExcelLoader,
".docx": Docx2txtLoader,
".doc": Docx2txtLoader,
}
#默認的嵌入方式
# Default Instructor Model
EMBEDDING_MODEL_NAME = "hkunlp/instructor-large"
#模型的ID 和名字
MODEL_ID = "TheBloke/Llama-2-7B-Chat-GGML"
MODEL_BASENAME = "llama-2-7b-chat.ggmlv3.q4_0.bin"一般而言，模型的信息包括MODEL_ID的MODEL_BASENAME，這塊的信息可以通過Hugging Face 查找獲得。Hugging Face是一家專注于自然語言處理（NLP）的AI研究公司，提供大量預訓練模型和工具，廣泛用于文本理解和生成任務。最重要的是它提供了一個大模型的平臺，讓廣大網友可以上傳自己調優的模型。
如下圖所示，可以登陸huggingface.co網站，在首頁的搜索框中輸入想要的模型，它會自動模糊匹配相關的模型。
在選擇模型之后，會進入如下頁面，通過模型詳情頁面的“Files and versions”tab頁，可以看到模型的ID，圖中的ID為“TheBloke/Llama-2-7B-Chat-GGML”，同時可以看到需要下載的模型文件。這里選擇bin 文件，如果模型存在多個下載文件，選擇第一個，本例中我們選擇“llama-2-7b-chat.ggmlv3.q4_0.bin”，這樣load_model函數會自動從huggingface 上下載定義好的模型文件。
總結
本文展示了大模型本地部署的全過程，包括模型選擇、配置、以及與應用的集成。通過對LocalGPT的細致解讀，文章不僅展示了技術的實用性，也為有意采用大模型的企業和開發者提供了一條清晰的實施路徑。這些深入的分析和實例指導，對于那些尋求在數據安全性和成本效益之間找到平衡點的企業來說，尤為寶貴。
作者介紹
崔皓，51CTO社區編輯，資深架構師，擁有18年的軟件開發和架構經驗，10年分布式架構經驗。
