Incorporações de vetor¶

Exemplos¶

Os exemplos a seguir usam funções de similaridade vetorial.

Esse exemplo de SQL usa a função VECTOR_INNER_PRODUCT para determinar quais vetores na tabela estão mais próximos entre si entre as colunas a e b:

CREATE TABLE vectors (a VECTOR(float, 3), b VECTOR(float, 3));
INSERT INTO vectors SELECT [1.1,2.2,3]::VECTOR(FLOAT,3), [1,1,1]::VECTOR(FLOAT,3);
INSERT INTO vectors SELECT [1,2.2,3]::VECTOR(FLOAT,3), [4,6,8]::VECTOR(FLOAT,3);

-- Compute the pairwise inner product between columns a and b
SELECT VECTOR_INNER_PRODUCT(a, b) FROM vectors;

+------+
| 6.3  |
|------|
| 41.2 |
+------+

Esse exemplo de SQL chama a função VECTOR_COSINE_SIMILARITY para encontrar o vetor mais próximo de [1,2,3]:

SELECT a, VECTOR_COSINE_SIMILARITY(a, [1,2,3]::VECTOR(FLOAT, 3)) AS similarity
    FROM vectors
ORDER BY similarity DESC
LIMIT 1;

+-------------------------+
| [1, 2.2, 3] | 0.9990... |
+-------------------------+

import snowflake.connector

conn = ... # Set up connection
cur = conn.cursor()

# Create a table and insert some vectors
cur.execute("CREATE OR REPLACE TABLE vectors (a VECTOR(FLOAT, 3), b VECTOR(FLOAT, 3))")
values = [([1.1, 2.2, 3], [1, 1, 1]), ([1, 2.2, 3], [4, 6, 8])]
for row in values:
        cur.execute(f"""
            INSERT INTO vectors(a, b)
                SELECT {row[0]}::VECTOR(FLOAT,3), {row[1]}::VECTOR(FLOAT,3)
        """)

# Compute the pairwise inner product between columns a and b
cur.execute("SELECT VECTOR_INNER_PRODUCT(a, b) FROM vectors")
print(cur.fetchall())

[(6.30...,), (41.2...,)]

# Find the closest vector to [1,2,3]
cur.execute(f"""
    SELECT a, VECTOR_COSINE_SIMILARITY(a, {[1,2,3]}::VECTOR(FLOAT, 3))
        AS similarity
        FROM vectors
        ORDER BY similarity DESC
        LIMIT 1;
""")
print(cur.fetchall())

[([1.0, 2.2..., 3.0], 0.9990...)]

from snowflake.snowpark import Session, Row
session = ... # Set up session
from snowflake.snowpark.types import VectorType, StructType, StructField
from snowflake.snowpark.functions import col, lit, vector_l2_distance
schema = StructType([StructField("vec", VectorType(int, 3))])
data = [Row([1, 2, 3]), Row([4, 5, 6]), Row([7, 8, 9])]
df = session.create_dataframe(data, schema)
df.select(
    "vec",
    vector_l2_distance(df.vec, lit([1, 2, 2]).cast(VectorType(int, 3))).as_("dist"),
).sort("dist").limit(1).show()

----------------------
|"VEC"      |"DIST"  |
----------------------
|[1, 2, 3]  |1.0     |
----------------------

Pesquisa de similaridade vetorial¶

Para implementar uma busca por documentos semanticamente similares, primeiro armazene as incorporações dos documentos a serem pesquisados. Mantenha as incorporações atualizadas quando os documentos forem adicionados ou editados.

Neste exemplo, os documentos são problemas do call center registrados por representantes de suporte. O problema é armazenado em uma coluna chamada issue_text na tabela issues. A seguir, o SQL cria uma nova coluna de vetor para armazenar as incorporações dos problemas.

ALTER TABLE issues ADD COLUMN issue_vec VECTOR(FLOAT, 768);

UPDATE issues
  SET issue_vec = SNOWFLAKE.CORTEX.EMBED_TEXT_768('snowflake-arctic-embed-m', issue_text);

Para realizar uma pesquisa, crie uma incorporação do termo de pesquisa ou do documento de destino e, em seguida, use uma função de similaridade vetorial para localizar documentos com incorporações semelhantes. Use as cláusulas ORDER BY e LIMIT para selecionar os k documentos com maior correspondência e, opcionalmente, use uma condição WHERE para especificar uma similaridade mínima.

Geralmente, a chamada para a função de similaridade vetorial deve aparecer na cláusula SELECT, não na cláusula WHERE. Dessa forma, a função é chamada apenas para as linhas especificadas pela cláusula WHERE, que pode restringir a consulta com base em algum outro critério, em vez de operar em todas as linhas da tabela. Para testar um valor de similaridade na cláusula WHERE, defina um alias de coluna para a chamada VECTOR_COSINE_SIMILARITY na cláusula SELECT e use esse alias em uma condição na cláusula WHERE.

Este exemplo encontra até cinco problemas correspondentes ao termo de pesquisa dos últimos 90 dias, supondo que a similaridade do cosseno com o termo de pesquisa seja de pelo menos 0,7.

SELECT
  issue,
  VECTOR_COSINE_SIMILARITY(
    issue_vec,
    SNOWFLAKE.CORTEX.EMBED_TEXT_768('snowflake-arctic-embed-m', 'User could not install Facebook app on his phone')
  ) AS similarity
FROM issues
ORDER BY similarity DESC
LIMIT 5
WHERE DATEDIFF(day, CURRENT_DATE(), issue_date) < 90 AND similarity > 0.7;

Geração aumentada de recuperação (RAG)¶

Na geração aumentada de recuperação (RAG), a consulta de um usuário é usada para encontrar documentos semelhantes usando a similaridade vetorial. O documento superior é então passado para um modelo de linguagem grande (LLM) junto com a consulta do usuário, fornecendo contexto para a resposta generativa (conclusão). Isso pode melhorar significativamente a adequação da resposta.

No exemplo a seguir, wiki é uma tabela com uma coluna de texto content, e query é uma tabela de linha única com uma coluna de texto text.

-- Create embedding vectors for wiki articles (only do once)
ALTER TABLE wiki ADD COLUMN vec VECTOR(FLOAT, 768);
UPDATE wiki SET vec = SNOWFLAKE.CORTEX.EMBED_TEXT_768('snowflake-arctic-embed-m', content);

-- Embed incoming query
SET query = 'in which year was Snowflake Computing founded?';
CREATE OR REPLACE TABLE query_table (query_vec VECTOR(FLOAT, 768));
INSERT INTO query_table SELECT SNOWFLAKE.CORTEX.EMBED_TEXT_768('snowflake-arctic-embed-m', $query);

-- Do a semantic search to find the relevant wiki for the query
WITH result AS (
    SELECT
        w.content,
        $query AS query_text,
        VECTOR_COSINE_SIMILARITY(w.vec, q.query_vec) AS similarity
    FROM wiki w, query_table q
    ORDER BY similarity DESC
    LIMIT 1
)

-- Pass to large language model as context
SELECT SNOWFLAKE.CORTEX.COMPLETE('mistral-7b',
    CONCAT('Answer this question: ', query_text, ' using this text: ', content)) FROM result;