知识图谱中能使用本地的模型或者huggingface上的模型去构建吗？

[li-hhhh]

我尝试过，只有嵌入模型可以。如果可行，那有什么本地模型或者huggingface中的模型推荐去替换Openai吗？
当使用本地模型或者huggingface中的模型去替换openai的模型时，总是报错显示缺一些东西，如predict，metadata

[dosubot[bot]]

@li-hhhh 你好！我是Dosu，一个可以帮助您解决错误、回答问题并成为贡献者的机器人。如果您需要任何帮助，请告诉我。

是的，可以使用本地模型或Hugging Face上的模型来构建知识图谱，并且可以避免类似AttributeError: "object has no attribute 'metadata'"的错误。

以下是使用Hugging Face模型与LlamaIndex构建知识图谱的示例：

1. 安装必要的包：

   pip install llama-index-embeddings-huggingface
   pip install llama_index transformers wikipedia html2text pyvis

2. 在代码中使用Hugging Face模型：

   from llama_index.embeddings.huggingface import HuggingFaceEmbedding
   from llama_index.core import Settings
   
   # 设置嵌入模型为Hugging Face模型
   Settings.embed_model = HuggingFaceEmbedding(
       model_name="BAAI/bge-small-en-v1.5"
   )

此外，可以使用LlamaIndex中的OpenAILike类使Hugging Face模型兼容OpenAI的API。以下是使用OpenAILike类的示例：

from llama_index.llms.openai_like import OpenAILike

# 设置模型为Hugging Face模型
model = OpenAILike(
    model="gpt-3.5-turbo",
    tokenizer="gpt-3.5-turbo",
    api_key="your_api_key",
    api_base="https://api.openai.com/v1"
)

# 使用模型进行补全
response = model.complete(prompt="Your prompt here")
print(response)

对于知识图谱构建，可以使用Hugging Face上的REBEL模型进行三元组提取：

1. 安装必要的包：

   pip install llama_index transformers wikipedia html2text pyvis

2. 使用REBEL模型进行三元组提取：

   from transformers import pipeline
   
   triplet_extractor = pipeline(
       "text2text-generation",
       model="Babelscape/rebel-large",
       tokenizer="Babelscape/rebel-large",
       device="cuda:0",  # 如果使用CPU，请注释掉这一行
   )
   
   def extract_triplets(input_text):
       text = triplet_extractor.tokenizer.batch_decode(
           [
               triplet_extractor(
                   input_text, return_tensors=True, return_text=False
               )[0]["generated_token_ids"]
           ]
       )[0]
   
       triplets = []
       relation, subject, relation, object_ = "", "", "", ""
       text = text.strip()
       current = "x"
       for token in (
           text.replace("<s>", "")
           .replace("<pad>", "")
           .replace("</s>", "")
           .split()
       ):
           if token == "<triplet>":
               current = "t"
               if relation != "":
                   triplets.append(
                       (subject.strip(), relation.strip(), object_.strip())
                   )
                   relation = ""
               subject = ""
           elif token == "<subj>":
               current = "s"
               if relation != "":
                   triplets.append(
                       (subject.strip(), relation.strip(), object_.strip())
                   )
               object_ = ""
           elif token == "<obj>":
               current = "o"
               relation = ""
           else:
               if current == "t":
                   subject += " " + token
               elif current == "s":
                   object_ += " " + token
               elif current == "o":
                   relation += " " + token
   
       if subject != "" and relation != "" and object_ != "":
           triplets.append((subject.strip(), relation.strip(), object_.strip()))
   
       return triplets

3. 可选：使用Wikipedia过滤提取的关系：

   import wikipedia
   
   class WikiFilter:
       def __init__(self):
           self.cache = {}
   
       def filter(self, candidate_entity):
           if candidate_entity in self.cache:
               return self.cache[candidate_entity]["title"]
   
           try:
               page = wikipedia.page(candidate_entity, auto_suggest=False)
               entity_data = {
                   "title": page.title,
                   "url": page.url,
                   "summary": page.summary,
               }
               self.cache[candidate_entity] = entity_data
               self.cache[page.title] = entity_data
               return entity_data["title"]
           except:
               return None
   
   wiki_filter = WikiFilter()
   
   def extract_triplets_wiki(text):
       relations = extract_triplets(text)
       filtered_relations = []
       for relation in relations:
           (subj, rel, obj) = relation
           filtered_subj = wiki_filter.filter(subj)
           filtered_obj = wiki_filter.filter(obj)
           if filtered_subj is None and filtered_obj is None:
               continue
           filtered_relations.append(
               (
                   filtered_subj or subj,
                   rel,
                   filtered_obj or obj,
               )
           )
       return filtered_relations

4. 使用LlamaIndex运行：

   from llama_index.core import KnowledgeGraphIndex, StorageContext
   from llama_index.readers.papers import ArxivReader
   from llama_index.core.graph_stores import SimpleGraphStore
   
   loader = ArxivReader()
   documents = loader.load_data(
       search_query="Retrieval Augmented Generation", max_results=1
   )
   
   from llama_index.core import Document
   documents = [Document(text="".join([x.text for x in documents]))]
   
   from llama_index.core import Settings
   from llama_index.llms.openai import OpenAI
   
   llm = OpenAI(temperature=0.1, model="gpt-3.5-turbo")
   Settings.llm = llm
   Settings.chunk_size = 256
   
   graph_store = SimpleGraphStore()
   storage_context = StorageContext.from_defaults(graph_store=graph_store)
   
   index = KnowledgeGraphIndex.from_documents(
       documents,
       max_triplets_per_chunk=3,
       kg_triplet_extract_fn=extract_triplets,
       storage_context=storage_context,
       include_embeddings=True,
   )
   
   index1 = KnowledgeGraphIndex.from_documents(
       documents,
       max_triplets_per_chunk=3,
       kg_triplet_extract_fn=extract_triplets_wiki,
       storage_context=storage_context,
       include_embeddings=True,
   )

这种方法确保您可以使用Hugging Face模型，同时避免AttributeError: "object has no attribute 'metadata'"错误^{[1][2][3][4][5]}。

To continue talking to Dosu, mention @dosu.

[li-hhhh]

from llama_index.llms.openai_like import OpenAILike

设置模型为Hugging Face模型

model = OpenAILike(
model="gpt-3.5-turbo",
tokenizer="gpt-3.5-turbo",
api_key="your_api_key",
api_base="https://api.openai.com/v1"
)

使用模型进行补全

response = model.complete(prompt="Your prompt here")
print(response)

请问你可以使用这个写一个在huggingface中调用对应的模型的例子吗？ api_key="your_api_key"， api_base="https://api.openai.com/v1"这两个参数是必须的吗？还有当我将huggingface的模型拉到本地之后，这个有改如何去调用？

[dosubot[bot]]

要在Hugging Face中调用对应的模型，并使用OpenAILike类，您可以按照以下步骤进行。api_key和api_base参数是必须的，但可以设置为本地API的值。

1. 安装必要的包：

   pip install llama-index-llms-openai-like transformers

2. 使用本地Hugging Face模型的示例代码：

   from llama_index.llms.openai_like import OpenAILike
   from transformers import pipeline
   
   # 设置环境变量
   import os
   os.environ['OPENAI_BASE_API'] = 'http://localhost:8000/v1'
   os.environ['OPENAI_API_KEY'] = 'your_api_key'
   
   # 初始化本地Hugging Face模型
   local_model = pipeline("text-generation", model="gpt2", tokenizer="gpt2")
   
   # 自定义OpenAILike类以使用本地模型
   class LocalOpenAILike(OpenAILike):
       def __init__(self, model, tokenizer, api_base, api_key):
           super().__init__(model=model, tokenizer=tokenizer, api_base=api_base, api_key=api_key)
           self.local_model = local_model
   
       def complete(self, prompt):
           return self.local_model(prompt, max_length=50)[0]['generated_text']
   
   # 设置模型为本地Hugging Face模型
   model = LocalOpenAILike(
       model="gpt2",
       tokenizer="gpt2",
       api_base='http://localhost:8000/v1',
       api_key='your_api_key'
   )
   
   # 使用模型进行补全
   response = model.complete(prompt="Your prompt here")
   print(response)

在这个示例中：

• model和tokenizer参数设置为Hugging Face模型的名称，例如gpt2。
• api_base设置为本地API的URL，例如http://localhost:8000/v1。
• api_key可以设置为任意值，如果本地API不需要API密钥，可以忽略。

通过这种方式，您可以使用本地Hugging Face模型来替换OpenAI的模型^[1][2]。

To continue talking to Dosu, mention @dosu.