point2｜文本如何向量化？

# 引入fasttext库
import fasttext

# 使用 fasttext 进行无监督训练。
# 'data.txt'：表示用来训练模型的数据文件的路径。
# model='skipgram'：表示使用 skipgram 模型进行训练。
# 在词嵌入（word embedding）中，skipgram 是一种常用的方法，其主要目的是预测上下文。
# 而另一种常用的方法是 CBOW（Continuous Bag-Of-Words），其主要目的是使用上下文来预测目标词。
model = fasttext.train_unsupervised('data.txt', model='skipgram')

# 保存训练好的模型到'model.bin'这个文件中。
# 这样，后续可以直接加载这个模型进行各种操作，而不需要再次训练。
model.save_model('model.bin')

# 引入 fasttext 库
import fasttext

# 使用 fasttext 训练一个无监督的模型。
# 'data.txt' 是训练数据的文件路径。
# 使用 'skipgram' 方法来训练，该方法是一种常见的词向量训练方法，与 'cbow'（另一种常见方法）相对。
# 其中，'skipgram' 预测上下文中的单词，而 'cbow' 根据上下文预测目标单词。
model = fasttext.train_unsupervised('data.txt', model='skipgram')

# 保存训练好的模型到 'model.bin' 文件。
model.save_model('model.bin')

# 引入必要的库
import fasttext
import numpy as np  # NumPy 是一个 Python 库，提供了大量数值计算功能
import faiss  # Faiss 是 Facebook AI 提供的一个库，用于高效搜索和聚类大规模数据集

# 加载一个已经训练好的 FastText 模型
model = fasttext.load_model('model.bin')  # 从 'model.bin' 文件加载预训练的 FastText 模型

# 转换文本为向量
vectors = []  # 初始化一个空的列表来存储句子向量
for line in open('data.txt', 'r', encoding="utf-8"):  # 从 'data.txt' 文件中逐行读取文本数据
    # 使用 FastText 模型获取每一行文本的向量表示，并加入到 vectors 列表中
    vectors.append(model.get_sentence_vector(line.strip()))  # line.strip() 去除文本行两端的空白字符

# 创建一个 Faiss 索引
# 为了使用 Faiss，首先需要确定要索引的向量的维度。这里我们使用 vectors[0].shape[0] 来获取第一个向量的维度。
index = faiss.IndexFlatL2(vectors[0].shape[0])  # 创建一个使用 L2 距离的简单扁平索引
index.add(np.array(vectors))  # 将句子向量列表转化为 NumPy 数组并加入到 Faiss 索引中

# 保存创建好的 Faiss 索引到 'vector.index' 文件中，以便后续使用
faiss.write_index(index, 'vector.index')

# 加载一个已经存储的 FAISS 索引。
# 'vector.index' 是之前建立并保存的索引文件，它包含了大量的向量，我们想要在其中搜索最相似的向量。
index = faiss.read_index('vector.index')

# 定义搜索函数。
def search(query_text, top_k=10):
    # 使用之前训练的 FastText 模型 (或其他模型) 获取 `query_text` 的向量表示。
    # 这里假定 `model.get_sentence_vector` 是从 FastText 模型获取句子向量的方法。
    query_vector = model.get_sentence_vector(query_text)
    
    # 使用 FAISS 索引搜索与 `query_vector` 最相似的向量。
    # D 是每个最近邻向量与查询向量的距离，I 是最近邻向量的索引。
    D, I = index.search(np.array([query_vector]), top_k)
    
    # 返回最相似向量的索引。注意，I[0] 是因为我们搜索的是一个向量，所以结果在第0位置。
    return I[0]

# 使用例子
# 给定一个文本 `input_text`，使用上述函数找到与其最相似的向量的索引。
input_text = "输入的文本"
result_ids = search(input_text)

# 导入需要的库
import fasttext   # 用于文本向量化的库
import numpy as np  # numpy 用于数组和向量操作
import faiss  # 用于高效相似度搜索的库

# 1. 使用 FastText 将文本转换为向量
def train_fasttext_model(data_file):
    # 使用 FastText 的无监督学习方法训练 skipgram 模型
    model = fasttext.train_unsupervised(data_file, model='skipgram')
    # 保存训练好的模型为 'model.bin'
    model.save_model('model.bin')

# 2. 使用 Faiss 存储文本向量，并使用余弦相似度进行检索
def build_faiss_index(data_file):
    # 加载已经训练好的 FastText 模型
    model = fasttext.load_model('model.bin')

    # 初始化一个空的向量列表
    vectors = []
    # 逐行读取文本数据文件
    for line in open(data_file, 'r', encoding="utf-8"):
        # 对每一行的文本获取其向量表示
        vector = model.get_sentence_vector(line.strip())
        vector /= np.linalg.norm(vector)  # 对向量进行 L2 范数归一化
        vectors.append(vector)

    # 使用 faiss 创建一个内积索引
    index = faiss.IndexFlatIP(len(vectors[0]))
    index.add(np.array(vectors))  # 向索引中添加向量

    # 保存创建的索引为 'cosine_vector.index'
    faiss.write_index(index, 'cosine_vector.index')

# 3. 检索相似文本
def search(query_text, top_k=3):
    # 加载已经训练好的 FastText 模型和 faiss 索引
    model = fasttext.load_model('model.bin')
    index = faiss.read_index('cosine_vector.index')
    
    # 从 data.txt 中加载原始文本列表
    original_texts = [line.strip() for line in open('data.txt', 'r', encoding="utf-8")]
    
    # 对查询文本获得其向量表示
    query_vector = model.get_sentence_vector(query_text)
    query_vector /= np.linalg.norm(query_vector)  # L2范数归一化

    # 使用 faiss 索引进行搜索，获取最相似的top_k个结果
    D, I = index.search(np.array([query_vector]), top_k)
    
    # 返回相似结果对应的原始文本
    return [original_texts[i] for i in I[0]]

# 4. 主函数
if __name__ == '__main__':
    # 以下是测试部分，可以根据需要注释或取消注释
    # train_fasttext_model('data.txt')   # 训练 FastText 模型
    # build_faiss_index('data.txt')  # 构建 faiss 索引

    # 测试的文本列表
    test_texts = [
        "我想吃水果。",
        "今日阳光明媚。",
        "深度学习是一个有趣的领域。",
        "今天阳光不错"
    ]

    # 对于每个测试文本，进行相似文本的检索，并打印结果
    for t in test_texts:
        results = search(t)
        print(f"对于测试文本：'{t}'，最相似的文本是：'{results[0]}'\n")

import fasttext
import numpy as np
import faiss

# 1. 使用FastText转换文本为向量
def train_fasttext_model(data_file):
    model = fasttext.train_unsupervised(data_file, model='skipgram')
    model.save_model('model.bin')

# 2. 使用Faiss存储文本向量，并使用余弦相似度
def build_faiss_index(data_file):
    # 加载已经训练好的FastText模型
    model = fasttext.load_model('model.bin')
    
    vectors = []
    texts = []
    for line in open(data_file, 'r'):
        texts.append(line.strip())
        vector = model.get_sentence_vector(line.strip())
        vector /= np.linalg.norm(vector)  # L2范数归一化
        vectors.append(vector)
    
    # 创建一个Faiss的内积索引
    index = faiss.IndexFlatIP(len(vectors[0]))
    index.add(np.array(vectors))
    
    # 保存索引
    faiss.write_index(index, 'cosine_vector.index')
    
    # 保存原始文本列表
    with open('texts.txt', 'w', encoding='utf-8') as f:
        for text in texts:
            f.write(text + '\n')

# 3. 检索相似文本
def search(query_text, top_k=10):
    model = fasttext.load_model('model.bin')
    index = faiss.read_index('cosine_vector.index')
    
    query_vector = model.get_sentence_vector(query_text)
    query_vector /= np.linalg.norm(query_vector)  # L2范数归一化
    _, I = index.search(np.array([query_vector]), top_k)
    
    # 从texts.txt中读取原始文本并返回结果
    texts = [line.strip() for line in open('texts.txt', 'r')]
    results = [texts[i] for i in I[0]]
    
    return results

if __name__ == '__main__':
    # 可以根据需要注释/取消注释以下部分
    # train_fasttext_model('data.txt')
    # build_faiss_index('data.txt')
    
    input_text = "输入的文本"
    similar_texts = search(input_text)
    for text in similar_texts:
        print(text)