Transformers实战(二)快速入门文本相似度、检索式对话机器人

这篇具有很好参考价值的文章主要介绍了Transformers实战(二)快速入门文本相似度、检索式对话机器人。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Transformers实战(二)快速入门文本相似度、检索式对话机器人

1、文本相似度

1.1 文本相似度简介

  • 文本匹配是一个较为宽泛的概念,基本上只要涉及到两段文本之间关系的,都可以被看作是一种文本匹配的任务,

  • 只是在具体的场景下,不同的任务对匹配二字的定义可能是存在差异的,具体的任务场景包括文本相似度计算、问答匹配、对话匹配、文本推理等等,另外,如之前介绍的多项选择,本质上也是文本匹配

  • 本次重点关注文本相似度任务,即判断两段文本是不是表达了同样的语义

  • 文本相似度本质上是一个分类任务。

Sentence A Sentence B Label
找一部小时候的动画片 求一部小时候的动画片。谢了 1
别急呀,我的朋友。 你一定要看我一下 0
明天多少度啊 明天气温多少度啊 1
可怕的事情终于发生 你到底想说什么? 0

1.2 最直接的解决方案—交互策略

交互策略,就是输入句子对,对是否相似进行学习。

transformer模型做文本相似度检测,# 深度学习,深度学习,python

数据预处理方式如下:

transformer模型做文本相似度检测,# 深度学习,深度学习,python

交互策略的实现比较简单,类似于情感分析。

1.2.1 数据集预处理

数据集:https://github.com/CLUEbenchmark/SimCLUE/tree/main

预训练模型依然是哈工大开源的chinese-macbert-base

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset

dataset = load_dataset("json", data_files="./train_pair_1w.json", split="train")
dataset[0:2]
{
 'sentence1': ['找一部小时候的动画片',
  '我不可能是一个有鉴赏能力的行家,小姐我把我的时间都花在书写上;象这样豪华的舞会,我还是头一次见到。'],
 'sentence2': ['求一部小时候的动画片。谢了', '蜡烛没熄就好了,夜黑得瘆人,情绪压抑。'],
 'label': ['1', '0']
 }
# 划分数据集
datasets = dataset.train_test_split(test_size=0.2)

# tokenizer = AutoTokenizer.from_pretrained("hfl/chinese-macbert-base")

# 离线加载
model_path = '/root/autodl-fs/models/chinese-macbert-base'
tokenizer = AutoTokenizer.from_pretrained(model_path)

def process_function(examples):
    tokenized_examples = tokenizer(examples["sentence1"], examples["sentence2"], max_length=128, truncation=True)
    tokenized_examples["labels"] = [float(label) for label in examples["label"]]
    return tokenized_examples


tokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)
tokenized_datasets
DatasetDict({
    train: Dataset({
        features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
        num_rows: 8000
    })
    test: Dataset({
        features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
        num_rows: 2000
    })
})
print(tokenized_datasets["train"][0])
{
'input_ids': [101, 1062, 4265, 1920, 782, 8024, 1963, 3362, 2769, 1762, 6878, 1168, 2600, 1385, 808, 1184, 6878, 1168, 4640, 2370, 7363, 678, 8024, 6929, 6421, 2582, 720, 1215, 8043, 102, 800, 2697, 6230, 2533, 800, 2190, 6821, 5439, 1928, 2094, 3683, 2190, 800, 1520, 1520, 6820, 779, 8024, 4507, 754, 800, 2190, 6821, 702, 782, 772, 4495, 4638, 3946, 2658, 679, 4881, 2544, 5010, 6629, 3341, 511, 102], 
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 
'labels': 0.0
}

1.2.2 加载模型、创建评估函数

import evaluate

# 离线加载模型
model = AutoModelForSequenceClassification.from_pretrained(model_path, num_labels=1)



# 这里采用离线加载
accuracy_path = '/root/autodl-tmp/transformers-code/metrics/accuracy'
f1_path = '/root/autodl-tmp/transformers-code/metrics/f1'

acc_metric = evaluate.load(accuracy_path)
f1_metirc = evaluate.load(f1_path)


def eval_metric(eval_predict):
    predictions, labels = eval_predict
    predictions = [int(p > 0.5) for p in predictions]
    labels = [int(l) for l in labels]
    acc = acc_metric.compute(predictions=predictions, references=labels)
    f1 = f1_metirc.compute(predictions=predictions, references=labels)
    acc.update(f1)
    return acc

1.2.3 创建TrainingArguments及Trainer

train_args = TrainingArguments(output_dir="./cross_model",      # 输出文件夹
                               per_device_train_batch_size=16,  # 训练时的batch_size
                               per_device_eval_batch_size=16,  # 验证时的batch_size
                               logging_steps=10,                # log 打印的频率
                               evaluation_strategy="epoch",     # 评估策略
                               save_strategy="epoch",           # 保存策略
                               save_total_limit=3,              # 最大保存数
                               learning_rate=2e-5,              # 学习率
                               weight_decay=0.01,               # weight_decay
                               metric_for_best_model="f1",      # 设定评估指标
                               load_best_model_at_end=True)     # 训练完成后加载最优模型
from transformers import DataCollatorWithPadding
trainer = Trainer(model=model, 
                  args=train_args, 
                  train_dataset=tokenized_datasets["train"], 
                  eval_dataset=tokenized_datasets["test"], 
                  data_collator=DataCollatorWithPadding(tokenizer=tokenizer),
                  compute_metrics=eval_metric)
trainer.train()

transformer模型做文本相似度检测,# 深度学习,深度学习,python

1.2.4 模型预测

from transformers import pipeline

model.config.id2label = {0: "不相似", 1: "相似"}
pipe = pipeline("text-classification", model=model, tokenizer=tokenizer, device=0)

result = pipe({"text": "我喜欢北京", "text_pair": "天气怎样"}, function_to_apply="none")
result["label"] = "相似" if result["score"] > 0.5 else "不相似"
result
{'label': '不相似', 'score': 0.054742373526096344}

1.3 基于向量匹配的解决方案

如果从多个文本中,找到最相似的文本,应该如何做呢?

基于交互策略,我们可以借鉴之前多项选择,用相同的处理方式(如下图)。

transformer模型做文本相似度检测,# 深度学习,深度学习,python

但是这样效率极低,因为每次都需要与全量数据进行模型推理,数据量较大时很难满足时延要求。

基于向量匹配的方案可以解决。

我们可以将候选文本经过训练好的模型进行向量化,然后存到向量数据库中(如faiss)。然后将问题也同样向量化,去向量库中进行向量匹配。(这也是检索式机器人的思路,我们将在检索机器人中,将本章节训练好的向量模型作为预训练模型,对文本进行向量化,并将向量集合存到faiss中,进行向量匹配,这里仅仅训练出向量模型。)

transformer模型做文本相似度检测,# 深度学习,深度学习,python

那么,这个向量模型该如何进行训练呢?

向量匹配训练,分别对句子进行编码,目标是让两个相似句子的相似度分数尽可能接近1。

transformer模型做文本相似度检测,# 深度学习,深度学习,python

数据预处理与多项选择类似

transformer模型做文本相似度检测,# 深度学习,深度学习,python

注意:此时没有预定义模型,需要我们自己实现模型。

模型中的损失,我们可以用pytorch提供的余弦损失函数 torch.nn.CosineEmbeddingLoss

transformer模型做文本相似度检测,# 深度学习,深度学习,python

  • 余弦损失函数,常常用于评估两个向量的相似性,两个向量的余弦值越高,则相似性越高。

  • x:包括x1x2,即需要计算相似度的predictionGT

  • y:相当于人为给定的flag,决定按哪种方式计算得到loss的结果。

  • 注意:此时label应该为正负1

  • 如果需要约束使x1和x2尽可能的相似,那么就使用y=1predictionGT完全一致时,loss为0

input1 = torch.randn(100, 128)
input2 = torch.randn(100, 128)
cos = nn.CosineEmbeddingLoss(reduction='mean')

# # 需要初始化一个N维的1或-1
loss_flag = torch.ones([100]) 
output = cos(input1, input2, loss_flag)

print(output)	# tensor(1.0003)

1.3.1 数据预处理

数据集:https://github.com/CLUEbenchmark/SimCLUE/tree/main

预训练模型依然是哈工大开源的chinese-macbert-base

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset
import torch

# 离线加载数据
dataset = load_dataset("json", data_files="./train_pair_1w.json", split="train")

# 数据集划分
datasets = dataset.train_test_split(test_size=0.2)


# 和多项选择相似的处理方式
model_path = '/root/autodl-fs/models/chinese-macbert-base'
tokenizer = AutoTokenizer.from_pretrained(model_path)

def process_function(examples):
    sentences = []
    labels = []
    for sen1, sen2, label in zip(examples["sentence1"], examples["sentence2"], examples["label"]):
        sentences.append(sen1)
        sentences.append(sen2)
        # 这里label处理为1和-1
        labels.append(1 if int(label) == 1 else -1)
    # input_ids, attention_mask, token_type_ids
    tokenized_examples = tokenizer(sentences, max_length=128, truncation=True, padding="max_length")
    tokenized_examples = {k: [v[i: i + 2] for i in range(0, len(v), 2)] for k, v in tokenized_examples.items()}
    tokenized_examples["labels"] = labels
    return tokenized_examples

tokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)
tokenized_datasets
DatasetDict({
    train: Dataset({
        features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
        num_rows: 8000
    })
    test: Dataset({
        features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],
        num_rows: 2000
    })
})

1.3.2 自定义训练模型

from transformers import BertForSequenceClassification, BertPreTrainedModel, BertModel
from typing import Optional
from transformers.configuration_utils import PretrainedConfig
from torch.nn import CosineSimilarity, CosineEmbeddingLoss

class DualModel(BertPreTrainedModel):

    def __init__(self, config: PretrainedConfig, *inputs, **kwargs):
        super().__init__(config, *inputs, **kwargs)
        self.bert = BertModel(config)
        self.post_init()

    def forward(
        self,
        input_ids: Optional[torch.Tensor] = None,
        attention_mask: Optional[torch.Tensor] = None,
        token_type_ids: Optional[torch.Tensor] = None,
        position_ids: Optional[torch.Tensor] = None,
        head_mask: Optional[torch.Tensor] = None,
        inputs_embeds: Optional[torch.Tensor] = None,
        labels: Optional[torch.Tensor] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ):
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict

        # Step1 分别获取sentenceA 和 sentenceB的输入
        senA_input_ids, senB_input_ids = input_ids[:, 0], input_ids[:, 1]
        senA_attention_mask, senB_attention_mask = attention_mask[:, 0], attention_mask[:, 1]
        senA_token_type_ids, senB_token_type_ids = token_type_ids[:, 0], token_type_ids[:, 1]

        # Step2 分别获取sentenceA 和 sentenceB的向量表示
        senA_outputs = self.bert(
            senA_input_ids,
            attention_mask=senA_attention_mask,
            token_type_ids=senA_token_type_ids,
            position_ids=position_ids,
            head_mask=head_mask,
            inputs_embeds=inputs_embeds,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        senA_pooled_output = senA_outputs[1]    # [batch, hidden]

        senB_outputs = self.bert(
            senB_input_ids,
            attention_mask=senB_attention_mask,
            token_type_ids=senB_token_type_ids,
            position_ids=position_ids,
            head_mask=head_mask,
            inputs_embeds=inputs_embeds,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        senB_pooled_output = senB_outputs[1]    # [batch, hidden]

        # step3 计算相似度
        cos = CosineSimilarity()(senA_pooled_output, senB_pooled_output)    # [batch, ]

        # step4 计算loss
        loss = None
        if labels is not None:
            loss_fct = CosineEmbeddingLoss(0.3)
            loss = loss_fct(senA_pooled_output, senB_pooled_output, labels)

        output = (cos,)
        return ((loss,) + output) if loss is not None else output
    
model = DualModel.from_pretrained(model_path)

1.3.3 创建评估函数

import evaluate

# 这里采用离线加载
accuracy_path = '/root/autodl-tmp/transformers-code/metrics/accuracy'
f1_path = '/root/autodl-tmp/transformers-code/metrics/f1'

acc_metric = evaluate.load(accuracy_path)
f1_metirc = evaluate.load(f1_path)


def eval_metric(eval_predict):
    predictions, labels = eval_predict
    predictions = [int(p > 0.7) for p in predictions]
    labels = [int(l > 0) for l in labels]
    acc = acc_metric.compute(predictions=predictions, references=labels)
    f1 = f1_metirc.compute(predictions=predictions, references=labels)
    acc.update(f1)
    return acc

1.3.4 创建TrainingArguments及Trainer

train_args = TrainingArguments(output_dir="./dual_model",      # 输出文件夹
                               per_device_train_batch_size=32,  # 训练时的batch_size
                               per_device_eval_batch_size=32,  # 验证时的batch_size
                               logging_steps=10,                # log 打印的频率
                               evaluation_strategy="epoch",     # 评估策略
                               save_strategy="epoch",           # 保存策略
                               save_total_limit=3,              # 最大保存数
                               learning_rate=2e-5,              # 学习率
                               weight_decay=0.01,               # weight_decay
                               metric_for_best_model="f1",      # 设定评估指标
                               load_best_model_at_end=True)     # 训练完成后加载最优模型
trainer = Trainer(model=model, 
                  args=train_args, 
                  train_dataset=tokenized_datasets["train"], 
                  eval_dataset=tokenized_datasets["test"], 
                  compute_metrics=eval_metric)
trainer.train()

transformer模型做文本相似度检测,# 深度学习,深度学习,python

1.3.5 自定义pipeline实现模型评估

class SentenceSimilarityPipeline:

    def __init__(self, model, tokenizer) -> None:
        self.model = model.bert
        self.tokenizer = tokenizer
        self.device = model.device

    def preprocess(self, senA, senB):
        return self.tokenizer([senA, senB], max_length=128, truncation=True, return_tensors="pt", padding=True)

    def predict(self, inputs):
        inputs = {k: v.to(self.device) for k, v in inputs.items()}
        return self.model(**inputs)[1]  # [2, 768]

    def postprocess(self, logits):
        cos = CosineSimilarity()(logits[None, 0, :], logits[None,1, :]).squeeze().cpu().item()
        return cos

    def __call__(self, senA, senB, return_vector=False):
        inputs = self.preprocess(senA, senB)
        logits = self.predict(inputs)
        result = self.postprocess(logits)
        if return_vector:
            return result, logits
        else:
            return result
pipe = SentenceSimilarityPipeline(model, tokenizer)

pipe("我喜欢北京", "明天不行", return_vector=True)
(0.4414671063423157,
 tensor([[ 0.8044, -0.7820,  0.9974,  ..., -0.6317, -0.9653, -0.4989],
         [ 0.3756,  0.0484,  0.9767,  ..., -0.9928, -0.9980, -0.5648]],
        device='cuda:0', grad_fn=<TanhBackward0>))

注:文本向量化更加便捷有效的工具

  • sentence-transformers

https://www.sbert.net/

  • text2vec

https://github.com/shibing624/text2vec

  • uniem

https://github.com/wangyuxinwhy/uniem

2、检索式对话机器人

2.1 检索式对话机器人简介

  • 对话机器人在本质上是一个用来模拟人类对话或聊天的计算机程序,接收人类的自然语言作为输入并给出合适的回复

  • 按照任务类型划分,对话机器人简单的可以划分为闲聊机器人、问答机器人、任务型对话机器人

  • 按照答案产生的逻辑划分,对话机器人可以划分为检索式对话机器人和生成式对话机器人

如何实现基于检索的问答机器人?

QQ匹配策略

可以利用QQ匹配策略,即取最优结果的Q对应的Answer作为最终结果。

transformer模型做文本相似度检测,# 深度学习,深度学习,python

  • 但是使用向量匹配的模型效果并不好,很难直接取到最优结果

  • 因此引入基于交互策略模型。向量匹配模块又称为召回模块,交互策略的模块又称为排序模块

transformer模型做文本相似度检测,# 深度学习,深度学习,python

2.2 向量匹配和交互策略结合实现检索对话机器人

法律知道数据集
https://github.com/SophonPlus/ChineseNlpCorpus

预训练模型
1.2章节训练的交互模型
1.3章节训练的匹配模型

2.2.1 加载自己训练的向量匹配模型

import pandas as pd

data = pd.read_csv("./law_faq.csv")
data.head()

transformer模型做文本相似度检测,# 深度学习,深度学习,python文章来源地址https://www.toymoban.com/news/detail-810511.html

# dual_model.py文件中是自定义的DualModel
from dual_model import DualModel
from transformers import AutoTokenizer

# 加载自己训练好的模型
dual_model = DualModel.from_pretrained("../12-sentence_similarity/dual_model/checkpoint-500/")
dual_model = dual_model.cuda()
dual_model.eval()
print("匹配模型加载成功!")


# 加载tokenzier
model_path = '/root/autodl-fs/models/chinese-macbert-base'
tokenzier = AutoTokenizer.from_pretrained(model_path)

2.2.2 将知识库中的问题编码为向量

import torch
from tqdm import tqdm


questions = data["title"].to_list()
vectors = []
with torch.inference_mode():
    for i in tqdm(range(0, len(questions), 32)):
        batch_sens = questions[i: i + 32]
        inputs = tokenzier(batch_sens, return_tensors="pt", padding=True, max_length=128, truncation=True)
        inputs = {k: v.to(dual_model.device) for k, v in inputs.items()}
        # 这里拿出[CLS]的向量表示
        vector = dual_model.bert(**inputs)[1]
        vectors.append(vector)
vectors = torch.concat(vectors, dim=0).cpu().numpy()
vectors.shape
(18213, 768)

2.2.3 将知识库中的问题向量存入向量库中

# pip install faiss-cpu
import faiss

index = faiss.IndexFlatIP(768)
faiss.normalize_L2(vectors)
index.add(vectors)
index

2.2.4 将用户问题编码为向量

quesiton = "寻衅滋事"
with torch.inference_mode():
    inputs = tokenzier(quesiton, return_tensors="pt", padding=True, max_length=128, truncation=True)
    inputs = {k: v.to(dual_model.device) for k, v in inputs.items()}
    vector = dual_model.bert(**inputs)[1]
    q_vector = vector.cpu().numpy()
q_vector.shape
(1, 768)

2.2.5 向量匹配

faiss.normalize_L2(q_vector)
# 使用faiss进行搜索
scores, indexes = index.search(q_vector, 10)

# 将匹配到的相似问题及答案召回
topk_result = data.values[indexes[0].tolist()]

# 匹配到的相似问题
topk_result[:, 0]
array(['涉嫌寻衅滋事', '两个轻微伤够寻衅滋事', '敲诈勒索罪', '聚群斗殴', '飞达暴力催收', '打架斗殴',
       '涉嫌犯罪?????', '殴打他人治安处罚', '遵守法律的措施', '十级伤残工伤'], dtype=object)

2.2.6 加载自己训练的交互模型

from transformers import BertForSequenceClassification


corss_model = BertForSequenceClassification.from_pretrained("../12-sentence_similarity/cross_model/checkpoint-500/")
corss_model = corss_model.cuda()
corss_model.eval()
print("模型加载成功!")

2.2.7 最终的预测结果

# 候选问题集合
canidate = topk_result[:, 0].tolist()
ques = [quesiton] * len(canidate)
inputs = tokenzier(ques, canidate, return_tensors="pt", padding=True, max_length=128, truncation=True)
inputs = {k: v.to(corss_model.device) for k, v in inputs.items()}
with torch.inference_mode():
    logits = corss_model(**inputs).logits.squeeze()
    result = torch.argmax(logits, dim=-1)
result
tensor(0, device='cuda:0')
# 候选答案集合
canidate_answer = topk_result[:, 1].tolist()

match_quesiton = canidate[result.item()]
final_answer = canidate_answer[result.item()]
match_quesiton, final_answer
('涉嫌寻衅滋事',
 '说明具有寻衅滋事行为,应受到相应的处罚,行为人情形严重或行为恶劣的涉嫌了寻衅滋事罪。寻衅滋事是指行为人结伙斗殴的、追逐、拦截他人的、强拿硬要或者任意损毁、占用公私财物的、其他寻衅滋事的行为。寻衅滋事罪,是指在公共场所无事生非、起哄闹事,造成公共场所秩序严重混乱的,追逐、拦截、辱骂、恐吓他人,强拿硬要或者任意损毁、占用公私财物,破坏社会秩序,情节严重的行为。对于寻衅滋事行为的处罚:1、《中华人*共和国治安管理处罚法》第二十六条规定,有下列行为之一的,处五日以上十日以下拘留,可以并处五百元以下罚款;情节较重的,处十日以上十五日以下拘留,可以并处一千元以下罚款:()结伙斗殴的;()追逐、拦截他人的;()强拿硬要或者任意损毁、占用公私财物的;()其他寻衅滋事行为;...)

到了这里,关于Transformers实战(二)快速入门文本相似度、检索式对话机器人的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Hugging Face 的 Transformers 库快速入门 (一)开箱即用的 pipelines

    注:本系列教程仅供学习使用, 由原作者授权, 均转载自小昇的博客 。 Transformers 是由 Hugging Face 开发的一个 NLP 包,支持加载目前绝大部分的预训练模型。随着 BERT、GPT 等大规模语言模型的兴起,越来越多的公司和研究者采用 Transformers 库来构建 NLP 应用,因此熟悉 Transformer

    2023年04月27日
    浏览(50)
  • Hugging Face快速入门(重点讲解模型(Transformers)和数据集部分(Datasets))

    本文主要包括如下内容: Hugging Face是什么,提供了哪些内容 Hugging Face模型的使用(Transformer类库) Hugging Face数据集的使用(Datasets类库) Hugging Face Hub和 Github 类似,都是Hub(社区)。Hugging Face可以说的上是机器学习界的Github。Hugging Face为用户提供了以下主要功能: 模型仓库(

    2024年01月21日
    浏览(48)
  • 🔥🔥Java开发者的Python快速实战指南:探索向量数据库之图像相似搜索-文字版

    首先,我要向大家道个歉。原本我计划今天向大家展示如何将图片和视频等形式转换为向量并存储在向量数据库中,但是当我查看文档时才发现,腾讯的向量数据库尚未完全开发完成。因此,今天我将用文本形式来演示相似图片搜索。如果您对腾讯的产品动态不太了解,可以

    2024年02月05日
    浏览(81)
  • Java开发者的Python快速实战指南:探索向量数据库之图像相似搜索-文字版

    首先,我要向大家道个歉。原本我计划今天向大家展示如何将图片和视频等形式转换为向量并存储在向量数据库中,但是当我查看文档时才发现,腾讯的向量数据库尚未完全开发完成。因此,今天我将用文本形式来演示相似图片搜索。如果您对腾讯的产品动态不太了解,可以

    2024年02月05日
    浏览(87)
  • Python Qt6快速入门-自定义对话框和标准对话框

    对话框是有用的 GUI 组件,可以与用户进行交流(因此得名对话框)。 它们通常用于文件打开/保存、设置、首选项或不适合应用程序主 UI 的功能。 它们是位于主应用程序前面的小模态(或阻塞)窗口,直到它们被关闭。 Qt 为最常见的用例提供

    2024年02月03日
    浏览(53)
  • milvus和相似度检索

    milvus 的使用流程是 创建collection - 创建partition - 创建索引(如果需要检索) - 插入数据 - 检索 这里以 Python 为例, 使用的milvus版本为2.3.x 首先按照库, python3 -m pip install pymilvus 以上是源码,可以看出 alias 只是一个字典的映射的key 通过源码可以看到,还有两种连接方式: 在.env文件

    2024年02月07日
    浏览(35)
  • transformers生成式对话机器人

    生成式对话机器人是一种人工智能技术,它通过学习大量自然语言数据,模拟人类进行开放、连贯和创造性的对话。这种类型的对话系统并不局限于预定义的回答集,而是能够根据上下文动态生成新的回复内容。其核心组件和技术包括: 1、神经网络架构:现代生成式对话机

    2024年03月10日
    浏览(56)
  • MySQL全文索引:中文语义分词检索(相似度匹配)

    前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。 通常情况下,全文检索引擎我们一般会用ES组件(传送门:SpringBoot系列——ElasticSearch),但不是所有业务都有那么大的数据量、那么大的并发要求,MySQL5.7之后内置

    2023年04月09日
    浏览(43)
  • 【向量数据库】相似向量检索Faiss数据库的安装及余弦相似度计算(C++)

    Faiss 是一个强大的向量相似度搜索库,具有以下优点: 高效的搜索性能:Faiss 在处理大规模向量数据时表现出色。它利用了高度优化的索引结构和近似搜索算法,可以快速地执行最近邻搜索和相似度匹配,具有很低的查询延迟。 高度可扩展:Faiss 提供了多种索引结构和算法

    2024年02月07日
    浏览(55)
  • es最大相似度检索(原生与java客户端)

    原生rest: 对“不好”进行分词, \\\"operator\\\": \\\"and\\\" 意思是同时满足。 结果: java RestHighLevelClient

    2024年02月11日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包