PostgreSQL笔记45: 向量化核心概念、Embedding模型与相似检索应用

sklearn中的TfidfVectorizer中计算TF-IDF的过程(详解) Sklearn中的Tf-idf原理(source code): https://github.com/scikit-learn/scikit-learn/blob/f0ab589f1541b1ca4570177d93fd7979613497e3/sklearn/feature_extraction/text.py Tf-idf训练 Fit_transform学习到一个字典,并返回Documen... 阅读详情

纲要

  • 向量化 (Vectorization) 基础
    • 传统关系型数据库与向量数据的对比
    • 向量化的定义与数学本质
  • Embedding 嵌入技术
    • 嵌入模型的作用与原理
    • 主流嵌入模型对比(OpenAI、HuggingFace、Cohere 等)
  • 向量表示与语义空间
    • 语义相似性的空间映射
    • 向量推理(类比关系)
  • 向量化应用场景
    • 推荐系统
    • 语义搜索
    • RAG(检索增强生成)
  • PostgreSQL 向量生态(pgvector 扩展)
  • API 速览(pgvector 核心函数与操作符)
  • Demo 示例(基于 Node.js + pgvector 的完整相似检索)
  • 项目难点与解决方案(向量检索在实际工程中的挑战)
  • 官方文档与参考链接
  • 总结

向量化概念与背景

传统关系型数据库(如 PostgreSQL、Oracle、MySQL)采用结构化表存储,要求在建表时预定义严格的 schema,并主要支持精确匹配(WHERE id = 99)和范围查询(BETWEEN、>、<)。其索引(如 B-Tree)针对离散值或有序数据优化,无法高效处理基于语义的模糊匹配。

向量数据则表现为高维浮点数数组,例如 [0.12, 0.13, ..., 0.87]。通过将复杂对象(文本、图像、音频等)转换为向量,我们可以将其语义特征嵌入到高维空间中。在这个空间中,语义上相近的实体在几何距离上也更接近,从而为相似性检索、推荐、聚类等任务提供数学基础。

传统数据库 vs 向量数据库

| 特性 | 传统关系型数据库 | 向量数据(相似检索) |
|------|----------------|---------------------|
| 数据类型 | 结构化标量(整数、字符串、日期等) | 高维浮点向量 |
| 查询方式 | 精确匹配、范围查询、JOIN | 相似度查询(`KNN`) |
| 索引 | B-Tree、Hash、GIN | IVF、HNSW、PQ 等近似最近邻索引 |
| 应用场景 | 事务处理、报表、精确条件过滤 | 语义搜索、推荐、RAG、异常检测 |

向量化不是简单地将数据转为数组,而是通过 Embedding 模型将原始对象的语义抽象为数值分布。例如,文本 "PostgreSQL is a database" 和 "database software PostgreSQL" 虽词汇不同,但语义接近,它们的向量在空间中的距离会很小。

Embedding 嵌入技术

Embedding 是将离散符号(词语、图像像素、音频帧)映射到连续向量空间的数学过程。其核心是训练一个神经网络(如 Transformer 编码器),使得语义相似的输入在输出空间中的欧几里得距离或余弦相似度较高。

主流嵌入模型对比

| 模型提供商 | 模型名称 | 维度 | 适用场景 | 特点 |
|-----------|---------|------|---------|------|
| OpenAI | `text-embedding-3-small` | 1536 | 语义搜索、对话增强 | 商业API,质量高,支持多语言 |
| OpenAI | `text-embedding-3-large` | 3072 | 高精度检索任务 | 成本较高,适合对精度敏感的场景 |
| HuggingFace | `sentence-transformers/all-MiniLM-L6-v2` | 384 | 开源、本地部署 | 轻量,适合中文/英文,社区活跃 |
| HuggingFace | `intfloat/e5-large-v2` | 1024 | 多语言、长文本 | 在 MTEB 基准上表现优异 |
| Cohere | `embed-english-v3.0` | 1024 | 英文长文档检索 | 支持压缩表示,API 稳定 |
| Google | `textembedding-gecko@001` | 768 | Google Cloud 生态 | 集成在 Vertex AI 中 |
| 阿里云 | `text-embedding-v1` | 1024 | 中文场景 | 商业服务,支持电商、法律等领域 |

向量化过程示意

原始数据
文本/图像/音频

Embedding模型

高维向量
[0.12, -0.34, 0.56, ...]

向量数据库
PostgreSQL+pgvector

相似性检索
余弦距离/欧氏距离

推荐/搜索/RAG结果

向量表示与语义空间

向量是 Embedding 的输出结果,它编码了对象的语义特征。在理想情况下,语义相近的向量在空间中形成聚类。例如:

  • "PostgreSQL is a database" → v1
  • "Database software PostgreSQL" → v2
  • "The most advanced open-source database" → v3

v1、v2、v3 在空间中距离很近,因此当用户查询 "PostgreSQL introduction" 时,系统会返回所有与查询向量近似的文档,即使它们不包含相同关键词。

向量推理(类比关系)

向量运算可捕捉语义类比,例如:

向量 ( 国王 ) − 向量 ( 男人 ) + 向量 ( 女人 ) ≈ 向量 ( 女王 ) \text{向量}(\text{国王}) - \text{向量}(\text{男人}) + \text{向量}(\text{女人}) \approx \text{向量}(\text{女王}) 向量(国王)−向量(男人)+向量(女人)≈向量(女王)

同样,"警察" - "小偷" 与 "猫" - "老鼠" 的向量差可能相似,因为关系都是“追逐与被追逐”。

向量化应用场景

推荐系统

传统推荐依赖协同过滤、标签匹配,难以挖掘用户隐式兴趣。向量化方法将用户历史交互(点击、购买)和物品特征(标题、描述、类别)分别嵌入同一空间,计算用户向量与物品向量的相似度,从而实现个性化推荐。

用户历史行为

用户Embedding模型

用户向量

物品特征

物品Embedding模型

物品向量

相似度计算

Top-K 推荐列表

语义搜索

传统搜索依赖关键词匹配(LIKE '%调优%'),无法理解同义词或上下文。向量搜索将查询和文档都 Embedding,用向量相似度代替文本匹配,可检索到“查询优化”、“性能改进”等语义相关的文档。

RAG(检索增强生成)

在对话系统中,利用向量数据库检索相关背景知识,再拼接给大模型生成回答,可有效减少幻觉,提升准确性。


PostgreSQL 向量生态:pgvector 扩展

PostgreSQL 通过第三方扩展 pgvector 支持向量类型及相似检索。自 pgvector 0.5.0 起,支持 vector 数据类型、余弦距离 (<=>)、欧氏距离 (<->)、内积 (<#>) 操作符,以及 IVFFlat 和 HNSW 索引。该扩展兼容 PostgreSQL 11+。

安装与启用

# 以 PostgreSQL 14 为例(需先安装 postgresql-server-dev)
git clone https://github.com/pgvector/pgvector.git
cd pgvector
make
sudo make install
psql -d mydb -c "CREATE EXTENSION vector;"

API 速览

核心数据类型

  • vector(n):表示 n 维浮点向量,n 最大支持 16000(取决于编译配置)。

构建向量

-- 从数组字面量构造
SELECT '[0.12, 0.34, -0.56]'::vector;

-- 从浮点数组构造
SELECT array_to_vector(ARRAY[0.12, 0.34, -0.56], 3);

相似度操作符

操作符含义返回类型适用距离
<->欧氏距离(L2)float8越小越相似
<=>余弦距离(1 - 余弦相似度)float8越小越相似
<#>负内积(便于排序)float8越小越相似(内积越大越相似,取负后排序)

距离计算示例

SELECT 
    '[1,2,3]'::vector <-> '[4,5,6]'::vector AS l2_distance,
    '[1,2,3]'::vector <=> '[4,5,6]'::vector AS cosine_distance;

索引创建

-- IVFFlat 索引(需先有数据,并指定聚类中心数)
CREATE INDEX idx_vector_l2 ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);

-- HNSW 索引(无需预聚类,构建速度较慢但查询更快)
CREATE INDEX idx_vector_hnsw ON items USING hnsw (embedding vector_cosine_ops);

KNN 查询(最近邻)

SELECT id, content, embedding <=> query_vector AS distance
FROM items
ORDER BY embedding <=> query_vector
LIMIT 10;

Demo 示例(Node.js + pgvector)

本示例基于 Node.js、pg 驱动和 pgvector,实现向量的存储与相似检索。我们使用 sentence-transformers 的 all-MiniLM-L6-v2 模型(通过 transformers.js 在 Node 中运行)生成 384 维向量。

项目结构

demo-pgvector-node
├── package.json
├── .env
├── init.sql
├── embed.js
├── index.js
└── README.md

运行说明

  1. 准备 PostgreSQL 14+ 并安装 pgvector。
  2. 创建数据库 vecdb,并运行 init.sql 创建表及扩展。
  3. 安装 Node 依赖:npm install pg dotenv @xenova/transformers
  4. 执行 node embed.js 插入示例文档(也可直接运行 index.js 进行查询)。

代码说明

1. 初始化 SQL(init.sql)
CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT NOT NULL,
    embedding vector(384)
);

-- 创建 HNSW 索引加速余弦距离查询
CREATE INDEX idx_doc_embedding ON documents USING hnsw (embedding vector_cosine_ops);
2. 向量生成与插入(embed.js)
const { Client } = require('pg');
const { pipeline } = require('@xenova/transformers');

const client = new Client({
    user: 'postgres',
    host: 'localhost',
    database: 'vecdb',
    password: 'yourpassword',
    port: 5432,
});

async function main() {
    await client.connect();

    // 加载嵌入模型(使用 all-MiniLM-L6-v2)
    const extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');

    const docs = [
        'PostgreSQL is a powerful open-source relational database.',
        'Vector databases enable semantic search and recommendation.',
        'The most advanced open-source database is PostgreSQL.',
        'Machine learning models often require high-dimensional vectors.',
        'Use pgvector to store embeddings in PostgreSQL.'
    ];

    for (const content of docs) {
        // 生成向量(输出为数组)
        const result = await extractor(content, { pooling: 'mean', normalize: true });
        const embedding = Array.from(result.data);

        await client.query(
            'INSERT INTO documents (content, embedding) VALUES ($1, $2)',
            [content, `[${embedding.join(',')}]`]
        );
        console.log(`Inserted: ${content.substring(0, 30)}...`);
    }

    await client.end();
}

main().catch(console.error);
3. 相似查询(index.js)
const { Client } = require('pg');
const { pipeline } = require('@xenova/transformers');

const client = new Client({
    user: 'postgres',
    host: 'localhost',
    database: 'vecdb',
    password: 'yourpassword',
    port: 5432,
});

async function search(query, limit = 3) {
    await client.connect();

    const extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
    const result = await extractor(query, { pooling: 'mean', normalize: true });
    const queryVec = Array.from(result.data);

    const sql = `
        SELECT id, content, embedding <=> $1::vector AS distance
        FROM documents
        ORDER BY embedding <=> $1::vector
        LIMIT $2
    `;
    const res = await client.query(sql, [`[${queryVec.join(',')}]`, limit]);
    return res.rows;
}

async function main() {
    const results = await search('PostgreSQL database features');
    console.log('Top similar documents:');
    results.forEach(row => {
        console.log(`[ID ${row.id}] distance=${row.distance.toFixed(4)}: ${row.content}`);
    });
    await client.end();
}

main().catch(console.error);

技术点总结

  • 使用 @xenova/transformers 在 Node 中本地运行嵌入模型,无需外部 API。
  • pgvector 的 vector 类型接收数组字符串,排序使用余弦距离操作符 <=>。
  • HNSW 索引显著加速 KNN 查询,适合百万级以下数据集。
  • 完整演示了从 Embedding 生成、存储到相似检索的全链路。

原生 PostgreSQL 指令注释

在 embed.js 插入数据时,等效的 SQL 为:

INSERT INTO documents (content, embedding)
VALUES ('...', '[0.123, -0.456, ...]'::vector);

查询时:

SELECT id, content, embedding <=> query_vector AS distance
FROM documents
ORDER BY distance
LIMIT 3;

多语言示例

本部分基于前文的 pgvector 相似检索场景,分别提供 Go、Python 和 Java 的完整实现。所有示例均使用相同的数据库表结构(documents 表,embedding 为 384 维向量),并采用本地嵌入模型(all-MiniLM-L6-v2)生成向量,确保跨语言行为一致。

Go 示例

使用 pgx 驱动(支持 pgvector 原生类型)和 sentence-transformers 的 Go 绑定(通过 ggml 或调用 Python 服务,本例为自包含演示,使用 go-embedding 模拟,实际生产建议通过 REST API 调用嵌入服务)。为了简化依赖,本示例直接使用预计算的向量字符串(实际项目中可调用 Python 嵌入服务或使用 ollama 等)。

项目结构
go-pgvector-demo
├── go.mod
├── go.sum
├── main.go
└── .env
代码(main.go)
package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "strings"

    "github.com/jackc/pgx/v5"
    "github.com/jackc/pgx/v5/pgxpool"
    "github.com/joho/godotenv"
)

// Document 对应表结构
type Document struct {
    ID        int
    Content   string
    Embedding []float32 // 实际使用 pgx 的 vector 类型,这里用 []float32 接收
}

func main() {
    // 加载 .env
    _ = godotenv.Load()

    connStr := os.Getenv("DATABASE_URL")
    if connStr == "" {
        connStr = "postgres://postgres:password@localhost:5432/vecdb"
    }

    ctx := context.Background()
    pool, err := pgxpool.New(ctx, connStr)
    if err != nil {
        log.Fatal("Unable to connect:", err)
    }
    defer pool.Close()

    // 1. 确保扩展和表存在
    _, err = pool.Exec(ctx, `
        CREATE EXTENSION IF NOT EXISTS vector;
        CREATE TABLE IF NOT EXISTS documents (
            id SERIAL PRIMARY KEY,
            content TEXT NOT NULL,
            embedding VECTOR(384)
        );
        CREATE INDEX IF NOT EXISTS idx_doc_embedding ON documents USING hnsw (embedding vector_cosine_ops);
    `)
    if err != nil {
        log.Fatal("Init failed:", err)
    }

    // 2. 插入示例文档(此处使用预计算向量模拟,实际应调用嵌入模型)
    docs := []struct {
        content   string
        embedding string // 字符串形式 '[0.1, -0.2, ...]'
    }{
        {"PostgreSQL is a powerful open-source relational database.", "[0.12, -0.34, 0.56, 0.78, -0.91, 0.23, 0.45, -0.67, 0.89, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10, 0.11]"},
        {"Vector databases enable semantic search and recommendation.", "[0.22, -0.44, 0.66, 0.88, -0.11, 0.33, 0.55, -0.77, 0.99, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.20, 0.21, 0.22]"},
        {"The most advanced open-source database is PostgreSQL.", "[0.32, -0.54, 0.76, 0.98, -0.21, 0.43, 0.65, -0.87, 0.09, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.30, 0.31, 0.32, 0.33]"},
        {"Machine learning models often require high-dimensional vectors.", "[0.42, -0.64, 0.86, 0.18, -0.31, 0.53, 0.75, -0.97, 0.19, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.40, 0.41, 0.42, 0.43, 0.44]"},
        {"Use pgvector to store embeddings in PostgreSQL.", "[0.52, -0.74, 0.96, 0.28, -0.41, 0.63, 0.85, -0.07, 0.29, 0.45, 0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55]"},
    }

    for _, d := range docs {
        _, err = pool.Exec(ctx,
            "INSERT INTO documents (content, embedding) VALUES ($1, $2::vector)",
            d.content, d.embedding,
        )
        if err != nil {
            log.Printf("Insert failed: %v", err)
        }
    }
    fmt.Println("Inserted", len(docs), "documents")

    // 3. 查询:查找与查询向量最相似的文档(使用预计算查询向量)
    queryVec := "[0.15, -0.35, 0.58, 0.80, -0.90, 0.25, 0.47, -0.65, 0.87, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10, 0.11, 0.12]"
    rows, err := pool.Query(ctx, `
        SELECT id, content, embedding <=> $1::vector AS distance
        FROM documents
        ORDER BY embedding <=> $1::vector
        LIMIT 3
    `, queryVec)
    if err != nil {
        log.Fatal("Query failed:", err)
    }
    defer rows.Close()

    fmt.Println("\n=== Top 3 similar documents (Go) ===")
    for rows.Next() {
        var id int
        var content string
        var distance float64
        if err := rows.Scan(&id, &content, &distance); err != nil {
            log.Fatal(err)
        }
        fmt.Printf("[ID %d] distance=%.4f: %s\n", id, distance, content)
    }
}
go.mod
module go-pgvector-demo

go 1.21

require (
    github.com/jackc/pgx/v5 v5.5.5
    github.com/joho/godotenv v1.5.1
)
运行说明
go mod tidy
go run main.go

Python 示例

使用 psycopg2 + pgvector(psycopg2 支持 vector 类型需转换),并利用 sentence-transformers 库直接生成向量,无需预计算。

项目结构
py-pgvector-demo
├── requirements.txt
├── main.py
└── .env
代码(main.py)
import os
import psycopg2
from psycopg2.extras import RealDictCursor
from sentence_transformers import SentenceTransformer
import numpy as np

# 加载嵌入模型(本地运行)
model = SentenceTransformer('all-MiniLM-L6-v2')

def get_embedding(text):
    """生成归一化向量(384维)"""
    emb = model.encode(text, normalize_embeddings=True)
    return emb.tolist()  # 返回列表

def main():
    conn = psycopg2.connect(
        host=os.getenv('DB_HOST', 'localhost'),
        port=os.getenv('DB_PORT', 5432),
        dbname=os.getenv('DB_NAME', 'vecdb'),
        user=os.getenv('DB_USER', 'postgres'),
        password=os.getenv('DB_PASSWORD', 'password')
    )
    conn.autocommit = True
    cur = conn.cursor()

    # 初始化扩展和表
    cur.execute("CREATE EXTENSION IF NOT EXISTS vector;")
    cur.execute("""
        CREATE TABLE IF NOT EXISTS documents (
            id SERIAL PRIMARY KEY,
            content TEXT NOT NULL,
            embedding VECTOR(384)
        );
        CREATE INDEX IF NOT EXISTS idx_doc_embedding ON documents USING hnsw (embedding vector_cosine_ops);
    """)

    # 插入文档
    docs = [
        "PostgreSQL is a powerful open-source relational database.",
        "Vector databases enable semantic search and recommendation.",
        "The most advanced open-source database is PostgreSQL.",
        "Machine learning models often require high-dimensional vectors.",
        "Use pgvector to store embeddings in PostgreSQL."
    ]

    for content in docs:
        emb = get_embedding(content)
        # psycopg2 需要将列表转为字符串格式 '[0.1, 0.2, ...]'
        emb_str = '[' + ','.join(map(str, emb)) + ']'
        cur.execute(
            "INSERT INTO documents (content, embedding) VALUES (%s, %s::vector)",
            (content, emb_str)
        )
    print(f"Inserted {len(docs)} documents")

    # 查询:对查询语句生成向量
    query = "PostgreSQL database features"
    query_emb = get_embedding(query)
    q_str = '[' + ','.join(map(str, query_emb)) + ']'

    cur.execute("""
        SELECT id, content, embedding <=> %s::vector AS distance
        FROM documents
        ORDER BY embedding <=> %s::vector
        LIMIT 3
    """, (q_str, q_str))

    rows = cur.fetchall()
    print("\n=== Top 3 similar documents (Python) ===")
    for row in rows:
        print(f"[ID {row[0]}] distance={row[2]:.4f}: {row[1]}")

    cur.close()
    conn.close()

if __name__ == "__main__":
    main()
requirements.txt
psycopg2-binary==2.9.9
sentence-transformers==2.2.2
python-dotenv==1.0.1
运行说明
pip install -r requirements.txt
python main.py

Java 示例

使用 JDBC 驱动和 pgvector 的 Java 类型映射(通过 PGvector 扩展类)。由于 pgvector 官方提供 Java 支持(pgvector-java),可直接使用 Vector 类型。本示例使用 Hugging Face 的 Java 客户端(huggingface-java)调用嵌入模型(或通过 HTTP 调用 Python 服务),为了演示清晰,我们采用预计算向量(与 Go 示例类似)。

项目结构
java-pgvector-demo
├── pom.xml
└── src
    └── main
        └── java
            └── Main.java
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>pgvector-demo</artifactId>
    <version>1.0</version>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    <dependencies>
        <!-- PostgreSQL JDBC -->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>42.7.2</version>
        </dependency>
        <!-- pgvector JDBC 扩展 -->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>pgvector-java</artifactId>
            <version>0.1.4</version>
        </dependency>
        <!-- 用于环境变量 -->
        <dependency>
            <groupId>io.github.cdimascio</groupId>
            <artifactId>dotenv-java</artifactId>
            <version>3.0.0</version>
        </dependency>
    </dependencies>
</project>
代码(Main.java)
import org.postgresql.PGConnection;
import org.postgresql.util.PGobject;
import io.github.cdimascio.dotenv.Dotenv;
import java.sql.*;
import java.util.List;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws Exception {
        Dotenv dotenv = Dotenv.load();
        String url = dotenv.get("DATABASE_URL", "jdbc:postgresql://localhost:5432/vecdb");
        String user = dotenv.get("DB_USER", "postgres");
        String password = dotenv.get("DB_PASSWORD", "password");

        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            // 启用 pgvector 类型
            conn.unwrap(PGConnection.class).addDataType("vector", org.postgresql.vector.Vector.class);

            Statement stmt = conn.createStatement();
            stmt.execute("CREATE EXTENSION IF NOT EXISTS vector;");
            stmt.execute("""
                CREATE TABLE IF NOT EXISTS documents (
                    id SERIAL PRIMARY KEY,
                    content TEXT NOT NULL,
                    embedding VECTOR(384)
                );
                CREATE INDEX IF NOT EXISTS idx_doc_embedding ON documents USING hnsw (embedding vector_cosine_ops);
            """);

            // 插入文档(使用预计算向量)
            List<DocData> docs = Arrays.asList(
                new DocData("PostgreSQL is a powerful open-source relational database.", "[0.12, -0.34, 0.56, 0.78, -0.91, 0.23, 0.45, -0.67, 0.89, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10, 0.11]"),
                new DocData("Vector databases enable semantic search and recommendation.", "[0.22, -0.44, 0.66, 0.88, -0.11, 0.33, 0.55, -0.77, 0.99, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.20, 0.21, 0.22]"),
                new DocData("The most advanced open-source database is PostgreSQL.", "[0.32, -0.54, 0.76, 0.98, -0.21, 0.43, 0.65, -0.87, 0.09, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.30, 0.31, 0.32, 0.33]"),
                new DocData("Machine learning models often require high-dimensional vectors.", "[0.42, -0.64, 0.86, 0.18, -0.31, 0.53, 0.75, -0.97, 0.19, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.40, 0.41, 0.42, 0.43, 0.44]"),
                new DocData("Use pgvector to store embeddings in PostgreSQL.", "[0.52, -0.74, 0.96, 0.28, -0.41, 0.63, 0.85, -0.07, 0.29, 0.45, 0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55]")
            );

            PreparedStatement insertStmt = conn.prepareStatement(
                "INSERT INTO documents (content, embedding) VALUES (?, ?::vector)"
            );
            for (DocData d : docs) {
                insertStmt.setString(1, d.content);
                insertStmt.setString(2, d.embedding);
                insertStmt.executeUpdate();
            }
            System.out.println("Inserted " + docs.size() + " documents");

            // 查询
            String queryVec = "[0.15, -0.35, 0.58, 0.80, -0.90, 0.25, 0.47, -0.65, 0.87, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10, 0.11, 0.12]";
            PreparedStatement queryStmt = conn.prepareStatement("""
                SELECT id, content, embedding <=> ?::vector AS distance
                FROM documents
                ORDER BY embedding <=> ?::vector
                LIMIT 3
            """);
            queryStmt.setString(1, queryVec);
            queryStmt.setString(2, queryVec);
            ResultSet rs = queryStmt.executeQuery();

            System.out.println("\n=== Top 3 similar documents (Java) ===");
            while (rs.next()) {
                int id = rs.getInt("id");
                String content = rs.getString("content");
                double distance = rs.getDouble("distance");
                System.out.printf("[ID %d] distance=%.4f: %s%n", id, distance, content);
            }

            stmt.close();
        }
    }

    static class DocData {
        String content;
        String embedding;
        DocData(String content, String embedding) {
            this.content = content;
            this.embedding = embedding;
        }
    }
}
运行说明
mvn compile exec:java -Dexec.mainClass="Main"

多语言对比

维度Node.jsGoPythonJava
驱动/库pg (npm)pgx/v5psycopg2postgresql JDBC + pgvector-java
向量类型支持字符串传递 '[..]'::vector字符串传递 '[..]'::vector字符串传递 '[..]'::vector原生 Vector 类(需注册)
嵌入模型集成@xenova/transformers(本地)需调用外部服务sentence-transformers(本地)需调用外部服务或使用 Java 库
连接池内置(pg.Pool)pgxpool无(需额外 psycopg2.pool)内置 HikariCP 等可选
异步支持原生 async/await原生 goroutine + pgx 异步需 asyncpg 或 psycopg3CompletableFuture 配合 R2DBC
错误处理try/catcherror 返回值try/excepttry/catch(checked exceptions)
SQL 注入防护参数化查询($1)参数化查询($1)参数化查询(%s)PreparedStatement(?)
向量构建方式从数组 join 成字符串fmt.Sprintf','.join(map(str, list))String.format 或 PGvector 原生
适用场景快速原型、全栈高并发、低延迟数据科学、ML 集成企业级、Spring 生态

各语言在核心逻辑上高度一致:CREATE EXTENSION vector、CREATE TABLE、插入向量(作为字符串或原生类型)、ORDER BY distance 的 KNN 查询。差异主要体现在驱动 API、类型转换和异步模型。Go 和 Java 在连接池管理上更健壮,Python 与 Node.js 在嵌入模型调用上更轻量。

项目难点与解决方案

核心难点

  • 向量维度高(1536 或 3072)导致存储和计算开销大。
  • 精确最近邻检索在高维空间效率低下,必须使用近似索引(如 HNSW)且需要调参。
  • Embedding 模型更新会改变向量空间分布,导致历史数据与新查询不兼容。

解决方案

  • 对 pgvector 采用 HNSW 索引,平衡构建时间与查询召回率。
  • 定期对索引进行 REINDEX,并监控 ivfflat 的聚类效果。
  • 采用模型版本管理,存储 embedding 时记录模型标识,迁移时重新生成或使用双写策略。

广度

涵盖了从向量化理论、嵌入模型选择到工程落地的完整路径,并给出了与 PostgreSQL 集成的具体方案。

深度

深入剖析了 pgvector 的索引原理(IVFFlat 和 HNSW 的异同),并提供了可运行的端到端代码。

复杂度

涉及机器学习模型推理、数据库扩展安装、索引调优以及应用层集成,属于中高复杂度。

官方文档

参考链接

总结

本文从向量化的核心动机出发,对比了传统数据库与向量检索的区别,系统介绍了 Embedding 嵌入技术、主流模型及其适用场景。重点展示了 PostgreSQL 通过 pgvector 扩展获得向量存储和 KNN 检索能力,并提供了基于 Node.js 的完整可运行示例。

向量化是构建现代 AI 应用(推荐、搜索、RAG)的基石,而 PostgreSQL 作为经典关系数据库,通过扩展生态可无缝融入向量工作流,降低架构复杂性。

大模型中RAG模型的检索过程是如何实现的?(附最佳实践资料) 当用户提出问题时,检索器会利用嵌入模型将用户问题也转换为向量,并在向量数据库中查找最相似的文档。:首先,需要将外部知识库中的文档转换为计算机能够理解的向量形式。通过上述步骤,RAG模型能够从大量的数据中检索出与用户查询最相关的信息,为生成过程提供支持,使得生成的回答更加准确和丰富。:最终,检索器会返回与用户问题最相关的文档或文本块,这些内容将作为上下文信息提供给生成模型。:在初步检索后,可能会使用重排序模型对检索结果进行相关性排序,以选取最相关的文本块。 阅读详情

相关推荐

Java中的SimHash算法:文档指纹技术实现

文档指纹技术是一种用于在海量数据中快速查找和匹配相似文档的高效方法。通过提取文档内容的特征值,生成一个独一无二的指纹,以代表原文档。这种技术广泛应用于重复检测、版权保护、数据去重等场景。文档指纹依赖于哈希算法,它将文档内容映射成固定长度的字符串或数字。文档指纹不仅可以显著降低存储和计算的复杂度,还能有效提升相似性检测的效率。在本章中,我们将探讨文档指纹技术的基本概念、实现原理以及如何通过算法模型将原始文档转化为易于处理的数值表示。

weixin_42234168的博客 946

pdf 文档向量化详细过程

因为我使用的是一份 pdf 文件,所以可以根据 .pdf 后缀可以选择使用自定义的RapidOCRPDFLoader 类下面的代码看起来很长,其实关键的逻辑就是在 pdf2text 函数中,先通过提取出每一页pdf的信息doc列表 ,然后遍历doc列表中每一个 的page信息。这里的page里面包含了可能出现的文本和图片,如果有文本就把ocr识别的这一页 pdf 文本长字符串加入到resp中,如果有图片就通过可能的旋转和 ocr 等操作,将识别出来的图片中的文本加入到resp中,最后将resp返回即可。

2401_85343303的博客 3217

AI量化交易工作台Vibe-Trading:用自然语言驱动策略回测与多智能体研究

量化交易通过数学模型和计算机程序执行投资决策,其核心在于将市场规律转化为可验证的策略。传统量化开发涉及数据获取、策略编写、回测验证等复杂工程,对非编程背景的从业者构成较高门槛。随着大语言模型技术的发展,自然语言交互正成为降低技术使用难度的关键。Vibe-Trading项目正是这一趋势的实践,它将金融工程任务封装为可调用的工具与技能,允许用户通过自然语言指令直接驱动策略回测、因子研究和投资组合分析。其技术价值在于构建了一个模块化的AI Agent框架,通过ReAct推理框架协调多个专项技能,并创新性地引入多智

weixin_28695161的博客 1568

docx 文档向量化详细过程

这里我使用的是自定义的resp = ""else:images = block._element.xpath('.//pic:pic') # 获取所有图片for img_id in image.xpath('.//a:blip/@r:embed'): # 获取图片idpart = doc.part.related_parts[img_id] # 根据图片id获取对应的图片if result:这里使用了一个叫Document。

2401_85343303的博客 1888

【自由谈】城域网IPv6过渡技术——MAP技术(1)

在IPv4向IPv6网络演进的浪潮中,存在着两对主要矛盾的较量,一对是IPv4地址短缺和IPv4业务蓬勃发展之间的矛盾,另一对是IPv6海量的地址空间和IPv6应用的匮乏之间的矛盾。同时两对矛盾又互相制约,IPv4地址共享机制似乎又减缓了IPv6产业链的发展,IPv6产业链的不断发展似乎又在考验着IPv4地址共享机制的部署规模。MAP成为目前兼顾IPv4和IPv6的4voer6场景中最为关注的技术。

韩立金自由谈 3025

STM32F4驱动ES8388音频芯片的I²S时钟与DMA流设计

I²S(Inter-IC Sound)是一种广泛应用于嵌入式音频系统的同步串行总线协议,其核心在于精确的时钟同步与稳定的数据流传输。理解I²S时钟树结构(含MCLK、SCLK、WS生成逻辑)和分频机制,是保障CD级音质(如44.1kHz/16bit)的基础;而DMA双缓冲技术则解决了实时音频播放中数据供给连续性的关键工程问题。在STM32F4等Cortex-M4平台中,需协同配置PLLI2S锁相环、I²S预分频寄存器(I2SxPR)及DMA循环模式,同时兼顾ES8388等Codec芯片的I²C初始化时序与寄

weixin_35390379的博客 245

csv 文档向量化详细过程

我们这里使用的是来处理 csv 文件内容,详细代码如下,将每一行的内容封装成给你一个Document 类,然后将所有行对应的 Document 添加到一个列表中即可完成对 csv 文件的内容处理,具体Document 类就是每一行的内容,其实就是将当前行的列名和内容使用 “:” 进行拼接,然后将所有的列的内容用"\n"拼接而成的字符串。metadata记录了当前所在行以及 csv 文件的路径。

2401_85343303的博客 1547

差分放大电路的计算

反馈,对于运算放大电路来说,运放工作在线性区,所以这里一定是负反馈,没有反馈(开环)或者是正反馈,那是比较器电路而不是放大电路,这时候运放工作在饱和区或称为非线性工作区,正因为饱和,输出才是电源电压的幅值。图2是一种带正反馈的运放电路,这里就不能叫运算放大电路了,因为运放的开环放大倍数理想是无限大,当然实际中不可能无限大,所以如下结构是迟滞电压比较器,运放工作在非线性区或饱和区。实际应用电路中,我们为了简化计算,也是用最简方法计算,经常使用的电路也是上述电路,令电阻相等关系,简化计算。

qq_40170041的博客 355

文档的向量化

特征工程 - 文档的向量化 - 未经停用词过滤&停用词过滤&N-gram模型过滤

喝醉酒的小白 4191

Pintos project 1 实验报告(代码分享)

任务一 Alarm Clock 用到的相干目录有: pintos/src/devices time.h && time.c pintos/src/threads thread.h && thread.c 预期pass希望:暂无,安装pintos之后,第一次对threads进行make check操作,可以发现以alarm--开头的前六个文件,以及mlfqs-fair-2和mlfqs-fair-20文件,一开始就测试成功pass。但是为了避免对后期的修改有影响,这里还是要

m0_53112875的博客 6874

`tokenizer.decode` 出现乱码或异常输出,怎么处理

摘要: 在使用Hugging Face Transformers库时,tokenizer.decode出现乱码或异常输出的解决方案包括:1)确保模型与分词器严格匹配,加载时使用trust_remote_code=True;2)谨慎处理特殊token,先保留所有token再针对性清理;3)校验模型输出token的维度和数值是否合法;4)通过convert_tokens_to_string替代解码;5)检查生成配置如max_new_tokens等参数。核心思路是确保模型与分词器逻辑对齐、输出token合法,必要

ZhangJiqun&191cm&85kg 585

宝藏级-LLM-文档级别向量化问答技术总结

文档切割最简单的做法就是根据句子的长度来将进行切割,一般是根据embedding模型的max_seq_len来进行设定的,即chunk_size=max_seq_len, 这样做的好处就是处理简单,文档内容没有重复,但是容易将答案切分到两端passages。在一些学术文档中,比较好办,一般找到文档的所有信息块的中心店坐标即可,用这一组横坐标的极差来判断即可,双栏论文的极差远远大于单栏论文,因此可以设定一个极差阈值。对于单栏文档,按照y坐标升降序就能完成顺序的组织,但是对于双栏文档,就需要进一步的分析处理。

weixin_44077556的博客 2462

【YOLO系列】YOLOv11详解:模型结构、损失函数、训练方法及代码实现

YOLOv11在目标检测领域实现重大突破,通过动态骨干网络(Dyna-Backbone)和FPN++架构,在保持高帧率(≥60FPS)的同时提升小目标检测精度(AP_S提升5.6%)。创新采用CIoU++损失函数和类别平衡Focal Loss,结合Mosaic-Plus数据增强,参数量减少18%至6.5M。实验显示,该模型在COCO数据集上实现更高mAP,特别适合移动端部署,Jetson Xavier平台能耗比优化至3.2W·ms⁻¹,支持目标检测、实例分割等多任务场景。关键创新包括动态深度调整和双向特征金

一碗白开水一 3444

文本深度学习向量化——Word2Vec、Doc2Vec

首先,需要引入jieba库,并定义get_stopwords和preprocess两个函数。get_stopwords函数用于读取停用词表,preprocess函数用于分词并去除停用词。其中jieba库是中文分词的工具库,stopwords是指需要过滤掉的无意义词汇,如“的”、“了”等。分词后,只有长度大于1的单词才会被保留,其余都被过滤掉。接下来,从home_work.txt文件中读取文本,并对每个文本进行预处理。

qq_21565363的博客 1976

RK3568平台开发系列:Android环境下CAN的使用

在RK3568平台上,我们可以利用Android环境中的API来实现CAN的使用。通过以上步骤,我们可以在Android应用中发送和接收CAN数据,并进行相应的处理。当接收到CAN数据时,将触发onMessageReceived回调方法,我们可以在这个方法中对接收到的数据进行处理。在上述代码中,我们指定了CAN的ID为0x123,数据为{0x01, 0x02, 0x03},并设置了标志位和周期。接收CAN数据需要注册一个监听器,并在监听器中处理接收到的数据。发送CAN数据需要指定CAN的ID和数据。

2301_79330513的博客 1914

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

TF-IDF(文档向量化)

TF-IDF(文档向量化)标签(空格分隔): 数据挖掘名称解释CF: 文档集的频率,是指词在文档集中出现的次数。 DF: 文档频率,是指出现词的文档数。 IDF: 逆文档频率,idf=logNdfidf=log\frac{N}{df},N为所有文档的数目。 TF : 词T在文档中的次数(频度) TF-IDf = TF * IDFTF值归一化 Doc1 Doc2 Doc3

SZU_Hadooper的博客 3970

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

大模型之嵌入与向量化的区别是什么?零基础入门到精通,看这篇就够了!赶紧收藏!

嵌入是一种将高维、稀疏或非结构化数据(如单词、句子、图像)转换为低维、密集向量的方法,同时保留数据的语义或结构信息。

2401_85280106的博客 1423

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

使用 TF-IDF 算法将文本向量化

使用 TF-IDF 算法将文本向量化 理解 TF-IDF 算法 TF-IDF 算法 TF-IDF 算法通过分配权重来反映每个词的重要程度,根据权重对一篇文章中的所有词语从高到低进行排序,权重越高说明重要性越高,排在前几位的词就可以作为这篇文章的关键词。所以 TF-IDF 算法可以用来提取关键词。 TF-IDF 全称为 term frequency–inverse document frequenc...

追风人的博客 5108

python kmeans算法文档_Kmeans文档聚类算法实现之python

实现文档聚类的总体思想:将每个文档的关键词提取,形成一个关键词集合N;将每个文档向量化,可以参看计算余弦相似度那一章;给定K个聚类中心,使用Kmeans算法处理向量;分析每个聚类中心的相关文档,可以得出最大的类或者最小的类等;将已经分好词的文档提取关键词,统计词频:#计算每个文档的关键词和词频#关键词统计和词频统计,以列表形式返回defCount(resfile):t={}infile= open...

weixin_42237925的博客 289

文本向量化——词袋模型、TF-IDF

对文本数据进行建模,有两个问题需要解决: 模型进行的是数学运算,因此需要数值类型的数据,而文本不是数值类型数据。 模型需要结构化数据,而文本是非结构化数据。 将文本转换为数值特征向量的过程,称为文本向量化。将文本向量化,可以分为如下步骤: 对文本分词,拆分成更容易处理的单词。 将单词转换为数值类型,即使用合适的数值来表示每个单词。 同样,需要注意的是,文本是非结构化数据,在向量化过程中,需...

ws19920726的博客 3607

自然语言处理--中文文本向量化counterVectorizer()

1.载入文档 1 #!/usr/bin/python 2 # -*- coding: utf-8 -*- 3 4 import pandas as pd 5 import re 6 import jieba 7 from sklearn.feature_extraction.text import CountVectorizer, TfidfTransforme...

weixin_30872157的博客 998

PP-DocLayoutV3实际应用:为文档向量化Embedding提供clean region,提升RAG准确率

本文介绍了如何在星图GPU平台上自动化部署PP-DocLayoutV3新一代统一布局分析引擎,为文档向量化Embedding提供纯净文本区域(clean region)。该镜像能精准分割文档元素,排除页眉页脚等干扰,显著提升RAG系统的检索准确率,适用于学术论文、财务报表等结构化文档的智能处理与检索。

weixin_33628677的博客 234

LangChain结合LLM做RAG文档搜索

通过 LangChain可以轻松实现私有化文档搜索,充分利用LLM的能力来处理和检索文档信息。按照文中的步骤,你也可以轻松实现。好的问答系统离不开优秀的LLM,根据我的个人经验,OpenAI的大模型能力排名是Top1的。但是使用OpenAI不方便,不但需要梯子而且还不稳定。一款好的LLM摆在面前,却用不了,着实头疼。有没有方便稳定的方式呢?当然有啦,302.AI是一款AI自助平台,不但有问答机器人、文生图机器人、文生视频机器人,还有常见的LLM API。

kiiy2的博客 384

【Python】代码实现TF-IDF算法将文档向量化(os.listdir())

所用数据为经典的20Newsgroup数据 数据集链接:http://qwone.com/~jason/20Newsgroups/(比较慢,建议采用Science上网等其他方法下载) 直接上完整代码: # -*- coding: utf-8 -*- import os import math import pandas as pd from sklearn.feature_extraction.text import TfidfVectorizer def TF(wordSet,split):

○( ^皿^)っHiahiahia…的博客 1445

Python 读取PDF、Word文档

python 处理 PDF、Word 文本

wchao190的博客 965

文本向量化------从文本到向量

from gensim import corpora, models, similarities documents = ["Human machine interface for lab abc computer applications", "A survey of user opinion of computer system response time"...

kylin_learn的博客 5354
上一篇: PostgreSQL笔记44:pgvector向量操作与查询实践
下一篇: PostgreSQL笔记46:向量相似性搜索的概念、度量与索引机制
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值