PostgreSQL笔记46:向量相似性搜索的概念、度量与索引机制

使用PostgreSQL创建高级搜索引擎 ​本文我们将探索PostgreSQL中的全文搜索功能,并研究我们能够复制多少典型搜索引擎功能。如果您想跟随并尝试示例查询(我们建议这样做,这样更有趣),可以使用来自Kaggle的Wikipedia电影情节数据集执行代码示例。该数据集包含 34,000 个电影标题,CSV 格式大小约为 81 MB。PostgreSQL的全文搜索方法提供了一些基础组件,您可以将它们组合起来创建自己的搜索引擎。 阅读详情

纲要

  • pgvector 扩展
  • KNN (K-Nearest Neighbor) 精确最近邻搜索
  • ANN (Approximate Nearest Neighbor) 近似最近邻搜索
  • 召回率 (Recall) 及其与查询速度的权衡
  • 距离度量方法
    • 欧几里得距离 (L2) – 运算符 <->
    • 余弦距离 (Cosine) – 运算符 <=>
    • 内积 (Inner Product) – 运算符 <#>
  • IVFFlat 索引(参数 lists、probes)
  • HNSW 索引
  • 索引选择与调优策略

精确最近邻搜索(KNN)及其局限性

在向量检索中,最基础的需求是:给定一个查询向量,从数据集中找出与其最相似的 k 个向量。这一操作在学术与工业界统称为 KNN (K-Nearest Neighbor)。

KNN 的实现方式非常直观——它需要计算查询向量与数据集中每一个向量的距离,然后按距离升序排序,取出前 k 个结果。这种方法的本质是精确搜索 (Exact Search),其优势在于召回率(Recall)为 100%,即绝不会遗漏任何真正的最近邻。

然而,KNN 的时间复杂度为 O ( n ⋅ d ) O(n \cdot d) O(n⋅d),其中 n n n 为向量总数, d d d 为向量维度。在百万级甚至亿级数据量的生产环境中,每次查询都需遍历全表并执行大量浮点运算,响应时间通常达到秒级甚至分钟级,无法满足实时性要求。正因如此,工业界普遍采用近似方案来换取性能。

近似最近邻搜索(ANN)与召回率

ANN (Approximate Nearest Neighbor) 是一种以牺牲少量精度为代价,大幅提升检索速度的技术路线。其核心思想是:通过构建特定的索引结构,在查询时只检索数据集的一个子集,而非全量数据。

例如,通过聚类算法将向量划分到不同的桶(Bucket)中,查询时仅搜索与查询向量最接近的几个桶,从而将计算次数从 n n n 降至 n / num_lists n / \text{num\_lists} n/num_lists 量级。在 pgvector 中,ANN 通过 IVFFlat 或 HNSW 索引实现。

在 ANN 场景中,召回率 (Recall) 是衡量检索质量的核心指标,其定义为:

Recall = ANN 检索到的正确结果数量 KNN 标准答案中的正确结果总数 \text{Recall} = \frac{\text{ANN 检索到的正确结果数量}}{\text{KNN 标准答案中的正确结果总数}} Recall=KNN 标准答案中的正确结果总数ANN 检索到的正确结果数量​

召回率反映了 ANN 结果与 KNN 精确结果之间的重合度。在实际工程中,不同业务场景对召回率的要求存在显著差异:

场景类型召回率要求典型应用
高召回率95% ~ 99%法律法规检索、金融风控、医疗案例检索
中等召回率80% ~ 90%个性化推荐、内容推送
低召回率50% ~ 80%非关键性相似查询、探索性分析

高召回率场景要求结果几乎无遗漏,而推荐类场景更注重响应速度与多样性。召回率与查询速度之间的权衡,是 ANN 索引调优的核心命题。

向量相似度度量方法

在 pgvector 中,相似性搜索必须明确指定一种距离或相似度度量方式。不同度量方法适用于不同类型的数据和语义场景。

欧几里得距离(L2)

欧几里得距离计算两个向量在空间中的直线距离:

d L2 ( a , b ) = ∑ i = 1 n ( a i − b i ) 2 d_{\text{L2}}(\mathbf{a}, \mathbf{b}) = \sqrt{\sum_{i=1}^{n} (a_i - b_i)^2} dL2​(a,b)=i=1∑n​(ai​−bi​)2 ​

该度量对绝对位置敏感,适用于图像特征、地理坐标等场景。pgvector 使用 <-> 运算符表示 L2 距离。

余弦距离(Cosine)

余弦相似度衡量两个向量方向的一致性,其值为夹角余弦:

cosine_similarity ( a , b ) = a ⋅ b ∥ a ∥ ⋅ ∥ b ∥ \text{cosine\_similarity}(\mathbf{a}, \mathbf{b}) = \frac{\mathbf{a} \cdot \mathbf{b}}{\|\mathbf{a}\| \cdot \|\mathbf{b}\|} cosine_similarity(a,b)=∥a∥⋅∥b∥a⋅b​

余弦距离定义为 1 - cosine_similarity。该度量对向量的模长不敏感,仅关注方向,因此特别适合文本语义搜索与文档相似度比较。pgvector 使用 <=> 运算符。

内积(Inner Product / Dot Product)

内积计算两个向量的投影重合程度:

inner_product ( a , b ) = ∑ i = 1 n a i ⋅ b i \text{inner\_product}(\mathbf{a}, \mathbf{b}) = \sum_{i=1}^{n} a_i \cdot b_i inner_product(a,b)=i=1∑n​ai​⋅bi​

内积对向量的模长和方向均敏感,常用于推荐系统中的嵌入向量排名。pgvector 使用 <#> 运算符,但实际返回的是负内积,以便与 PostgreSQL 的索引排序机制兼容。

度量方法选择建议

度量方法运算符适用场景
欧几里得距离 (L2)<->图像检索、地理空间、默认选择
余弦距离<=>文本语义搜索、文档嵌入(推荐)
内积 (负内积)<#>推荐系统、归一化向量的最大内积搜索

注意:对于已归一化的单位向量(模长为 1),余弦距离、负内积与欧几里得距离在排序结果上等价。许多文本嵌入模型(如 text-embedding-ada-002)默认推荐使用余弦相似度。

pgvector 索引:IVFFlat 与 HNSW

pgvector 提供了两种 ANN 索引实现:IVFFlat 和 HNSW。两者均能大幅加速查询,但底层原理和适用场景有所区别。

IVFFlat 索引

IVFFlat (Inverted File Flat) 基于向量量化。其构建过程分为两步:

  1. 对数据集中的向量执行 k-means 聚类,将其划分为若干个列表(List / Cluster)。
  2. 每个列表维护一个质心 (Centroid),即该列表内所有向量的平均值。

查询时,计算查询向量与所有质心的距离,选择最近的若干个列表(由参数 probes 控制),仅在这些列表内部进行精确扫描。

关键参数:

  • lists:聚类总数。推荐值:对于百万级数据,设为 rows / 1000;更大数据集使用 sqrt(rows)。lists 越大,每个列表越小,查询越快,但可能因聚类不精而损失召回率。
  • probes:查询时探测的列表数量。增大 probes 可提升召回率,但会增加查询时间。默认值为 1,生产环境通常设为 10~50。

IVFFlat 索引创建示例:

CREATE INDEX idx_items_embedding ON items 
USING ivfflat (embedding vector_cosine_ops) 
WITH (lists = 100);

重要约束:IVFFlat 索引不能创建在空表上,因为其依赖 k-means 聚类训练。在创建索引前,表中应有足够数据(建议至少数千行)。

HNSW 索引

HNSW (Hierarchical Navigable Small World) 是一种基于多层图结构的 ANN 算法。它构建了多层最近邻图:高层节点稀疏,用于快速定位候选区域;低层节点密集,用于最终精确搜索。查询时从顶层逐层向下导航,在底层找到最近的若干向量。

HNSW 的优势:

  • 无需训练阶段:可在空表上直接创建,并随着数据插入动态更新图结构。
  • 速度-召回率权衡更优:在相同召回率下,通常比 IVFFlat 提供更快的查询响应。
  • 参数调优相对简单。

HNSW 索引创建示例:

CREATE INDEX idx_items_embedding ON items 
USING hnsw (embedding vector_cosine_ops);

HNSW 也支持额外参数(如 m、ef_construction、ef_search)用于精细控制图结构,但默认值已适用于多数场景。

IVFFlat vs HNSW 对比

特性IVFFlatHNSW
是否需要训练数据是(需有数据后创建)否(可空表创建)
构建速度较快较慢(尤其数据量大时)
查询速度中等(受 probes 影响)通常更快
内存占用较低较高(因图结构)
召回率调节通过 probes 灵活调整通过 ef_search 调整
适用场景超大规模数据(亿级)中小规模(千万级)且要求高实时性

在实际项目中,建议根据数据量、性能要求和硬件资源选择合适的索引类型,并通过 EXPLAIN ANALYZE 对比不同配置下的查询延迟与召回率。

API 速览

本节汇总 pgvector 扩展中涉及的核心 SQL 函数与运算符。

向量数据类型

-- 声明向量列(维度固定,例如 1536)
CREATE TABLE items (
    id SERIAL PRIMARY KEY,
    embedding vector(1536)
);

距离运算符

运算符说明返回类型
<->L2 欧几里得距离float8
<=>余弦距离(1 - 余弦相似度)float8
<#>负内积(用于排序)float8

使用示例:

-- 查询与给定向量最相似的 10 条记录(使用余弦距离)
SELECT id, embedding
FROM items
ORDER BY embedding <=> '[0.1, 0.2, ...]'::vector
LIMIT 10;

索引创建函数

-- IVFFlat
CREATE INDEX index_name ON table_name 
USING ivfflat (column_name vector_cosine_ops) 
WITH (lists = 100);

-- HNSW
CREATE INDEX index_name ON table_name 
USING hnsw (column_name vector_cosine_ops);

vector_cosine_ops 可替换为 vector_l2_ops(L2)或 vector_ip_ops(负内积),需与查询中使用的运算符保持一致。

调整查询行为

对于 IVFFlat,可在会话级别或查询级别调整 probes:

-- 设置当前会话的 probes 值
SET ivfflat.probes = 10;

-- 或在查询中通过 enable_indexscan 等强制方式,但更推荐会话级设置。

对于 HNSW,调整 hnsw.ef_search:

SET hnsw.ef_search = 100;

完整 Demo(Node.js + pg)

以下是一个使用 Node.js 和 pg 驱动连接 PostgreSQL,执行向量插入与相似性查询的完整示例。该 Demo 演示了创建表、生成随机向量、创建索引以及执行 ANN 搜索的完整流程。

代码实现

const { Client } = require('pg');

// 连接配置(请替换为实际参数)
const client = new Client({
    host: 'localhost',
    port: 5432,
    database: 'testdb',
    user: 'postgres',
    password: 'secret'
});

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

    // 1. 创建表(向量维度为 128 用于演示)
    await client.query(`
        CREATE TABLE IF NOT EXISTS items (
            id SERIAL PRIMARY KEY,
            embedding vector(128)
        );
    `);

    // 2. 插入 10000 条随机向量(模拟数据)
    console.log('插入测试数据...');
    const insertPromises = [];
    for (let i = 0; i < 10000; i++) {
        const vec = Array.from({ length: 128 }, () => Math.random() * 2 - 1);
        insertPromises.push(
            client.query('INSERT INTO items (embedding) VALUES ($1)::vector', [vec])
        );
    }
    await Promise.all(insertPromises);
    console.log('数据插入完成。');

    // 3. 创建 IVFFlat 索引(需保证表中有数据)
    // 注意:对于小数据集(<1000行)索引效果不明显,此处演示语法
    await client.query(`
        CREATE INDEX IF NOT EXISTS idx_items_embedding
        ON items
        USING ivfflat (embedding vector_cosine_ops)
        WITH (lists = 10);
    `);
    console.log('索引创建完成。');

    // 4. 设置探测数(提高召回率)
    await client.query('SET ivfflat.probes = 5;');

    // 5. 准备查询向量
    const queryVec = Array.from({ length: 128 }, () => Math.random() * 2 - 1);

    // 6. 执行 ANN 搜索(余弦距离)
    const result = await client.query(
        `SELECT id, embedding <=> $1::vector AS distance
         FROM items
         ORDER BY embedding <=> $1::vector
         LIMIT 10;`,
        [queryVec]
    );

    console.log('最近的 10 个向量距离:');
    result.rows.forEach((row, idx) => {
        console.log(`  ${idx+1}. id=${row.id}, distance=${row.distance.toFixed(6)}`);
    });

    await client.end();
}

run().catch(console.error);

运行说明

  1. 确保 PostgreSQL 已安装 pgvector 扩展(执行 CREATE EXTENSION vector;)。
  2. 在项目目录执行 npm init -y && npm install pg。
  3. 将上述代码保存为 demo.js,修改数据库连接参数(host、port、database、user、password)。
  4. 执行 node demo.js。

代码说明

  • 插入数据:批量生成 10000 个 128 维随机向量,模拟真实嵌入数据。
  • 索引创建:使用 ivfflat 并指定 lists=10(小数据集)。对于真实场景,lists 应依据数据量调优。
  • 查询执行:通过 <=> 计算余弦距离,排序后取前 10 个结果。
  • 参数调整:通过 SET ivfflat.probes = 5 调整召回率与速度的平衡。

技术点总结

  • 使用 pgvector 的 vector 类型存储嵌入。
  • 使用 CREATE INDEX 构建 ANN 索引以加速查询。
  • 通过 SET 命令动态调整索引探测参数。
  • 使用 ORDER BY 和距离运算符完成相似性排序。

多语言示例

以下分别使用 Go、Python 和 Java 三种语言实现与 Node.js 示例完全等价的功能:连接 PostgreSQL(含 pgvector 扩展)、创建表、插入 10000 条 128 维随机向量、创建 IVFFlat 索引、设置 probes、执行 ANN 余弦距离查询并输出结果。

Go 示例

代码实现
package main

import (
    "database/sql"
    "fmt"
    "log"
    "math/rand"
    "strconv"
    "strings"
    "time"

    _ "github.com/lib/pq"
)

func main() {
    // 1. 连接 PostgreSQL
    connStr := "host=localhost port=5432 user=postgres password=secret dbname=testdb sslmode=disable"
    db, err := sql.Open("postgres", connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    if err = db.Ping(); err != nil {
        log.Fatal(err)
    }

    // 2. 创建表(向量维度 128)
    _, err = db.Exec(`
        CREATE TABLE IF NOT EXISTS items (
            id SERIAL PRIMARY KEY,
            embedding vector(128)
        );
    `)
    if err != nil {
        log.Fatal(err)
    }

    // 3. 插入 10000 条随机向量
    fmt.Println("插入测试数据...")
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 10000; i++ {
        vec := make([]float64, 128)
        for j := range vec {
            vec[j] = rand.Float64()*2 - 1
        }
        // 构建向量字符串:'[0.1,0.2,...]'
        vecStr := "[" + strings.Join(strings.Fields(fmt.Sprintf("%f", vec)), ",") + "]"
        _, err = db.Exec("INSERT INTO items (embedding) VALUES ($1::vector)", vecStr)
        if err != nil {
            log.Fatal(err)
        }
    }
    fmt.Println("数据插入完成。")

    // 4. 创建 IVFFlat 索引
    _, err = db.Exec(`
        CREATE INDEX IF NOT EXISTS idx_items_embedding
        ON items
        USING ivfflat (embedding vector_cosine_ops)
        WITH (lists = 10);
    `)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("索引创建完成。")

    // 5. 设置 probes
    _, err = db.Exec("SET ivfflat.probes = 5;")
    if err != nil {
        log.Fatal(err)
    }

    // 6. 准备查询向量
    queryVec := make([]float64, 128)
    for j := range queryVec {
        queryVec[j] = rand.Float64()*2 - 1
    }
    queryStr := "[" + strings.Join(strings.Fields(fmt.Sprintf("%f", queryVec)), ",") + "]"

    // 7. 执行 ANN 搜索
    rows, err := db.Query(`
        SELECT id, embedding <=> $1::vector AS distance
        FROM items
        ORDER BY embedding <=> $1::vector
        LIMIT 10;
    `, queryStr)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    fmt.Println("最近的 10 个向量距离:")
    idx := 1
    for rows.Next() {
        var id int
        var distance float64
        if err = rows.Scan(&id, &distance); err != nil {
            log.Fatal(err)
        }
        fmt.Printf("  %d. id=%d, distance=%.6f\n", idx, id, distance)
        idx++
    }
    if err = rows.Err(); err != nil {
        log.Fatal(err)
    }
}
运行说明
  1. 安装 Go 1.18+,并确保 PostgreSQL 已安装 pgvector 扩展(CREATE EXTENSION vector;)。
  2. 在项目目录执行 go mod init demo && go get github.com/lib/pq。
  3. 将代码保存为 main.go,修改连接字符串(host、port、user、password、dbname)。
  4. 执行 go run main.go。
代码说明
  • 使用 github.com/lib/pq 作为 PostgreSQL 驱动。
  • 向量以字符串形式传递(例如 '[0.1,0.2,...]'),通过 ::vector 显式转换。
  • 使用 database/sql 标准接口执行 DDL、插入和查询。
  • 插入采用逐条执行方式(为清晰演示;生产环境建议使用批量插入)。
技术点总结
  • Go 中调用 pgvector 的向量类型需借助字符串转换和类型强转。
  • 使用 SET 语句调整 ivfflat.probes 会话参数。
  • 通过 Query 获取结果集并扫描到结构体字段。
  • 需处理浮点数格式化以确保向量字符串符合 PostgreSQL 数组语法。

Python 示例

代码实现
import psycopg2
import random
import numpy as np

def main():
    # 1. 连接 PostgreSQL
    conn = psycopg2.connect(
        host="localhost",
        port=5432,
        database="testdb",
        user="postgres",
        password="secret"
    )
    cur = conn.cursor()

    # 2. 创建表(向量维度 128)
    cur.execute("""
        CREATE TABLE IF NOT EXISTS items (
            id SERIAL PRIMARY KEY,
            embedding vector(128)
        );
    """)
    conn.commit()

    # 3. 插入 10000 条随机向量
    print("插入测试数据...")
    for _ in range(10000):
        vec = [random.random() * 2 - 1 for _ in range(128)]
        # 使用 psycopg2 的数组适配,但 vector 类型需转为字符串
        vec_str = "[" + ",".join(map(str, vec)) + "]"
        cur.execute("INSERT INTO items (embedding) VALUES (%s::vector);", (vec_str,))
    conn.commit()
    print("数据插入完成。")

    # 4. 创建 IVFFlat 索引
    cur.execute("""
        CREATE INDEX IF NOT EXISTS idx_items_embedding
        ON items
        USING ivfflat (embedding vector_cosine_ops)
        WITH (lists = 10);
    """)
    conn.commit()
    print("索引创建完成。")

    # 5. 设置 probes
    cur.execute("SET ivfflat.probes = 5;")

    # 6. 准备查询向量
    query_vec = [random.random() * 2 - 1 for _ in range(128)]
    query_str = "[" + ",".join(map(str, query_vec)) + "]"

    # 7. 执行 ANN 搜索
    cur.execute("""
        SELECT id, embedding <=> %s::vector AS distance
        FROM items
        ORDER BY embedding <=> %s::vector
        LIMIT 10;
    """, (query_str, query_str))

    print("最近的 10 个向量距离:")
    for idx, (row_id, dist) in enumerate(cur.fetchall(), start=1):
        print(f"  {idx}. id={row_id}, distance={dist:.6f}")

    cur.close()
    conn.close()

if __name__ == "__main__":
    main()
运行说明
  1. 安装 Python 3.8+,并执行 pip install psycopg2-binary numpy(numpy 可选,仅用于向量运算示范,本示例未强制使用)。
  2. 确保 PostgreSQL 已安装 pgvector 扩展。
  3. 将代码保存为 demo.py,修改连接参数。
  4. 执行 python demo.py。
代码说明
  • 使用 psycopg2 驱动,向量值以字符串数组形式传递,借助 %s::vector 类型转换。
  • 插入循环逐条执行,每批次提交(生产环境建议使用 executemany 或批量 INSERT)。
  • 查询使用参数化查询,避免 SQL 注入。
  • 结果通过 fetchall() 一次性获取。
技术点总结
  • Python 中 pgvector 向量以 JSON 数组风格的字符串表示。
  • 使用 psycopg2 的 %s 占位符配合 ::vector 类型转换。
  • 通过 SET 调整索引探测参数。
  • 代码简洁,适合快速原型验证。

Java 示例

代码实现
import java.sql.*;
import java.util.Random;

public class VectorDemo {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/testdb";
        String user = "postgres";
        String password = "secret";

        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement()) {

            // 1. 创建表(向量维度 128)
            stmt.execute("""
                CREATE TABLE IF NOT EXISTS items (
                    id SERIAL PRIMARY KEY,
                    embedding vector(128)
                );
            """);

            // 2. 插入 10000 条随机向量
            System.out.println("插入测试数据...");
            Random rand = new Random();
            String insertSql = "INSERT INTO items (embedding) VALUES (?::vector)";
            try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
                for (int i = 0; i < 10000; i++) {
                    double[] vec = new double[128];
                    StringBuilder sb = new StringBuilder("[");
                    for (int j = 0; j < 128; j++) {
                        vec[j] = rand.nextDouble() * 2 - 1;
                        if (j > 0) sb.append(",");
                        sb.append(vec[j]);
                    }
                    sb.append("]");
                    pstmt.setString(1, sb.toString());
                    pstmt.addBatch();
                    // 每 1000 条执行一批
                    if (i % 1000 == 0) {
                        pstmt.executeBatch();
                    }
                }
                pstmt.executeBatch();
            }
            System.out.println("数据插入完成。");

            // 3. 创建 IVFFlat 索引
            stmt.execute("""
                CREATE INDEX IF NOT EXISTS idx_items_embedding
                ON items
                USING ivfflat (embedding vector_cosine_ops)
                WITH (lists = 10);
            """);
            System.out.println("索引创建完成。");

            // 4. 设置 probes
            stmt.execute("SET ivfflat.probes = 5;");

            // 5. 准备查询向量
            double[] queryVec = new double[128];
            StringBuilder qb = new StringBuilder("[");
            for (int j = 0; j < 128; j++) {
                queryVec[j] = rand.nextDouble() * 2 - 1;
                if (j > 0) qb.append(",");
                qb.append(queryVec[j]);
            }
            qb.append("]");
            String queryStr = qb.toString();

            // 6. 执行 ANN 搜索
            String querySql = """
                SELECT id, embedding <=> ?::vector AS distance
                FROM items
                ORDER BY embedding <=> ?::vector
                LIMIT 10;
            """;
            try (PreparedStatement pstmt = conn.prepareStatement(querySql)) {
                pstmt.setString(1, queryStr);
                pstmt.setString(2, queryStr);
                try (ResultSet rs = pstmt.executeQuery()) {
                    System.out.println("最近的 10 个向量距离:");
                    int idx = 1;
                    while (rs.next()) {
                        int id = rs.getInt("id");
                        double dist = rs.getDouble("distance");
                        System.out.printf("  %d. id=%d, distance=%.6f\n", idx, id, dist);
                        idx++;
                    }
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
运行说明
  1. 安装 JDK 11+,并添加 PostgreSQL JDBC 驱动依赖(例如通过 Maven 或 Gradle,或直接下载 postgresql-42.x.x.jar)。
  2. 确保 PostgreSQL 已安装 pgvector 扩展。
  3. 编译:javac -cp ".:postgresql-42.x.x.jar" VectorDemo.java。
  4. 运行:java -cp ".:postgresql-42.x.x.jar" VectorDemo(Windows 下用 ; 分隔)。
  5. 修改连接 URL、用户名和密码。
代码说明
  • 使用 JDBC 标准 API,PreparedStatement 进行参数化查询。
  • 向量以字符串数组格式传递,通过 ?::vector 转换。
  • 插入使用 addBatch() 批量执行,每 1000 条提交一次,提升性能。
  • 查询结果通过 ResultSet 遍历获取。
技术点总结
  • Java 中需手动构建向量字符串(方括号 + 逗号分隔)。
  • 使用 PreparedStatement 的 setString 传递向量字符串。
  • 批量插入可显著提升性能,适合大数据量场景。
  • 通过 Statement 执行 SET 调整会话参数。

多语言对比

维度Node.js (参考)GoPythonJava
驱动/库pggithub.com/lib/pqpsycopg2-binaryPostgreSQL JDBC
向量传递方式数组直接作为参数(pg 支持)字符串 [0.1,0.2,...] + ::vector字符串 + ::vector字符串 + ::vector
批量插入Promise.all 并发逐条(可改为批量)逐条(可改为 executemany)addBatch + executeBatch
参数占位符$1$1%s?
结果获取result.rows 数组rows.Next() + Scanfetchall() 列表ResultSet 游标
错误处理try-catch / Promise.catchif err != niltry-excepttry-catch
会话参数设置client.query("SET ...")db.Exec("SET ...")cur.execute("SET ...")stmt.execute("SET ...")
代码行数(核心)~35 行~65 行~35 行~70 行
适用生产级别高高中高高

所有语言实现均等价完成以下核心流程:连接 → 建表 → 插入随机向量 → 创建 IVFFlat 索引 → 设置 probes → 执行余弦距离 ANN 查询 → 输出结果。开发者可根据团队技术栈选择合适的语言,调优批量大小和连接池等细节以适应生产环境。

项目难点与解决方案

核心难点

  • 精确与性能的权衡:KNN 保证 100% 召回但性能极差,ANN 速度快但可能遗漏结果,如何根据业务场景选择合适方案。
  • 索引参数调优:IVFFlat 的 lists 与 probes 以及 HNSW 的 ef_search 等参数需要根据数据分布和查询负载进行精细调整。
  • 度量方法选择:不同嵌入模型和业务语义对应不同的距离度量,选错会影响检索结果的相关性。

解决方案

  • 分层设计:对精度要求高的场景(如金融法规检索)使用 KNN 或高召回率 ANN(增大 probes);对推荐等场景采用低召回率但极速的配置。
  • 基准测试:在生产上线前,使用 EXPLAIN ANALYZE 和自定义召回率评估脚本,对比不同索引和参数组合的实际效果。
  • 度量匹配:严格遵循所用嵌入模型的官方推荐(例如 OpenAI 的 text-embedding-ada-002 推荐余弦相似度),并在创建索引时选用对应的运算符类。

广度

  • 涉及数据库索引技术(聚类、图结构)、向量代数(距离度量)、系统性能调优。
  • 跨越传统关系型数据库与 AI 应用两个领域。

深度

  • 深入讲解 IVFFlat 的聚类原理和 HNSW 的图导航机制,而非仅停留在使用层面。
  • 分析了召回率与速度的数学关系,并给出参数调整的量化指导。

复杂度

  • 多参数组合导致调优空间大,且不同数据集下最优配置差异显著。
  • 需要兼顾查询延迟、内存占用、构建时间和召回率等多个目标。

官方文档与参考链接

官方文档

参考链接

总结

本文系统梳理了向量相似性搜索的完整技术栈,从精确 KNN 到近似 ANN,从召回率指标到三种主流距离度量(L2、余弦、内积),并深入解析了 pgvector 提供的 IVFFlat 和 HNSW 两种索引的底层原理、参数调优及适用场景。

同时,通过可运行的 Node.js 演示代码,直观展示了如何在生产环境中落地向量检索能力。理解召回率与速度的权衡、合理选择度量方法与索引类型,是构建高性能向量搜索系统的关键。

Postgres扩展之pgvector:向量相似度搜索 pgvector:在 Postgres 中存储和查询向量。您可以将向量数据与其他数据一起存储在 Postgres 中,并进行向量相似性搜索,同时仍然可以利用 Postgres 提供的所有强大功能。pgvector 扩展与 Postgres 无缝集成 - 允许用户在现有数据库基础设施中利用其功能。通过将向量化处理的能力整合到PostgreSQL中,pgvector允许用户直接在数据库中进行大规模的相似性搜索、机器学习模型预测等多种操作,因为不需要单独的数据存储或复杂的数据传输过程。 阅读详情

相关推荐

PostgreSQL pgvector:如何利用向量数据库提升搜索效率和精度

随着基础模型的兴起,向量数据库的受欢迎程度也飙升。事实上,在大型语言模型环境中,向量数据库也很有用。在机器学习领域,我们经常处理的是向量嵌入。向量嵌入是通过特定的机器学习模型运行对象的特征,将对象的上下文信息投射到潜在空间中来创建的。为了在使用向量嵌入时能够表现得特别好,创建向量数据库是必要的。这方面的工作包括存储、更新和检索向量。当我们谈论检索时,通常是指检索与查询最相似的向量,这些向量与嵌入到同一潜在空间并传递到向量数据库中。这个检索过程被称为近似最近邻。

FrenzyTechAI的博客 1万+

PostgreSQL 做实时高效 搜索引擎 - 全文检索核心功能

搜索语法 1.1 tsquery为搜索输入,支持与,或,反,距离语法,如下 & (AND), | (OR), ! (NOT), and <-> (FOLLOWED BY) and <?> (距离多少?), 例子如下: c有两个位置,在匹配距离时,两个都可以。 postgres=# select to_tsvector('a b c c'); to...

jjj的博客 2925

使用PostgreSQL进行全文检索

通过按照上述步骤安装、配置和使用PostgreSQL数据库服务器,并利用其内置的全文检索功能,我们可以轻松地在大量文本数据中进行快速和高效的全文检索。全文检索是一种强大的技术,可以帮助我们在大量文本数据中快速查找和匹配关键词。PostgreSQL是一种流行的开源关系型数据库管理系统,它提供了内置的全文检索功能,可以帮助我们有效地进行全文检索。安装完成后,需要创建一个数据库和相应的表来存储要进行全文检索的数据。本文将介绍如何在使用PostgreSQL数据库服务器时进行全文检索,并给出相应的源代码示例。

XhClojure的博客 924

PostgreSQL 中强大的全文搜索

这篇博文将引导您了解使用PostgreSQL实现足够好的全文搜索所需的基本部分。 剧透警告:对于那些寻找“好的,只需向我展示一个全文搜索,在 Postgres 中不到 20 行的排名和模糊搜索”的好奇的人,所以你去: SELECT courses.id, courses.title, courses.description, rank_title, rank_description, similarity FROM courses, .

allway2的博客 4131

PostgreSQL 中的全文搜索:综合指南

为了演示如何使用 PostgreSQL 的全文搜索功能,我们假设您有一个名为“articles”的表,其中包含列“id”、“title”和“content”。搜索:PostgreSQL 提供了各种函数和运算符来使用“tsvector”和“tsquery”值对文本数据执行全文搜索。与依赖精确匹配或模式匹配的传统搜索方法不同,FTS 考虑文本的语言和结构以提供更准确和相关的结果。这些索引称为“tsvector 索引”,存储预处理的文本数据,从而实现快速高效的搜索。PostgreSQL 中的全文搜索。

我的博客,不一样的自我表达 984

PostgreSQL中文全文搜索zhparser.zip

Zhparser 是一个 PostgreSQL 的扩展,用于中文的全文搜索。实现了一个中文解析器,基于 SCWS。 标签:zhparser

pgvector终极指南:在PostgreSQL中实现高效向量相似性搜索的实战方案

PostgreSQL向量搜索扩展pgvector为传统关系型数据库注入了强大的AI能力,让开发者能够在熟悉的SQL环境中实现高效的向量相似性搜索。作为开源向量数据库解决方案,pgvector完美融合了PostgreSQL的ACID事务特性和向量检索能力,支持单精度、半精度、二进制和稀疏向量等多种数据类型,为AI应用提供了可靠的数据存储和检索基础设施。 ## 应对高维数据挑战的向量存储方案 现代

gitblog_00574的博客 1155

COMSOL金属氢化物-放氢过程

"层流"的出口设置压降函数,解决“找不到一致的初始值”问题,主要是一开始设置出口为1atm的话,压力场过渡太剧烈,不好找到初始解,要么就先算个稳态流场,这种也能求解。注:P0是根据实测PCT的插值曲线(函数名称为:p_iso)得到的,根据初始质量储氢量wtw0,和初始温度条件T0,然后根据函数p_iso(wtw0)*exp(-deltHd/R_const*(1/T0-1/303.15[K]))求解获得。若"初始步长"选择框不勾上,前面0~5s内的求解容易发散,然后求解失败。2、设置"达西定律"的。

qq_24800941的博客 1932

超强性能pgvector:PostgreSQL向量相似性搜索深度解析

在人工智能和大数据时代,向量相似性搜索(Vector Similarity Search)已成为现代应用的核心技术。无论是推荐系统、语义搜索、图像识别还是异常检测,都需要高效处理高维向量数据。传统的关系型数据库在处理这类场景时面临巨大挑战,而pgvector的出现彻底改变了这一局面。 pgvector是一个开源的PostgreSQL扩展,它将向量相似性搜索原生集成到世界上最先进的开源数据库中。通...

gitblog_01160的博客 971

大模型学习路线之多模态模型

​ (Frankly speaking,博主太懒了)章节一只对CLIP、BLIP、BLIP2、InstructBLIP进行了整理,章节二以CLIP、VisualGLM作为实践案例。​ 实际上多模态模型除了CLIP、BLIP、BLIP2、InstructBLIP,还有LLaVA、miniGPT4,以及国内清华的VisualGLM、阿里的Qwen-VL等。(更多多模态原理可以看文末的参考说明)一、多模态模型 & 理论。

2401_86435672的博客 2294

【深度学习】基于BERT模型的情感分析(附实战完整代码+数据集)

情感分类是一个快速发展的研究领域,尽管众多模型和数据集在二分类任务中显示出很高的准确性,但细粒度的情感分类任务仍然是一个很大改进空间的领域。分析SST-5数据集,Munikar等人的先前工作表明,嵌入工具BERT允许使用简单的模型来实现最新的准确性。

aaaa_hsjsueu的博客 2万+

PostgreSQL与PGVector:将向量存储和搜索集成到数据库中的革命性技术

随着人工智能和机器学习的迅猛发展,向量化表示(Vectorization)在数据处理中变得越来越重要。特别是在自然语言处理(NLP)、计算机视觉等领域中,向量的使用已经成为了标准。为了在数据库层面上有效地管理这些向量,PGVector应运而生。PGVector是一个PostgreSQL扩展,用于在数据库中存储和搜索向量数据。本文将详细介绍PostgreSQL与PGVector的结合,及其在现代数据处理中的重要性,并探讨PGVector的底层原理及其实际应用。

hello.reader 3694

基于角谱传播的MATLAB仿真:从相位恢复看自由空间光传播

本文详细介绍了基于角谱传播理论的MATLAB仿真方法,用于模拟自由空间光传播过程。通过傅里叶光学原理,将光场分解为频谱并应用传播相位滤波器,实现了从纯相位物体到可观测衍射图样的仿真。文章结合具体代码,演示了如何利用角谱法进行相位恢复,为计算成像和生物医学检测等领域的研究提供了实用的仿真工具和思路。

weixin_29055699的博客 283

5分钟快速上手pgvector:为PostgreSQL注入AI向量搜索超能力

还在为AI应用中的向量数据存储和搜索发愁吗?pgvector正是你需要的解决方案!这个开源扩展让PostgreSQL数据库瞬间拥有处理向量数据的超能力,让你在熟悉的SQL环境中轻松实现向量相似性搜索。无论你是想构建智能推荐系统、实现语义搜索,还是进行图像内容检索,pgvector都能让你的PostgreSQL如虎添翼! ## 🎯 pgvector的核心价值:让AI向量搜索变得简单 想象一下,

gitblog_00330的博客 1032

手把手完整实现STM32+ESP8266+MQTT+ThingsCloud云平台+Android App及iOS App及微信小程序及Web App应用

本教程文章完整记录实现STM32+ESP8266+MQTT+ThingsCloud云平台+Android App及iOS App及微信小程序及Web App应用。

嵌入式阿齐Archie 1万+

Python学习第1天:初识Python

Python 作为目前最流行的编程语言之一,凭借其简洁优雅的语法和强大的生态系统,成为了无数开发者的首选。本系列文章将带你从零基础入门,逐步掌握 Python 编程的核心技能。今天我们先来认识 Python,并安装好开发环境。Python(英式发音:/ˈpaɪθən/;美式发音:/ˈpaɪθɑːn/)是由荷兰人吉多·范罗苏姆(Guido von Rossum)发明的一种编程语言,是目前世界上最受欢迎和拥有最多用户的编程语言。

tigerhhzz的博客 436

PostgreSQL pgvector 在 Windows 上的安装与使用教程:从源码编译到向量相似性搜索

pgvector 是 PostgreSQL 的向量扩展,用来在数据库里直接存储向量并做相似性搜索。本教程带你完成 Windows pgvector 安装全流程:从源码编译,到在数据库中创建扩展、插入向量、执行一次真实的相似度查询。跟着做完,你的 Windows 版 PostgreSQL 就能处理向量数据了。 ## 装完你会得到什么 按本文操作完成后,你的环境里会有: - 已编译进 Postg

gitblog_00415的博客 777

EXCEL VBA从入门到精通 第一章:VBA入门

在VBA中,需要使用关键字Dim来定义一个变量,后面跟上变量名和变量的数据类型。例如,下面的代码定义了一个整型变量x和一个字符串变量name在VBA中,使用关键字Const来定义常量,后面跟上常量名和常量的值。例如,下面的代码定义了一个整型常量MAX_NUM和一个字符串常量MESSAGE需要注意的是,常量一旦被定义,其值就不能被改变。

1万+

革命性向量搜索pgvector:PostgreSQL原生AI向量数据库完整指南

在人工智能蓬勃发展的今天,向量数据已成为AI应用的核心。从推荐系统到语义搜索,从图像识别到自然语言处理,向量嵌入(Embedding)无处不在。然而,传统的关系型数据库在处理高维向量数据时显得力不从心,而专门的向量数据库又增加了系统复杂性和维护成本。 pgvector的出现彻底改变了这一局面。作为PostgreSQL的开源扩展,它将强大的向量相似性搜索能力无缝集成到世界上最先进的开源关系数据库中...

gitblog_01196的博客 1489

基于51单片机的智能台灯设计:嵌入式程序设计实现

随着智能家居和物联网的快速发展,智能台灯作为一种典型的智能家居产品,已成为现代家庭中不可或缺的设备。传统的台灯只能提供简单的照明功能,而智能台灯不仅具备基础的照明功能,还能根据用户的需求进行自动调节,比如自动调节亮度、色温,甚至具备定时开关、远程控制等智能功能。本文将介绍如何基于51单片机设计一款智能台灯。我们将涉及硬件设计、嵌入式系统架构、传感器选择、调光控制、语音识别、远程控制等方面,详细阐述如何实现这些功能,并给出相关的代码和实现步骤。

2201_76125393的博客 837

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

如何快速掌握PostgreSQL向量搜索:终极实战指南

你是否想过将AI向量数据直接存储在熟悉的PostgreSQL数据库中?pgvector正是这样一个开源扩展,它让PostgreSQL具备了强大的向量相似性搜索能力。无论你是想构建智能推荐系统、语义搜索应用,还是进行图像相似性分析,pgvector都能为你提供完整的解决方案。 ## 🚀 从传统数据库到AI时代的数据革命 想象一下,你的数据库不仅能存储结构化数据,还能理解向量空间中的相似性关系。

gitblog_01424的博客 880

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

pgvector深度指南:PostgreSQL向量相似性搜索实战与架构解析

pgvector是PostgreSQL的开源向量相似性搜索扩展,为关系型数据库赋予了处理AI向量数据的能力。在现代AI应用架构中,pgvector安装和配置是实现向量搜索功能的关键技术环节。本文将深入探讨pgvector的核心架构、部署方案、性能优化策略以及实际应用场景,为中级开发者和架构师提供全面的技术指导。 ## 技术价值定位与场景分析 在AI驱动的现代应用中,向量相似性搜索已成为核心技术

gitblog_00533的博客 547

深度学习工具包 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")

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

如何为PostgreSQL添加向量搜索能力:pgvector扩展的完整实战指南

在AI应用爆炸式增长的今天,向量相似性搜索已成为现代数据库系统的核心需求。pgvector作为一个开源的PostgreSQL扩展,为传统关系型数据库赋予了强大的向量搜索能力,让你可以在PostgreSQL中直接存储和查询向量数据,实现高效的近似最近邻搜索。 ## 为什么你需要pgvector?🎯 想象一下这样的场景:你的电商平台需要根据用户浏览历史推荐相似商品,你的内容平台需要根据文章语义匹

gitblog_01427的博客 700

如何在PostgreSQL中快速部署pgvector向量搜索扩展:完整实战指南

PostgreSQL作为最流行的开源关系数据库之一,现在通过pgvector扩展具备了强大的向量搜索能力。pgvector是一个开源的向量相似性搜索扩展,它将AI向量处理功能直接集成到PostgreSQL中,让你能够在熟悉的SQL环境中执行高效的向量相似性查询。无论你是想要构建智能推荐系统、实现语义搜索功能,还是进行图像相似性分析,pgvector都能为你提供完整的解决方案。 ## 🚀 pgv

gitblog_00448的博客 847

EF Core 9重大更新:如何利用向量检索实现毫秒级相似性搜索?

掌握EF Core 9重大更新,轻松实现毫秒级相似性搜索。依托Entity Framework Core 9 的向量检索支持,开发者可在数据库中高效执行语义搜索、图像匹配等场景。通过集成向量索引与LINQ查询优化,显著提升搜索性能。构建AI驱动应用的利器,值得收藏。

Instrustar的博客 979

5分钟掌握pgvector:让PostgreSQL拥有AI向量搜索的超能力 [特殊字符]

pgvector是一个为PostgreSQL数据库增加向量相似性搜索能力的开源扩展。想象一下,你的数据库不仅能存储文本和数字,还能理解图片、音频、视频的"含义"并进行智能检索!这个项目让PostgreSQL摇身一变,成为支持AI应用的强大向量数据库。 ## 为什么你需要关注向量搜索? 在AI时代,数据不再仅仅是数字和文字。从ChatGPT的对话到Midjourney的图片,从语音识别到推荐系统

gitblog_00915的博客 628
上一篇: PostgreSQL笔记45: 向量化核心概念、Embedding模型与相似检索应用
下一篇: PostgreSQL笔记47: pgvector向量索引原理与选型指南
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、付费专栏及课程。

余额充值