Intégrations vectorielles¶

Snowflake Python Connector¶

Ces exemples montrent comment utiliser le type de données VECTOR et les fonctions de similarité vectorielle avec le connecteur Python.

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...)]

Snowpark Python¶

Ces exemples montrent comment utiliser le type de données VECTOR et les fonctions de similarité vectorielle avec la bibliothèque Snowpark Python.

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     |
----------------------

Recherche de similitudes vectorielles¶

Pour mettre en œuvre une recherche de documents sémantiquement similaires, il faut d’abord stocker les intégrations des documents à rechercher. Maintenez les intégrations à jour lorsque des documents sont ajoutés ou modifiés.

Dans cet exemple, les documents sont des problèmes soumis au centre d’appel enregistrés par les représentants du service d’assistance. La question est stockée dans une colonne appelée issue_text dans la table issues. Le SQL suivant crée une nouvelle colonne de vecteurs pour contenir les intégrations des questions.

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);

Pour effectuer une recherche, il faut créer une intégration du terme recherché ou du document cible, puis utiliser une fonction de similarité vectorielle pour localiser les documents dont les intégrations sont similaires. Utilisez les clauses ORDER BY et LIMIT pour sélectionner les k premiers documents correspondants et utilisez éventuellement une condition WHERE pour spécifier une similarité minimale.

En règle générale, l’appel à la fonction de similarité vectorielle doit figurer dans la clause SELECT et non dans la clause WHERE. De cette façon, la fonction n’est appelée que pour les lignes spécifiées par la clause WHERE, qui peut restreindre la requête sur la base d’autres critères, au lieu d’opérer sur toutes les lignes de la table. Pour tester une valeur de similarité dans la clause WHERE, définissez un alias de colonne pour l’appel VECTOR_COSINE_SIMILARITY dans la clause SELECT et utilisez cet alias dans une condition de la clause WHERE.

Cet exemple permet de trouver jusqu’à cinq questions correspondant au terme de recherche au cours des 90 derniers jours, en supposant que la similarité en cosinus avec le terme de recherche est d’au moins 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;

Génération augmentée de récupération (RAG)¶

Dans la génération augmentée de récupération (RAG), la requête d’un utilisateur est utilisée pour trouver des documents similaires à l’aide du vecteur de similarité. Le document de tête est ensuite transmis à un grand modèle de langage (LLM) avec la requête de l’utilisateur, fournissant le contexte pour la réponse générative (achèvement). Cela peut améliorer considérablement la pertinence de la réponse.

Dans l’exemple suivant, wiki est une table avec une colonne de texte content, et query est une table à une seule ligne avec une colonne de texte 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;