首页 > 其他分享 >大模型2-初试大模型+RAG

大模型2-初试大模型+RAG

时间：2024-10-08 17:51:38浏览次数：10  
标签：初试 RAG 模型 question print path model self 向量

任务

使用大模型+RAG技术，缓解大模型幻觉问题。

RAG介绍

在实际业务场景中，通用的基础大模型可能存在无法满足我们需求的情况，主要有以下几方面原因：

  • 知识局限性：大模型的知识来源于训练数据，而这些数据主要来自于互联网上已经公开的资源，对于一些实时性的或者非公开的，由于大模型没有获取到相关数据，这部分知识也就无法被掌握。

  • 数据安全性：为了使得大模型能够具备相应的知识，就需要将数据纳入到训练集进行训练。然而，对于企业来说，数据的安全性至关重要，任何形式的数据泄露都可能对企业构成致命的威胁。

  • 大模型幻觉：由于大模型是基于概率统计进行构建的，其输出本质上是一系列数值运算。因此，有时会出现模型“一本正经地胡说八道”的情况，尤其是在大模型不具备的知识或不擅长的场景中。

针对上述这些问题，研究人员提出了检索增强生成（Retrieval Augmented Generation, RAG）的方法。这种方法通过引入外部知识，使大模型能够生成准确且符合上下文的答案，同时能够减少模型幻觉的出现。

由于RAG简单有效，它已经成为主流的大模型应用方案之一。

如下图所示，RAG通常包括以下三个基本步骤：
RAG流程

  • 索引：将文档库分割成较短的 Chunk，即文本块或文档片段，然后构建成向量索引。

  • 检索：计算问题和 Chunks 的相似度，检索出若干个相关的 Chunk。

  • 生成：将检索到的Chunks作为背景信息，生成问题的回答。

简而言之，就是先把文档分割成一个个的小块，每个小块用模型转为一个向量存储起来作为知识库，当用户提问时，首先在知识库中查找相关的向量，即与问题相关的资料，然后把问题和检索到的资料都输给大模型，让大模型结合自身知识和知识库知识回答问题，这样当大模型不知道问题答案时还能参考知识库知识回答，从而减少大模型幻觉。

实例

按照上面所说，要对已有文本切分构建向量，然后要在回答问题时索引相关向量。所以，核心在于向量库构建和向量索引算法。

1、向量库构建

利用模型将文本转为向量：

# 定义向量模型类
class EmbeddingModel:
    """
    class for EmbeddingModel
    """
    def __init__(self, path: str) -> None:
        # 定义向量模型的tokenizer和model
        self.tokenizer = AutoTokenizer.from_pretrained(path)
        self.model = AutoModel.from_pretrained(path).cuda()
        print(f'Loading EmbeddingModel from {path}.')

    def get_embeddings(self, texts: List) -> List[float]:
        """
        calculate embedding for text list
        """
        encoded_input = self.tokenizer(texts, padding=True, truncation=True, return_tensors='pt')
        print(encoded_input)
        encoded_input = {k: v.cuda() for k, v in encoded_input.items()}
        with torch.no_grad():
            model_output = self.model(**encoded_input)
            sentence_embeddings = model_output[0][:, 0]
        sentence_embeddings = torch.nn.functional.normalize(sentence_embeddings, p=2, dim=1)
        return sentence_embeddings.tolist()

（1）加载模型

（2）文本转为向量

get_embeddings 函数的主要作用是为输入的文本列表 (texts) 计算嵌入向量（embeddings）。它的主要流程如下：

  1. 分词和编码 (self.tokenizer):
    • 将输入文本列表 texts 使用 tokenizer 进行分词和编码，并将其转换为模型可以处理的格式。使用 padding=True 进行填充，确保所有输入句子长度一致，并且 truncation=True 用于在句子过长时截断到模型的最大长度。
    • return_tensors='pt' 表示返回的是 PyTorch 张量（tensor）。
  2. 迁移到 GPU (cuda):
    • 为了加速处理，所有的输入数据（encoded_input）被迁移到 GPU 上。使用 .cuda() 函数将这些张量转移到 GPU。
  3. 禁用梯度计算:
    • 使用 torch.no_grad() 上下文管理器禁用梯度计算，因为这里不需要更新模型的权重，只需要计算句子嵌入。这样可以减少内存消耗并加快计算速度。
  4. 模型前向传递:
    • 调用 self.model(**encoded_input) 来执行模型的前向传递，得到模型的输出 model_output。model_output[0] 通常表示每个输入 token 的嵌入，形状为 (batch_size, sequence_length, hidden_size)。
  5. 提取句子级别的嵌入:
    • model_output[0][:, 0] 取出每个句子对应的 [CLS] token 的嵌入（即 0 位置的嵌入）。在 BERT 等模型中，[CLS] token 的嵌入通常被用作整个句子的语义表示。
  6. 归一化嵌入:
    • 使用 torch.nn.functional.normalize 对句子嵌入进行 L2 归一化，确保每个句子的嵌入向量的模为 1。p=2 指的是 L2 范数，dim=1 是在句子维度上进行归一化。
  7. 转换为 Python 列表:
    • 最终将句子嵌入张量转换为 Python 列表，并返回嵌入向量的列表。

2、向量索引算法

其核心在于在一大堆向量中找到与问题有关的向量，这里用余弦相似度判断向量是否与问题有关。

# 定义向量库索引类
class VectorStoreIndex:
    """
    class for VectorStoreIndex
    """
    def __init__(self, doecment_path: str, embed_model: EmbeddingModel) -> None:
        self.documents = []
        for line in open(doecment_path, 'r', encoding='utf-8'):
            line = line.strip()
            self.documents.append(line)
        print(self.documents)

        self.embed_model = embed_model
        self.vectors = self.embed_model.get_embeddings(self.documents)

        print(f'Loading {len(self.documents)} documents for {doecment_path}.')

    def get_similarity(self, vector1: List[float], vector2: List[float]) -> float:
        """
        calculate cosine similarity between two vectors
        """
        dot_product = np.dot(vector1, vector2) # 点积反映了两个向量在方向上的相似程度
        magnitude = np.linalg.norm(vector1) * np.linalg.norm(vector2) # 这里计算的是两个向量的模（或范数），即向量的长度，并将两个模相乘。模是通过求每个向量的元素平方和再开方得到的。这反映了向量的大小。
        if not magnitude:
            return 0
        return dot_product / magnitude   # 点积/模的乘积=余弦相似度

    def query(self, question: str, k: int = 1) -> List[str]:
        question_vector = self.embed_model.get_embeddings([question])[0]
        result = np.array([self.get_similarity(question_vector, vector) for vector in self.vectors])
        return np.array(self.documents)[result.argsort()[-k:][::-1]].tolist()

（1）get_similarity 是用于计算两个向量之间的余弦相似度（cosine similarity）

get_similarity(self, vector1: List[float], vector2: List[float]) -> float
  • 函数接受两个输入参数：vector1 和 vector2，它们都是浮点数列表（即向量）。返回值是一个浮点数，即余弦相似度的结果。

dot_product = np.dot(vector1, vector2)：这一步计算两个向量的点积（即向量之间相应位置元素的乘积和）。点积反映了两个向量在方向上的相似程度。

magnitude = np.linalg.norm(vector1) * np.linalg.norm(vector2)：这里计算的是两个向量的模（或范数），即向量的长度，并将两个模相乘。模是通过求每个向量的元素平方和再开方得到的。这反映了向量的大小。

if not magnitude: return 0：如果模为 0（意味着其中一个或两个向量是零向量，即没有方向），则余弦相似度被定义为 0，因为无法比较方向。

return dot_product / magnitude：最后，函数返回点积除以模的乘积，这就是余弦相似度的定义。这个值位于 -1 到 1 之间，表示两个向量之间的方向相似性，1 表示完全相同的方向，-1 表示完全相反的方向，0 表示它们互相正交。

余弦相似度值越接近 1，表示两个向量的方向越相近。

（2）query 方法，用于从一组文档中查找与问题（question）最相似的内容。

函数输入与输出：

def query(self, question: str, k: int = 1) -> List[str]
  • 参数：
    • question：一个字符串，表示要查询的问题或语句。
    • k：一个整数（默认为1），表示返回的最相似文档的数量。
  • 返回值：返回与输入问题最相似的文档列表，长度为 k。
**question_vector = self.embed_model.get_embeddings([question])[0]**
  • 这里通过 self.embed_model.get_embeddings 方法对输入的问题进行嵌入，将文本转换为向量表示。[question] 表示将问题放入列表中，而 [0] 则是提取出第一个（也是唯一一个）向量，因为传入的是一个单一问题。
  • question_vector 是问题的嵌入向量，通常用作进一步计算相似度。
result = np.array([self.get_similarity(question_vector, vector) for vector in self.vectors])
  • 这里遍历 self.vectors 中存储的所有文档向量，并逐一与 question_vector 进行相似度计算。使用 self.get_similarity 方法计算余弦相似度，返回一个相似度分数的列表。
  • np.array(...) 将所有相似度结果转换为 NumPy 数组，方便后续的排序和索引操作。
return np.array(self.documents)[result.argsort()[-k:][::-1]].tolist()
  • result.argsort()：返回 result 数组的索引值，按相似度从低到高进行排序。
  • [-k:][::-1]：选取最后 k 个相似度最高的索引，并使用 [::-1] 进行逆序排列，以得到从最高相似度到最低相似度的排序。
  • np.array(self.documents)：将文档转换为 NumPy 数组，使用排好序的索引来提取与问题最相似的文档。
  • .tolist()：将结果从 NumPy 数组转换为 Python 列表，并将最相似的 k 个文档返回。

query函数的作用是计算输入问题与所有文档的相似度，并返回相似度最高的 k 个文档。通过将文本转化为向量并使用余弦相似度进行比较，它能够为文本检索或类似的任务提供有效的结果。

3、大模型输出

最后将问题和检索的内容输入大模型，得到答案。

# 定义大语言模型类
class LLM:
    """
    class for Yuan2.0 LLM
    """
    def __init__(self, model_path: str) -> None:
        print("Creat tokenizer...")
        self.tokenizer = AutoTokenizer.from_pretrained(model_path, add_eos_token=False, add_bos_token=False, eos_token='<eod>')
        self.tokenizer.add_tokens(['<sep>', '<pad>', '<mask>', '<predict>', '<FIM_SUFFIX>', '<FIM_PREFIX>', '<FIM_MIDDLE>','<commit_before>','<commit_msg>','<commit_after>','<jupyter_start>','<jupyter_text>','<jupyter_code>','<jupyter_output>','<empty_output>'], special_tokens=True)

        print("Creat model...")
        self.model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.bfloat16, trust_remote_code=True).cuda()

        print(f'Loading Yuan2.0 model from {model_path}.')

    def generate(self, question: str, context: List):
        if context:
            prompt = f'背景：{context}\n问题：{question}\n请基于背景，回答问题。'
        else:
            prompt = question

        prompt += "<sep>"
        inputs = self.tokenizer(prompt, return_tensors="pt")["input_ids"].cuda()
        outputs = self.model.generate(inputs, do_sample=False, max_length=1024)
        output = self.tokenizer.decode(outputs[0])

        print(output.split("<sep>")[-1])

（1）加载大模型

（2）构建prompt

（3）得到结果

将不加RAG和加RAG的输出结果对比：
使用RAG前后输出对比

可以看出，不加RAG的输出虽然很多，但是不准确，比如广州大学的办学时间，简直胡说，加了RAG后有参考资料，输出内容会更准确，从而减少了大模型幻觉。

使用Yuan2-2B完整代码

# 大模型+RAG
# 导入所需的库
from typing import List
import numpy as np

import torch
from transformers import AutoModel, AutoTokenizer, AutoModelForCausalLM

# 向量模型下载
from modelscope import snapshot_download
model_dir = snapshot_download("AI-ModelScope/bge-small-zh-v1.5", cache_dir='.')
# 源大模型下载
from modelscope import snapshot_download
model_dir = snapshot_download('IEITYuan/Yuan2-2B-Mars-hf', cache_dir='.')
# model_dir = snapshot_download('IEITYuan/Yuan2-2B-July-hf', cache_dir='.')

# 定义向量模型类
class EmbeddingModel:
    """
    class for EmbeddingModel
    """
    def __init__(self, path: str) -> None:
        # 定义向量模型的tokenizer和model
        self.tokenizer = AutoTokenizer.from_pretrained(path)
        self.model = AutoModel.from_pretrained(path).cuda()
        print(f'Loading EmbeddingModel from {path}.')

    def get_embeddings(self, texts: List) -> List[float]:
        """
        calculate embedding for text list
        """
        encoded_input = self.tokenizer(texts, padding=True, truncation=True, return_tensors='pt')
        
        encoded_input = {k: v.cuda() for k, v in encoded_input.items()}
        print(encoded_input)
        with torch.no_grad():
            model_output = self.model(**encoded_input)
            sentence_embeddings = model_output[0][:, 0]
        sentence_embeddings = torch.nn.functional.normalize(sentence_embeddings, p=2, dim=1)
        return sentence_embeddings.tolist()

print("> Create embedding model...")
embed_model_path = './AI-ModelScope/bge-small-zh-v1___5'
embed_model = EmbeddingModel(embed_model_path)

# 定义向量库索引类
class VectorStoreIndex:
    """
    class for VectorStoreIndex
    """
    def __init__(self, doecment_path: str, embed_model: EmbeddingModel) -> None:
        self.documents = []
        for line in open(doecment_path, 'r', encoding='utf-8'):
            line = line.strip()
            self.documents.append(line)
        # print(self.documents)

        self.embed_model = embed_model
        self.vectors = self.embed_model.get_embeddings(self.documents)

        print(f'Loading {len(self.documents)} documents for {doecment_path}.')

    def get_similarity(self, vector1: List[float], vector2: List[float]) -> float:
        """
        calculate cosine similarity between two vectors
        """
        dot_product = np.dot(vector1, vector2) # 点积反映了两个向量在方向上的相似程度
        magnitude = np.linalg.norm(vector1) * np.linalg.norm(vector2) # 这里计算的是两个向量的模（或范数），即向量的长度，并将两个模相乘。模是通过求每个向量的元素平方和再开方得到的。这反映了向量的大小。
        if not magnitude:
            return 0
        return dot_product / magnitude   # 点积/模的乘积=余弦相似度

    def query(self, question: str, k: int = 1) -> List[str]:
        question_vector = self.embed_model.get_embeddings([question])[0]
        result = np.array([self.get_similarity(question_vector, vector) for vector in self.vectors])
        return np.array(self.documents)[result.argsort()[-k:][::-1]].tolist() 

print("> Create index...")
doecment_path = './knowledge.txt'
index = VectorStoreIndex(doecment_path, embed_model)


question = '介绍一下广州大学'
print('> Question:', question)

context = index.query(question)
print('> Context:', context)


# 定义大语言模型类
class LLM:
    """
    class for Yuan2.0 LLM
    """
    def __init__(self, model_path: str) -> None:
        print("Creat tokenizer...")
        self.tokenizer = AutoTokenizer.from_pretrained(model_path, add_eos_token=False, add_bos_token=False, eos_token='<eod>')
        self.tokenizer.add_tokens(['<sep>', '<pad>', '<mask>', '<predict>', '<FIM_SUFFIX>', '<FIM_PREFIX>', '<FIM_MIDDLE>','<commit_before>','<commit_msg>','<commit_after>','<jupyter_start>','<jupyter_text>','<jupyter_code>','<jupyter_output>','<empty_output>'], special_tokens=True)

        print("Creat model...")
        self.model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.bfloat16, trust_remote_code=True).cuda()

        print(f'Loading Yuan2.0 model from {model_path}.')

    def generate(self, question: str, context: List):
        if context:
            prompt = f'背景：{context}\n问题：{question}\n请基于背景，回答问题。'
        else:
            prompt = question

        prompt += "<sep>"
        inputs = self.tokenizer(prompt, return_tensors="pt")["input_ids"].cuda()
        outputs = self.model.generate(inputs, do_sample=False, max_length=1024)
        output = self.tokenizer.decode(outputs[0])

        print(output.split("<sep>")[-1])

print("> Create Yuan2.0 LLM...")
model_path = './IEITYuan/Yuan2-2B-Mars-hf'
# model_path = './IEITYuan/Yuan2-2B-July-hf'
llm = LLM(model_path)

print('> Without RAG:')
llm.generate(question, [])

print('> With RAG:')
llm.generate(question, context)

使用Qwen2-1.5B完整代码

# 大模型+RAG
# 导入所需的库
from typing import List
import numpy as np

import torch
from transformers import AutoModel, AutoTokenizer, AutoModelForCausalLM

# 向量模型下载
from modelscope import snapshot_download
model_dir = snapshot_download("AI-ModelScope/bge-small-zh-v1.5", cache_dir='.')
# 源大模型下载
from modelscope import snapshot_download
# model_dir = snapshot_download('IEITYuan/Yuan2-2B-Mars-hf', cache_dir='.')
model_dir = snapshot_download('qwen/Qwen2-1.5B-Instruct', cache_dir='.')

# 定义向量模型类
class EmbeddingModel:
    """
    class for EmbeddingModel
    """
    def __init__(self, path: str) -> None:
        # 定义向量模型的tokenizer和model
        self.tokenizer = AutoTokenizer.from_pretrained(path)
        self.model = AutoModel.from_pretrained(path).cuda()
        print(f'Loading EmbeddingModel from {path}.')

    def get_embeddings(self, texts: List) -> List[float]:
        """
        calculate embedding for text list
        """
        encoded_input = self.tokenizer(texts, padding=True, truncation=True, return_tensors='pt')
        
        encoded_input = {k: v.cuda() for k, v in encoded_input.items()}
        print(encoded_input)
        with torch.no_grad():
            model_output = self.model(**encoded_input)
            sentence_embeddings = model_output[0][:, 0]
        sentence_embeddings = torch.nn.functional.normalize(sentence_embeddings, p=2, dim=1)
        return sentence_embeddings.tolist()

print("> Create embedding model...")
embed_model_path = './AI-ModelScope/bge-small-zh-v1___5'
embed_model = EmbeddingModel(embed_model_path)

# 定义向量库索引类
class VectorStoreIndex:
    """
    class for VectorStoreIndex
    """
    def __init__(self, doecment_path: str, embed_model: EmbeddingModel) -> None:
        self.documents = []
        for line in open(doecment_path, 'r', encoding='utf-8'):
            line = line.strip()
            self.documents.append(line)
        # print(self.documents)

        self.embed_model = embed_model
        self.vectors = self.embed_model.get_embeddings(self.documents)

        print(f'Loading {len(self.documents)} documents for {doecment_path}.')

    def get_similarity(self, vector1: List[float], vector2: List[float]) -> float:
        """
        calculate cosine similarity between two vectors
        """
        dot_product = np.dot(vector1, vector2) # 点积反映了两个向量在方向上的相似程度
        magnitude = np.linalg.norm(vector1) * np.linalg.norm(vector2) # 这里计算的是两个向量的模（或范数），即向量的长度，并将两个模相乘。模是通过求每个向量的元素平方和再开方得到的。这反映了向量的大小。
        if not magnitude:
            return 0
        return dot_product / magnitude   # 点积/模的乘积=余弦相似度

    def query(self, question: str, k: int = 1) -> List[str]:
        question_vector = self.embed_model.get_embeddings([question])[0]
        result = np.array([self.get_similarity(question_vector, vector) for vector in self.vectors])
        return np.array(self.documents)[result.argsort()[-k:][::-1]].tolist() 

print("> Create index...")
doecment_path = './knowledge.txt'
index = VectorStoreIndex(doecment_path, embed_model)


question = '介绍一下广州大学'
print('> Question:', question)

context = index.query(question)
print('> Context:', context)


# 定义大语言模型类
class LLM:
    """
    class for Yuan2.0 LLM
    """
    def __init__(self, model_path: str) -> None:
        print("Creat tokenizer...")
        self.tokenizer = AutoTokenizer.from_pretrained(model_path, add_eos_token=False, add_bos_token=False, eos_token='<eod>')
        self.tokenizer.add_tokens(['<sep>', '<pad>', '<mask>', '<predict>', '<FIM_SUFFIX>', '<FIM_PREFIX>', '<FIM_MIDDLE>','<commit_before>','<commit_msg>','<commit_after>','<jupyter_start>','<jupyter_text>','<jupyter_code>','<jupyter_output>','<empty_output>'], special_tokens=True)

        print("Creat model...")
        self.model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.bfloat16, trust_remote_code=True).cuda()

        print(f'Loading Yuan2.0 model from {model_path}.')

    def generate(self, question: str, context: List):
        if context:
            prompt = f'背景：{context}\n问题：{question}\n请基于背景，回答问题。'
        else:
            prompt = question

        messages = [
            {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
            ]
        messages.append({"role": "user", "content": prompt},)
        text = self.tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True,
            )
        inputs = self.tokenizer([text], return_tensors="pt").to(self.model.device)
        outputs = self.model.generate(**inputs, max_length=1024) # 设置解码方式和最大生成长度
        generated_ids = [
            output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, outputs)
        ]
        response = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
        print(response)

print("> Create Yuan2.0 LLM...")
# model_path = './IEITYuan/Yuan2-2B-Mars-hf'
model_path = './qwen/Qwen2-1___5B-Instruct'
llm = LLM(model_path)

print('> Without RAG:')
llm.generate(question, [])

print('> With RAG:')
llm.generate(question, context)

参考文献：

1、‬‌⁠‌‬‬‌‬‍‍‌‌‌‍‍‌‬‌⁠‍‍‌⁠Task3：源大模型RAG实战 - 飞书云文档 (feishu.cn)

2、Qwen官方文档

标签：初试,RAG,模型,question,print,path,model,self,向量
From： https://blog.csdn.net/qq_42755230/article/details/142762364

相关文章

  • 大模型在多轮对话中的“massage“
    messages是用于与模型进行对话的结构化格式。这个格式通常用于对话式接口或应用程序中，以模拟人类与模型之间的多轮对话。messages列表中的每个元素代表一条消息，并包含了角色信息。常见的角色包括system、assistant和usersystem描述:system消息通常用来向模型提供指导或......
  • Jeff Dean点赞谷歌新研究：鲸鱼生物声学模型，可识别8种鲸类
    鲸鱼声音识别对于保护海洋生态具有重要意义，科学家可以通过分析鲸鱼的声音，了解其种类、迁徙路线、繁殖习惯和社会结构，从而制定更加有效的保护政策。然而，鲸鱼声音识别并非易事。首先，目前全世界已知的鲸鱼种类超过94种，且声学频率范围极为广泛，从蓝鲸低至10赫兹的声波到齿鲸高达1......
  • Starrocks模型表（一）
    主键表优势：支撑实时数据更新的同时，也能保证高效的复杂即席查询性能主键表中的主键具有唯一非空约束，用于唯一标识数据行，如果新数据的主键值与表中原数据的主键值相同，则存在唯一约束冲突，此时新数据会替代原数据应用场景实时对接事务型数据至StarRocks。事务型数据库中，除了插......
  • 使用Python实现深度学习模型：智能身份验证与防伪
    在当今数字化时代，身份验证和防伪技术变得尤为重要。深度学习作为人工智能的一个重要分支，提供了强大的工具来解决这些问题。本文将介绍如何使用Python实现一个基于深度学习的智能身份验证与防伪系统，详细讲解其基本原理和实现步骤。一、项目概述本项目旨在通过训练一个卷积......
  • 模型压缩的方法？
    模型压缩的方法方法模型压缩是一个重要的讨论话题，因为它直接关系到模型在实际应用中的效率和部署能力。模型压缩的主要目的是在保持模型性能的同时，减少模型的参数量和计算量，从而加快推理速度、降低存储需求，使得模型能够在资源受限的设备上运行。以下是一些常见的模型......
  • （29-6-01）通过回测、ARIMA 和 GRU 预测股票价格：深度学习模型预测（1）
    29.8 深度学习模型预测对于股票市场这类序列数据，使用不考虑数据序列的模型进行预测可能会丢失数据中的重要信息。因此，在本项目中引入了递归神经网络（RNN），它能有效利用数据的序列信息进行预测。递归神经网络主要有三种类型：标准RNN、长短期记忆网络（LSTM）和门控递归单元（GRU）。标......
  • RAG系统评测实践详细版：Coze及相关产品评测对比，以及下一代RAG技术
    AIRAG系统评测实践：Coze及相关产品评测对比RAG（检索增强生成）是一种AI框架，它将传统信息检索系统（例如数据库）的优势与生成式大语言模型(LLM)的功能结合在一起，通过将这些额外的知识与自己的语言技能相结合，AI可以撰写更准确、更具时效性且更贴合您的具体需求的文字。RAG通过几个......
  • 部署cogview图片生成模型
       CogView3是一种新颖的文本生成图像系统，采用了接力扩散的方式，将生成高分辨率图像的过程分解为多个阶段。通过接力的超分辨率过程，对低分辨率生成结果添加高斯噪声，并从这些带噪声的图像开始扩散。我们的结果显示，CogView3的表现优于SDXL，获胜率达到77.0%。此外，通过对扩......
  • 【孤岛划分】分布式能源接入弹性配电网模型研究【IEEE33节点】（Matlab代码实现）
      目录......
  • 基于多主体主从博弈的区域综合能源系统低碳经济优化调度【分层模型】（Matlab代码实现）
      ......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99