tnblog
首页
视频
资源
登录
原

Ollama 离线 Llama 2大语言模型的安装

18555人阅读 2023/8/22 18:20 总访问：3455468 评论：0 收藏：0 手机
分类: .net后台框架

Ollama 离线 Llama 2大语言模型的安装

Llama 2


Llama 2是由于Meta旗下开发的一款AI大语言模型，要把它跑起来是需要很多CPU、GPU等硬件资源。

Ollama简介


简单来说它相当于上面的缩减版。
它实现了本地运行Llama 2的实现方案，它通过一些模型文件Ollama打包、模型、权重、配置包，包括GPU的使用做了一定的优化。
另外LangChain也对其做了集成。

相关链接：https://ollama.ai/
https://github.com/jmorganca/ollama
https://python.langchain.com/docs/integrations/llms/ollama

Ollama下载


目前Ollama对于Mac可以进行直接安装，对于其他操作系统需要进行编译。

Mac安装


直接点击Ollama主页的安装下载安装包即可，然后进行解压，双击就完成应用到本地。


打开后我们点击next，再点击install进行Ollama命令行的安装。


然后我们需要选择我们的模型，这里我们就使用常规的模型进行安装就好了。
模型的规格如下：


打开我们的命令行执行如下命令。

  1. # 下载模型
  2. ollama run llama2
  3. # 查看进程
  4. ps -ef |grep ollama
  5. # 查看对外暴露的端口
  6. lsof -i :11434


左边我们可以看到Ollama的模型已经下载完成了，右边我们可以看到它启动的进程以及ollama开放的11434端口。这样我们就算安装完成了。

Windows安装


拉下源代码码后执行如下脚本进行编译与安装。

  1. go build .
  2. ./ollama serve &
  3. ./ollama run llama2


这样就完成安装了。

断网测试


我们在不联网的情况下进行测试它能否回答我们的一些问题。


可以说是很厉害了，接下来我们可以尝试通过API的方式来进行调用。

  1. curl -X POST http://localhost:11434/api/generate -d '{
  2.   "model": "llama2",
  3.   "prompt":"Why is the sky blue?"
  4. }'

LangChain调用

安装依赖

  1. # 首先安装虚拟环境
  2. python -m venv venv
  3. # 激活虚拟环境
  4. source venv/bin/activate
  5. # 安装requirements.txt相关依赖包
  6. pip install -r requirements.txt


关于requirements.txt下的相关依赖如下（其实不需要这么多但后续还有其他实验要做）：

  1. absl-py==1.4.0
  2. aiohttp==3.8.5
  3. aiosignal==1.3.1
  4. anyio==3.7.1
  5. astunparse==1.6.3
  6. async-timeout==4.0.3
  7. attrs==23.1.0
  8. backoff==2.2.1
  9. beautifulsoup4==4.12.2
  10. bs4==0.0.1
  11. cachetools==5.3.1
  12. certifi==2023.7.22
  13. cffi==1.15.1
  14. chardet==5.2.0
  15. charset-normalizer==3.2.0
  16. Chroma==0.2.0
  17. chroma-hnswlib==0.7.2
  18. chromadb==0.4.5
  19. click==8.1.6
  20. coloredlogs==15.0.1
  21. cryptography==41.0.3
  22. dataclasses-json==0.5.14
  23. fastapi==0.99.1
  24. filetype==1.2.0
  25. flatbuffers==23.5.26
  26. frozenlist==1.4.0
  27. gast==0.4.0
  28. google-auth==2.22.0
  29. google-auth-oauthlib==1.0.0
  30. google-pasta==0.2.0
  31. gpt4all==1.0.8
  32. grpcio==1.57.0
  33. h11==0.14.0
  34. h5py==3.9.0
  35. httptools==0.6.0
  36. humanfriendly==10.0
  37. idna==3.4
  38. importlib-resources==6.0.1
  39. joblib==1.3.2
  40. keras==2.13.1
  41. langchain==0.0.261
  42. langsmith==0.0.21
  43. libclang==16.0.6
  44. lxml==4.9.3
  45. Markdown==3.4.4
  46. MarkupSafe==2.1.3
  47. marshmallow==3.20.1
  48. monotonic==1.6
  49. mpmath==1.3.0
  50. multidict==6.0.4
  51. mypy-extensions==1.0.0
  52. nltk==3.8.1
  53. numexpr==2.8.5
  54. numpy==1.24.3
  55. oauthlib==3.2.2
  56. onnxruntime==1.15.1
  57. openapi-schema-pydantic==1.2.4
  58. opt-einsum==3.3.0
  59. overrides==7.4.0
  60. packaging==23.1
  61. pdf2image==1.16.3
  62. pdfminer==20191125
  63. pdfminer.six==20221105
  64. Pillow==10.0.0
  65. posthog==3.0.1
  66. protobuf==4.24.0
  67. pulsar-client==3.2.0
  68. pyasn1==0.5.0
  69. pyasn1-modules==0.3.0
  70. pycparser==2.21
  71. pycryptodome==3.18.0
  72. pydantic==1.10.12
  73. PyPika==0.48.9
  74. python-dateutil==2.8.2
  75. python-dotenv==1.0.0
  76. python-magic==0.4.27
  77. PyYAML==6.0.1
  78. regex==2023.8.8
  79. requests==2.31.0
  80. requests-oauthlib==1.3.1
  81. rsa==4.9
  82. six==1.16.0
  83. sniffio==1.3.0
  84. soupsieve==2.4.1
  85. SQLAlchemy==2.0.19
  86. starlette==0.27.0
  87. sympy==1.12
  88. tabulate==0.9.0
  89. tenacity==8.2.2
  90. tensorboard==2.13.0
  91. tensorboard-data-server==0.7.1
  92. tensorflow==2.13.0
  93. tensorflow-estimator==2.13.0
  94. tensorflow-hub==0.14.0
  95. termcolor==2.3.0
  96. tokenizers==0.13.3
  97. tqdm==4.66.1
  98. typing-inspect==0.9.0
  99. typing_extensions==4.5.0
  100. unstructured==0.9.2
  101. urllib3==1.26.16
  102. uvicorn==0.23.2
  103. uvloop==0.17.0
  104. watchfiles==0.19.0
  105. websockets==11.0.3
  106. Werkzeug==2.3.6
  107. wrapt==1.15.0
  108. yarl==1.9.2

注意：安装chroma-hnswlib可能会出现问题。可以参考我这篇博客：https://www.tnblog.net/hb/article/details/8203

简单实践


我们创建一个main.py文件，并通过无限循环输入我们的问题，然后去调用Ollama的接口，代码如下：

  1. # 设置Ollama的地址
  2. ollama_host = "localhost"
  3. # 设置Ollama的端口
  4. ollama_port = 11434
  5. # 设置Ollama的模型
  6. ollama_model = "llama2"
  8. from langchain.llms import Ollama
  9. from langchain.callbacks.manager import CallbackManager
  10. from langchain.callbacks.streaming_stdout import StreamingStdOutCallHandler
  12. if __name__ == "__main__":
  13.     # 通过API的方式调用Ollama
  14.     # StreamingStdOutCallbackHandler 使用流式输出结果
  15.     llm = Ollama(base_url=f"http://{ollama_host}:{ollama_port}", 
  16.         model=ollama_model,
  17.         callback_manager=CallbackManager([StreamingStdOutCallHandler()])
  18.         )
  20.     # 通过命令行的方式调用Ollama
  21.     while True:
  22.         query = input("\n\n Enter a query: ")
  23.         llm(query)
  1. # 运行代码
  2. python main.py
  3. # 我的python版本3.10.x

在线文档训练


我们通过官网的案例对在线的某个pdf进行分析，代码如下：

  1. from langchain.document_loaders import OnlinePDFLoader
  2. from langchain.vectorstores import Chroma
  3. from langchain.embeddings import GPT4AllEmbeddings
  4. from langchain import PromptTemplate
  5. from langchain.llms import Ollama
  6. from langchain.callbacks.manager import CallbackManager
  7. from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
  8. from langchain.chains import RetrievalQA
  9. import sys
  10. import os
  12. class SuppressStdout:
  13.     # __enter__ 最先开始的时候会执行一次
  14.     def __enter__(self):
  15.         self._original_stdout = sys.stdout
  16.         self._original_stderr = sys.stderr
  17.         sys.stdout = open(os.devnull, 'w')
  18.         sys.stderr = open(os.devnull, 'w')
  19.     # __exit__ 最后执行一次
  20.     def __exit__(self, exc_type, exc_val, exc_tb):
  21.         sys.stdout.close()
  22.         sys.stdout = self._original_stdout
  23.         sys.stderr = self._original_stderr
  25. # 加载在线pdf并将其分成块
  26. loader = OnlinePDFLoader("https://d18rn0p25nwr6d.cloudfront.net/CIK-0001813756/975b3e9b-268e-4798-a9e4-2a9a7c92dc10.pdf")
  27. data = loader.load()
  29. # RecursiveCharacterTextSplitter是一个基于递归的字符级别的分词器。它可以将文本逐个字符地拆分，并且可以递归地处理包含其他词汇的字符，例如中文中的词语或日语中的汉字。
  30. from langchain.text_splitter import RecursiveCharacterTextSplitter
  31. # chunk_size 设置为分割块的大小
  32. # chunk_overlap 设置每个分割块之间重叠的字符数。
  33. text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
  34. all_splits = text_splitter.split_documents(data)
  36. # 使用Chroma数据库进行存储所有的分片，使用的分片方式是GPT4ALL
  37. with SuppressStdout():
  38.     vectorstore = Chroma.from_documents(documents=all_splits, embedding=GPT4AllEmbeddings())
  40. while True:
  41.     query = input("\nQuery: ")
  42.     # 退出设置
  43.     if query == "exit":
  44.         break
  45.     # 收到空字符串将进行跳过
  46.     if query.strip() == "":
  47.         continue
  49.     # Prompt 设置回答的规则模版
  50.     template = """Use the following pieces of context to answer the question at the end. 
  51.     If you don't know the answer, just say that you don't know, don't try to make up an answer. 
  52.     Use three sentences maximum and keep the answer as concise as possible. 
  53.     {context}
  54.     Question: {question}
  55.     Helpful Answer:"""
  56.     # 通过Prompt模版生成完整语句
  57.     QA_CHAIN_PROMPT = PromptTemplate(
  58.         input_variables=["context", "question"],
  59.         template=template,
  60.     )
  61.     # 开始调用
  62.     llm = Ollama(model="llama2", callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]))
  63.     # llm = Ollama(model="llama2:13b", callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]))
  64.     # 通过设置大语言模型、向量存储和prompt创建一个QA链进行回答
  65.     qa_chain = RetrievalQA.from_chain_type(
  66.         llm,
  67.         retriever=vectorstore.as_retriever(),
  68.         chain_type_kwargs={"prompt": QA_CHAIN_PROMPT},
  69.     )
  71.     result = qa_chain({"query": query})


通过下面的命令启动项目运行代码。

  1. python document_start.py

注意：可能会报错如下图所示。

其实是证书问题导致的，所以我们只需要更新一下我们的证书就好。

  1. # 执行这个代码
  2. /Applications/Python\ 3.10/Install\ Certificates.command


运行成功后，我们提问一下该pdf中相关的内容，我们发现回答的一般。大家可以再多调整调整。


我又换了另外一个自己的pdf进行了一下测试，感觉还是挺不错的就是有点慢，可能我的电脑还是菜了点。

支持多种的不同文件


首先我们创建一个source_documents文件夹，将我们需要训练的文件放入其中。
然后创建一个constants.py文件作为设置的全局变量。

  1. import os
  2. from chromadb.config import Settings
  4. # 定义用于存储数据库的文件夹
  5. PERSIST_DIRECTORY = os.environ.get('PERSIST_DIRECTORY', 'db')
  7. # 定义Chroma设置
  8. CHROMA_SETTINGS = Settings(
  9.         chroma_db_impl='duckdb+parquet',
  10.         persist_directory=PERSIST_DIRECTORY,
  11.         anonymized_telemetry=False
  12. )


然后创建一个document_full.py编写我们的代码。

  1. #!/usr/bin/env python3
  2. import os
  3. import glob
  4. from typing import List
  5. from multiprocessing import Pool
  6. from tqdm import tqdm
  8. # langchain加载
  9. from langchain.document_loaders import (
  10.     # 从csv文件中加载文档
  11.     CSVLoader,
  12.     # 从EverNote文件中加载文档
  13.     EverNoteLoader,
  14.     # 从PyMuPDF文件中加载文档
  15.     PyMuPDFLoader,
  16.     # 从文本文件中加载文档
  17.     TextLoader,
  18.     # 从电子邮件中加载文档
  19.     UnstructuredEmailLoader,
  20.     # 从EPub文件中加载文档
  21.     UnstructuredEPubLoader,
  22.     # 从HTML文件中加载文档
  23.     UnstructuredHTMLLoader,
  24.     # 从Markdown文件中加载文档
  25.     UnstructuredMarkdownLoader,
  26.     # 从ODT文件中加载文档
  27.     UnstructuredODTLoader,
  28.     # 从PowerPoint文件中加载文档
  29.     UnstructuredPowerPointLoader,
  30.     # 从Word文件中加载文档
  31.     UnstructuredWordDocumentLoader,
  32. )
  34. # langchain加载分词器
  35. from langchain.text_splitter import RecursiveCharacterTextSplitter
  36. from langchain.vectorstores import Chroma
  37. from langchain.embeddings import HuggingFaceEmbeddings
  38. from langchain.docstore.document import Document
  39. from constants import CHROMA_SETTINGS
  42. #?加载环境变量
  43. # 数据库
  44. persist_directory = os.environ.get('PERSIST_DIRECTORY', 'db')
  45. # 源目录
  46. source_directory = os.environ.get('SOURCE_DIRECTORY', 'source_documents')
  47. # 模型名称 嵌入模型名称
  48. embeddings_model_name = os.environ.get('EMBEDDINGS_MODEL_NAME', 'all-MiniLM-L6-v2')
  49. chunk_size = 500
  50. chunk_overlap = 50
  52. # 加载电子邮件并将其转换为文档对象列表
  53. # 默认值不起作用时回退到text/plain的包装器
  54. class MyElmLoader(UnstructuredEmailLoader):
  55.     """Wrapper to fallback to text/plain when default does not work"""
  57.     def load(self) -> List[Document]:
  58.         """Wrapper adding fallback for elm without html"""
  59.         try:
  60.             try:
  61.                 doc = UnstructuredEmailLoader.load(self)
  62.             except ValueError as e:
  63.                 if 'text/html content not found in email' in str(e):
  64.                     # 报错后如果为内容没有找到文件，将尝试转为文本
  65.                     self.unstructured_kwargs["content_source"]="text/plain"
  66.                     doc = UnstructuredEmailLoader.load(self)
  67.                 else:
  68.                     raise
  69.         except Exception as e:
  70.             # 将文件路径添加到异常消息
  71.             raise type(e)(f"{self.file_path}: {e}") from e
  73.         return doc
  76. # 将文件扩展名映射到文档加载程序及其参数
  77. LOADER_MAPPING = {
  78.     ".csv": (CSVLoader, {}),
  79.     # ".docx": (Docx2txtLoader, {}),
  80.     ".doc": (UnstructuredWordDocumentLoader, {}),
  81.     ".docx": (UnstructuredWordDocumentLoader, {}),
  82.     ".enex": (EverNoteLoader, {}),
  83.     ".eml": (MyElmLoader, {}),
  84.     ".epub": (UnstructuredEPubLoader, {}),
  85.     ".html": (UnstructuredHTMLLoader, {}),
  86.     ".md": (UnstructuredMarkdownLoader, {}),
  87.     ".odt": (UnstructuredODTLoader, {}),
  88.     ".pdf": (PyMuPDFLoader, {}),
  89.     ".ppt": (UnstructuredPowerPointLoader, {}),
  90.     ".pptx": (UnstructuredPowerPointLoader, {}),
  91.     ".txt": (TextLoader, {"encoding": "utf8"}),
  92.     # 根据需要为其他文件扩展名和加载程序添加更多映射
  93. }
  95. # 根据文件扩展名加载单个文档
  96. def load_single_document(file_path: str) -> List[Document]:
  97.     ext = "." + file_path.rsplit(".", 1)[-1]
  98.     if ext in LOADER_MAPPING:
  99.         loader_class, loader_args = LOADER_MAPPING[ext]
  100.         loader = loader_class(file_path, **loader_args)
  101.         return loader.load()
  103.     raise ValueError(f"Unsupported file extension '{ext}'")
  105. # 加载所有文档
  106. def load_documents(source_dir: str, ignored_files: List[str] = []) -> List[Document]:
  107.     """
  108.     Loads all documents from the source documents directory, ignoring specified files
  109.     """
  110.     all_files = []
  111.     for ext in LOADER_MAPPING:
  112.         # 递归加载所有文件
  113.         # glob.glob() 方法用于查找匹配的文件路径名列表
  114.         all_files.extend(
  115.             glob.glob(os.path.join(source_dir, f"**/*{ext}"), recursive=True)
  116.         )
  117.     # 对于 all_files 列表中的每个元素 file_path，如果 file_path 不在 ignored_files 列表中，则将 file_path 添加到新的列表 filtered_files 中。
  118.     filtered_files = [file_path for file_path in all_files if file_path not in ignored_files]
  120.     # 使用多进程加载文档
  121.     with Pool(processes=os.cpu_count()) as pool:
  122.         # 用于存储每个文档加载的结果
  123.         results = []
  124.         # 创建了一个 tqdm 进度条对象 pbar，它的总长度为 filtered_files 的长度，描述为 Loading new documents，进度条的宽度为 80。
  125.         with tqdm(total=len(filtered_files), desc='Loading new documents', ncols=80) as pbar:
  126.             # imap_unordered() 方法返回一个迭代器，它会在进程池中的多个进程上并行地对 iterable 中的元素调用 function。
  127.             for i, docs in enumerate(pool.imap_unordered(load_single_document, filtered_files)):
  128.                 # 将每个文档加载的结果添加到 results 列表中
  129.                 results.extend(docs)
  130.                 # 更新进度条
  131.                 pbar.update()
  133.     return results
  135. # 加载文档并将其拆分为块
  136. def process_documents(ignored_files: List[str] = []) -> List[Document]:
  137.     """
  138.     Load documents and split in chunks
  139.     """
  140.     print(f"Loading documents from {source_directory}")
  141.     # 加载文档
  142.     documents = load_documents(source_directory, ignored_files)
  143.     if not documents:
  144.         print("No new documents to load")
  145.         exit(0)
  146.     print(f"Loaded {len(documents)} new documents from {source_directory}")
  147.     # 创建文本拆分器
  148.     text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
  149.     # 拆分文档
  150.     texts = text_splitter.split_documents(documents)
  151.     print(f"Split into {len(texts)} chunks of text (max. {chunk_size} tokens each)")
  152.     return texts
  154. # 检查 vectorstore 是否存在
  155. def does_vectorstore_exist(persist_directory: str) -> bool:
  156.     """
  157.     Checks if vectorstore exists
  158.     """
  159.     # 检查是否存在 index 文件夹
  160.     if os.path.exists(os.path.join(persist_directory, 'index')):
  161.         # 检查是否存在 chroma-collections.parquet 和 chroma-embeddings.parquet 文件
  162.         if os.path.exists(os.path.join(persist_directory, 'chroma-collections.parquet')) and os.path.exists(os.path.join(persist_directory, 'chroma-embeddings.parquet')):
  163.             # 检查是否存在 index 文件夹下的文件
  164.             list_index_files = glob.glob(os.path.join(persist_directory, 'index/*.bin'))
  165.             list_index_files += glob.glob(os.path.join(persist_directory, 'index/*.pkl'))
  166.             # 一个工作向量库至少需要3个文档
  167.             if len(list_index_files) > 3:
  168.                 return True
  169.     return False
  171. def main():
  172.     # 创建嵌入模型，HuggingFaceEmbeddings 是一个包装器，用于从 HuggingFace 模型中提取嵌入
  173.     embeddings = HuggingFaceEmbeddings(model_name=embeddings_model_name)
  174.     # 检查 vectorstore 是否存在
  175.     if does_vectorstore_exist(persist_directory):
  176.         # 更新并存储本地vectorstore
  177.         print(f"Appending to existing vectorstore at {persist_directory}")
  178.         # 更新 "Chroma" 数据库实例，其中 persist_directory 是数据库的持久化目录，embedding_function 是用于生成文本嵌入的函数，client_settings 是客户端的配置设置。
  179.         db = Chroma(persist_directory=persist_directory, embedding_function=embeddings, client_settings=CHROMA_SETTINGS)
  180.         # 通过调用 db.get() 方法获取数据库中的数据。
  181.         collection = db.get()
  182.         # 从获取到的数据中，提取出 metadatas 字段中的 source 字段，并将这些字段作为参数传递给 process_documents 函数。
  183.         texts = process_documents([metadata['source'] for metadata in collection['metadatas']])
  184.         print(f"Creating embeddings. May take some minutes...")
  185.         db.add_documents(texts)
  186.     else:
  187.         # 创建并存储本地矢量存储
  188.         print("Creating new vectorstore")
  189.         texts = process_documents()
  190.         print(f"Creating embeddings. May take some minutes...")
  191.         db = Chroma.from_documents(texts, embeddings, persist_directory=persist_directory, client_settings=CHROMA_SETTINGS)
  192.     db.persist()
  193.     db = None
  195.     print(f"Ingestion complete! You can now run privateGPT.py to query your documents")
  198. if __name__ == "__main__":
  199.     main()


然后安装相关依赖包。

  1. pip install sentence_transformers
  2. pip install pymupdf


最后开始运行并测试，需要注意的是第一次需要下载和加载模型需要很久。

  1. python document_full.py


再次遇到问题，是由于Chroma的配置被弃用了，换个低版本就可以了。

  1. pip install --upgrade chromadb==0.3.29
  2. # 参考链接：https://github.com/imartinez/privateGPT/issues/869


安装llama2-uncensored模型。

  1. ollama pull llama2-uncensored


编写privateGPT.py，用于运行我们训练好的模型。

  1. #!/usr/bin/env python3
  2. from langchain.chains import RetrievalQA
  3. from langchain.embeddings import HuggingFaceEmbeddings
  4. from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
  5. from langchain.vectorstores import Chroma
  6. from langchain.llms import Ollama
  7. import os
  8. import argparse
  9. import time
  11. model = os.environ.get("MODEL", "llama2-uncensored")
  12. # 对于嵌入模型，该示例使用句子转换器模型
  13. # https://www.sbert.net/docs/pretrained_models.html
  14. # 全mpnet-base-v2型号提供了最好的质量，而全MiniLM-L6-v2速度快了5倍，仍然提供了良好的质量。
  15. embeddings_model_name = os.environ.get("EMBEDDINGS_MODEL_NAME", "all-MiniLM-L6-v2")
  16. persist_directory = os.environ.get("PERSIST_DIRECTORY", "db")
  17. target_source_chunks = int(os.environ.get('TARGET_SOURCE_CHUNKS',4))
  19. from constants import CHROMA_SETTINGS
  21. def main():
  22.     # 分析命令行参数
  23.     args = parse_arguments()
  24.     embeddings = HuggingFaceEmbeddings(model_name=embeddings_model_name)
  25.     db = Chroma(persist_directory=persist_directory, embedding_function=embeddings, client_settings=CHROMA_SETTINGS)
  26.     retriever = db.as_retriever(search_kwargs={"k": target_source_chunks})
  27.     # 激活/停用LLM的流式StdOut回调
  28.     callbacks = [] if args.mute_stream else [StreamingStdOutCallbackHandler()]
  30.     llm = Ollama(model=model, callbacks=callbacks)
  32.     qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever, return_source_documents= not args.hide_source)
  33.     # 交互式问答
  34.     while True:
  35.         query = input("\nEnter a query: ")
  36.         if query == "exit":
  37.             break
  38.         if query.strip() == "":
  39.             continue
  41.         # 从链中获取答案
  42.         start = time.time()
  43.         res = qa(query)
  44.         answer, docs = res['result'], [] if args.hide_source else res['source_documents']
  45.         end = time.time()
  47.         # 打印结果
  48.         print("\n\n> Question:")
  49.         print(query)
  50.         print(answer)
  52.         # 打印用于答案的相关来源
  53.         for document in docs:
  54.             print("\n> " + document.metadata["source"] + ":")
  55.             print(document.page_content)
  57. def parse_arguments():
  58.     # privateGPT：使用LLM的功能，在没有互联网连接的情况下向您的文档提问。
  59.     parser = argparse.ArgumentParser(description='privateGPT: Ask questions to your documents without an internet connection, '
  60.                                                  'using the power of LLMs.')
  61.     # -S 使用此标志可禁用打印用于答案的源文档。
  62.     parser.add_argument("--hide-source", "-S", action='store_true',
  63.                         help='Use this flag to disable printing of source documents used for answers.')
  64.     # -M 使用此标志可禁用LLM的流式StdOut回调。
  65.     parser.add_argument("--mute-stream", "-M",
  66.                         action='store_true',
  67.                         help='Use this flag to disable the streaming StdOut callback for LLMs.')
  69.     return parser.parse_args()
  72. if __name__ == "__main__":
  73.     main()


总体来说还是比较准，但是就是慢了点，问个问题花我5-6分钟，下面我换个模型试试看。

  1. ollama pull llama2:13b
  2. MODEL=llama2:13b python privateGPT.py


更慢了。。。8分钟花了


欢迎加群讨论技术，1群：677373950(满了，可以加，但通过不了)，2群：656732739

评价

基于Ollama创建Gemma定制化AI模型
基于Ollama创建Gemma定制化AI模型[TOC] 什么是Gemma？Gemma模型使用了和Gemini同源的技术，总共有20亿参数和70亿参数两种...

Harbor介绍与离线安装
Harbor介绍与离线安装[TOC] Harbor介绍Harbor是一个开源的可信云本地注册项目，用于存储、签名和扫描内容。Harbor通过添加...

离线部署Linux环境，不借助docker
离线部署Linux系统dotnet 6.0环境前言、Linux 命令请用管理员身份运行命令：sudo -s一、下载.NET环境官网地址：下载 .NET 6...

uniapp 离线打包配置
下载Android Studio 并配置好JavaSDK查看HBuilderX版本然后去下载对应的SDK版本https://pan.baidu.com/s/1ZYxRVH23EbldPQqO...

uniapp 离线打包配置高德地图
没有申请key的去高德开放平台申请的Android平台Keyhttps://console.amap.com/dev/key/app SHA1 在前面申请云端证书里面找 ...
这一世以无限游戏为使命！
博主信息
排名
2
文章
633
粉丝
44
评论
93
文章类别
最新文章
最新评价
docker中Sware集群与service
尘叶心繁 : 想学呀！我教你呀
一个bug让程序员走上法庭 索赔金额达400亿日元
叼着奶瓶逛酒吧 : 所以说做程序员也要懂点法律知识
.net core 塑形资源
剑轩 : 收藏收藏
映射AutoMapper
剑轩 : 好是好，这个对效率影响大不大哇,效率高不高
ASP.NET Core 服务注册生命周期
剑轩 : http://www.tnblog.net/aojiancc2/article/details/167
关于我们
ICP备案 ：渝ICP备18016597号-1
网站信息：2018-2025TNBLOG.NET
技术交流：群号656732739
联系我们：contact@tnblog.net
公网安备：50010702506256
欢迎加群
欢迎加群交流技术