NextGen collections de recherche vectorielle Prise en main Recherche filtrée Limitations Utilisation de collections vectorielles classiques Étapes suivantes

Utilisation de collections de recherche vectorielle

Avec le type de collection de recherche vectorielle dans OpenSearch Serverless, vous pouvez effectuer des recherches de similarité évolutives et performantes. Vous pouvez créer des expériences de recherche augmentée modernes basées sur le machine learning (ML) et des applications d'intelligence artificielle générative (IA) sans gérer l'infrastructure de base de données vectorielle sous-jacente.

Les exemples d'utilisation des collections de recherche vectorielle incluent les recherches d'images, les recherches de documents, la récupération de musique, les recommandations de produits, les recherches de vidéos, les recherches géolocalisées, la détection des fraudes et la détection des anomalies.

Le moteur vectoriel pour OpenSearch Serverless utilise la fonction de recherche du voisin le plus proche (k-NN) dans. OpenSearch Vous bénéficiez des mêmes fonctionnalités avec la simplicité d'un environnement sans serveur. Le moteur prend en charge l'API du plug-in K-nn. Grâce à ces opérations, vous pouvez utiliser la recherche en texte intégral, le filtrage avancé, les agrégations, les requêtes géospatiales et les requêtes imbriquées pour accélérer l'extraction des données et améliorer les résultats de recherche.

Le moteur vectoriel fournit des mesures de distance telles que la distance euclidienne, la similitude des cosinus et la similitude des produits par points, et peut prendre en charge 16 000 dimensions. Vous pouvez stocker des champs contenant différents types de données pour les métadonnées, tels que des nombres, des booléens, des dates, des mots clés et des points géographiques. Vous pouvez également stocker des champs avec du texte pour obtenir des informations descriptives afin d'ajouter du contexte aux vecteurs stockés. La colocation des types de données réduit la complexité, augmente la maintenabilité et évite la duplication des données, les problèmes de compatibilité des versions et les problèmes de licence.

NextGen collections de recherche vectorielle

NextGen la recherche vectorielle évolue en fonction de la demande en fonction de la charge de travail afin d'optimiser l'équilibre entre les coûts et les performances. Seuls les blocs de données nécessaires pour répondre aux demandes de recherche actives sont chargés en mémoire, et les opérateurs évoluent dynamiquement en fonction de la mémoire requise et des ressources du processeur. Lorsque la collection est inactive et qu'il n'y a aucune demande en cours, l'indexation et la recherche sont redimensionnées à zéro, ce qui permet de réaliser des économies supplémentaires. Par défaut, NextGen inclut des optimisations intégrées qui améliorent le rappel tout en réduisant les coûts et la latence.

ID de document personnalisé : les identifiants de document personnalisés sont pris en charge dans les NextGen collections, ce qui permet aux clients d'effectuer des mises à jour ou d'indexer des documents avec des identifiants fournis par l'utilisateur.
Indices de compression 32x — Tous les index sont créés avec une technique de compression 32x avancée par défaut. Vous pouvez remplacer le niveau de compression par défaut et sélectionner n'importe quel niveau de compression pris en charge : 1x, 2x, 8x, 16x ou 32x (par défaut).
Accélération de la création d'index : l'accélération du GPU est activée par défaut pour permettre de créer des index vectoriels à grande échelle plus rapidement et plus efficacement. Il réduit le temps nécessaire pour indexer les données dans des index vectoriels, offrant ainsi une expérience d'indexation à haut débit et des économies de coûts. Les ressources GPU ne sont provisionnées que lorsque cela est nécessaire lors des opérations de création d'index. Vous pouvez contrôler l'utilisation du GPU par index à l'aide de ce paramètreindex.knn.remote_index_build.enabled. Pour de plus amples informations, veuillez consulter Accélération par GPU pour l'indexation vectorielle.
API simplifiée : les collections de recherche NextGen vectorielle ne nécessitent pas les mode paramètres engine et dans les mappages d'index. Le système détermine automatiquement la configuration optimale en interne, réduisant ainsi la complexité de la création d'index.
Réponse de recherche optimisée : par défaut, les réponses de recherche dans les collections de NextGen vecteurs excluent le vecteur d'origine des résultats. Cela réduit la latence de recherche de bout en bout et la taille de la charge utile des réponses. Pour inclure des vecteurs dans la réponse de recherche, voirRécupérez le document complet avec des vecteurs.
NextGen les collections de vecteurs ont une latence de lecture après écriture (refresh_interval) de 10 secondes.

Commencer à utiliser les collections de recherche vectorielle

Dans ce didacticiel, vous allez effectuer les étapes suivantes pour stocker, rechercher et récupérer des intégrations vectorielles en temps réel :

Configurer des autorisations
Créer une collection
Charger et rechercher des données
Supprimer la collection

Étape 1 : configurer des autorisations

Pour suivre ce didacticiel (et pour utiliser OpenSearch Serverless en général), vous devez disposer des autorisations Gestion des identités et des accès AWS (IAM) appropriées. Dans ce didacticiel, vous allez créer une collection, télécharger et rechercher des données, puis supprimer la collection.

Votre utilisateur ou votre rôle doit être associé à une politique basée sur l'identité avec les autorisations minimales suivantes :

Pour plus d'informations sur les autorisations IAM OpenSearch sans serveur, consultez. Identity and Access Management pour Amazon OpenSearch Serverless

Étape 2 : créer une collection

Pour créer une nouvelle collection, suivez le flux de création de collection unifié (NextGen Express Create), qui configure automatiquement les politiques de chiffrement, de réseau et d'accès aux données. Pour obtenir des instructions, veuillez consulter Création d'une NextGen collection (Express Create).

Pour le reste de ce didacticiel, la collection d'exemples est nommée housing et est une collection de recherche NextGen vectorielle.

Note

Si vous choisissez plutôt de créer une collection vectorielle classique, consultez Utilisation de collections vectorielles classiques les procédures spécifiques aux collections classiques.

Étape 3 : charger et rechercher des données

Un index est un ensemble de documents dotés d'un schéma de données commun qui vous permet de stocker, de rechercher et de récupérer vos intégrations vectorielles et d'autres champs. Vous pouvez créer et télécharger des données vers les index d'une collection OpenSearch sans serveur à l'aide de la console Dev Tools dans les OpenSearch tableaux de bord ou d'un outil HTTP tel que Postman ou awscurl. Ce didacticiel utilise les outils de développement. Pour un accès par programmation à l'aide du SDK Python, consultez. Ingestion de données dans des collections Amazon OpenSearch Serverless

Pour indexer et rechercher des données dans la collection de logements

Pour créer un index pour votre nouvelle collection, envoyez la demande suivante dans la console Dev Tools. Par défaut, cela crée un index avec une distance euclidienne et une compression 32x.


PUT housing-index
{
  "settings": {
    "index.knn": true
  },
  "mappings": {
    "properties": {
      "housing-vector": {
        "type": "knn_vector",
        "dimension": 3,
        "space_type": "l2"
      },
      "title": {
        "type": "text"
      },
      "price": {
        "type": "long"
      },
      "location": {
        "type": "geo_point"
      }
    }
  }
}

Pour utiliser un niveau de compression différent, définissez-le compression_level dans le mappage des champs. L'exemple suivant crée un index compression_level défini sur 1x.


PUT housing-index-1x
{
  "settings": {
    "index.knn": true
  },
  "mappings": {
    "properties": {
      "housing-vector": {
        "type": "knn_vector",
        "dimension": 3,
        "compression_level": "1x",
        "space_type": "l2"
      },
      "title": {
        "type": "text"
      },
      "price": {
        "type": "long"
      },
      "location": {
        "type": "geo_point"
      }
    }
  }
}

Les niveaux de compression pris en charge sont 1x, 2x, 8x, 16x et 32x.

Pour indexer des documentshousing-index, vous pouvez utiliser un identifiant généré par le système (POST) ou un identifiant fourni par l'utilisateur (PUT).


# System-generated document ID
POST housing-index/_doc
{
  "housing-vector": [10, 20, 30],
  "title": "2 bedroom in downtown Seattle",
  "price": "2800",
  "location": "47.71, 122.00"
}

# User-provided document ID
PUT housing-index/_doc/100
{
  "housing-vector": [10, 20, 30],
  "title": "2 bedroom in downtown Seattle",
  "price": "2800",
  "location": "47.71, 122.00"
}

Pour rechercher des propriétés similaires à celles de votre index, envoyez la requête suivante. Par défaut, la réponse de recherche exclut le vecteur d'origine _source afin de réduire la latence et la taille de la charge utile.


GET housing-index/_search
{
  "size": 5,
  "query": {
    "knn": {
      "housing-vector": {
        "vector": [10, 20, 30],
        "k": 2
      }
    }
  }
}

La réponse exclut le housing-vector champ de _source :


{
  "took": 10,
  "timed_out": false,
  "_shards": {
    "total": 0,
    "successful": 0,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 1,
    "hits": [
      {
        "_index": "housing-index",
        "_id": "100",
        "_score": 1,
        "_source": {
          "price": "2800",
          "location": "47.71, 122.00",
          "title": "2 bedroom in downtown Seattle"
        }
      }
    ]
  }
}

Récupérez le document complet avec des vecteurs

Pour remplacer le comportement par défaut, définissez-le sur _source true dans la demande de recherche. Vous pouvez également utiliser les excludes optionsincludes/de _source pour récupérer des champs spécifiques.


GET housing-index/_search
{
  "size": 5,
  "_source": true,
  "query": {
    "knn": {
      "housing-vector": {
        "vector": [10, 20, 30],
        "k": 2
      }
    }
  }
}

La réponse inclut désormais le housing-vector champ dans _source :


{
  "took": 10,
  "timed_out": false,
  "_shards": {
    "total": 0,
    "successful": 0,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 1,
    "hits": [
      {
        "_index": "housing-index",
        "_id": "100",
        "_score": 1,
        "_source": {
          "housing-vector": [10, 20, 30],
          "price": "2800",
          "location": "47.71, 122.00",
          "title": "2 bedroom in downtown Seattle"
        }
      }
    ]
  }
}

Étape 4 : supprimer la collection

La collection de logements étant destinée à des fins de test, supprimez-la lorsque vous aurez terminé d'expérimenter.

Pour supprimer une collection OpenSearch sans serveur

Ouvrez la console Amazon OpenSearch Service.
Dans le volet de navigation de gauche, choisissez Collections, puis sélectionnez la collection de logements.
Choisissez Supprimer et confirmez la suppression.

Recherche filtrée

Vous pouvez utiliser des filtres pour affiner les résultats de votre recherche sémantique. Pour créer un index et effectuer une recherche filtrée sur vos documents, remplacez les données de téléchargement et de recherche du didacticiel précédent par les instructions suivantes. Les autres étapes restent les mêmes. Pour plus d'informations sur les filtres, voir K-nn search with filters.

Pour indexer et rechercher des données dans la collection de logements

Pour créer un index unique pour votre collection, envoyez la demande suivante dans la console Dev Tools :


PUT housing-index-filtered
{
  "settings": {
    "index.knn": true
  },
  "mappings": {
    "properties": {
      "housing-vector": {
        "type": "knn_vector",
        "dimension": 3,
        "space_type": "l2",
        "method": {
          "name": "hnsw"
        }
      },
      "title": {
        "type": "text"
      },
      "price": {
        "type": "long"
      },
      "location": {
        "type": "geo_point"
      }
    }
  }
}

Pour indexer un seul document selon un filtre basé sur l'indice des logements, envoyez la demande suivante :


POST housing-index-filtered/_doc
{
  "housing-vector": [
    10,
    20,
    30
  ],
  "title": "2 bedroom in downtown Seattle",
  "price": "2800",
  "location": "47.71, 122.00"
}

Pour rechercher vos données pour un appartement à Seattle à un prix donné et à une distance donnée d'un point géographique, envoyez la demande suivante :


GET housing-index-filtered/_search
{
  "size": 5,
  "query": {
    "knn": {
      "housing-vector": {
        "vector": [
          0.1,
          0.2,
          0.3
        ],
        "k": 5,
        "filter": {
          "bool": {
            "must": [
              {
                "query_string": {
                  "query": "Find me 2 bedroom apartment in Seattle under $3000 ",
                  "fields": [
                    "title"
                  ]
                }
              },
              {
                "range": {
                  "price": {
                    "lte": 3000
                  }
                }
              },
              {
                "geo_distance": {
                  "distance": "100miles",
                  "location": {
                    "lat": 48,
                    "lon": 121
                  }
                }
              }
            ]
          }
        }
      }
    }
  }
}

Limitations

La recherche radiale n'est pas prise en charge sur les index NextGen vectoriels qui utilisent une compression 32x.

Utilisation de collections vectorielles classiques

Les collections vectorielles classiques constituent la génération originale de la recherche vectorielle OpenSearch sans serveur. Utilisez les procédures décrites dans cette section si vous possédez déjà une collection de vecteurs Classic. Pour les nouvelles collections, nous vous recommandons de NextGen — voir Créer des collections pour créer une collection NextGen vectorielle.

Note

Les collections Amazon OpenSearch Serverless Classic prennent en charge la quantification scalaire 16 bits Faiss, qui effectue des conversions entre des vecteurs flottants 32 bits et des vecteurs 16 bits. Pour en savoir plus, consultez la section Quantification scalaire 16 bits Faiss. Vous pouvez également utiliser des vecteurs binaires pour réduire les coûts de mémoire. Pour plus d'informations, consultez la section Vecteurs binaires.
Les collections Amazon OpenSearch Serverless Classic prennent en charge la recherche vectorielle sur disque, ce qui réduit considérablement les coûts opérationnels liés aux charges de travail vectorielles dans les environnements à faible mémoire. Pour plus d'informations, consultez la section Recherche Disk-based vectorielle.

Les exemples suivants s'appliquent aux collections de vecteurs classiques, qui utilisent le nmslib moteur par défaut et incluent le vecteur d'origine dans les réponses de recherche.

Pour indexer et rechercher des données dans une collection de logements classique

Pour créer un index pour votre collection Classic, envoyez la demande suivante dans la console Dev Tools. Par défaut, cela crée un index avec le nmslib moteur et la distance euclidienne.


PUT housing-index
{
   "settings": {
      "index.knn": true
   },
   "mappings": {
      "properties": {
         "housing-vector": {
            "type": "knn_vector",
            "dimension": 3
         },
         "title": {
            "type": "text"
         },
         "price": {
            "type": "long"
         },
         "location": {
            "type": "geo_point"
         }
      }
   }
}

Pour indexer un seul document dans housing-index, envoyez la demande suivante :


POST housing-index/_doc
{
  "housing-vector": [
    10,
    20,
    30
  ],
  "title": "2 bedroom in downtown Seattle",
  "price": "2800",
  "location": "47.71, 122.00"
}

Pour rechercher des propriétés similaires à celles de votre index, envoyez la requête suivante :


GET housing-index/_search
{
    "size": 5,
    "query": {
        "knn": {
            "housing-vector": {
                "vector": [
                    10,
                    20,
                    30
                ],
                "k": 5
            }
        }
    }
}

Pour créer un index et effectuer une recherche filtrée, utilisez les exemples suivants. Pour plus d'informations sur les filtres, voir K-nn search with filters.

Pour indexer et effectuer une recherche filtrée sur une collection de logements classique

Pour créer un index unique pour votre collection, envoyez la demande suivante dans la console Dev Tools :


PUT housing-index-filtered
{
  "settings": {
    "index.knn": true
  },
  "mappings": {
    "properties": {
      "housing-vector": {
        "type": "knn_vector",
        "dimension": 3,
        "method": {
          "engine": "faiss",
          "name": "hnsw"
        }
      },
      "title": {
        "type": "text"
      },
      "price": {
        "type": "long"
      },
      "location": {
        "type": "geo_point"
      }
    }
  }
}

Pour indexer un seul document selon un filtre basé sur l'indice des logements, envoyez la demande suivante :


POST housing-index-filtered/_doc
{
  "housing-vector": [
    10,
    20,
    30
  ],
  "title": "2 bedroom in downtown Seattle",
  "price": "2800",
  "location": "47.71, 122.00"
}

Pour rechercher vos données pour un appartement à Seattle à un prix donné et à une distance donnée d'un point géographique, envoyez la demande suivante :


GET housing-index-filtered/_search
{
  "size": 5,
  "query": {
    "knn": {
      "housing-vector": {
        "vector": [
          0.1,
          0.2,
          0.3
        ],
        "k": 5,
        "filter": {
          "bool": {
            "must": [
              {
                "query_string": {
                  "query": "Find me 2 bedroom apartment in Seattle under $3000 ",
                  "fields": [
                    "title"
                  ]
                }
              },
              {
                "range": {
                  "price": {
                    "lte": 3000
                  }
                }
              },
              {
                "geo_distance": {
                  "distance": "100miles",
                  "location": {
                    "lat": 48,
                    "lon": 121
                  }
                }
              }
            ]
          }
        }
      }
    }
  }
}

Les collections vectorielles classiques présentent les limites suivantes :

Les collections de recherche vectorielle ne sont pas compatibles avec le moteur Apache Lucene ANN.
Les collections de recherche vectorielle ne prennent en charge que l'algorithme HNSW avec Faiss. Ils ne soutiennent pas la FIV ou la FIV.
Les collections de recherche vectorielle ne prennent pas en charge les opérations de l'API d'échauffement, de statistiques et d'entraînement des modèles.
Les collections de recherche vectorielle ne prennent pas en charge les scripts en ligne ou stockés.
Les informations sur le nombre d'index ne sont pas disponibles dans AWS Management Console les collections de recherche vectorielle.
L'intervalle d'actualisation des index des collections de recherche vectorielle est de 60 secondes.

Billion-scale charges de travail

Les collections de recherche vectorielle classiques prennent en charge des charges de travail contenant des milliards de vecteurs. Il n'est pas nécessaire de réindexer à des fins de mise à l'échelle, car la mise à l'échelle automatique s'en charge pour vous. Si vous avez des millions de vecteurs (ou plus) dotés d'un grand nombre de dimensions et que vous avez besoin de plus de 200 OCU, contactez le AWS Support pour augmenter le nombre maximum d'unités de OpenSearch calcul (OCU) pour votre compte.

Étapes suivantes

Maintenant que vous savez comment créer une collection de recherche vectorielle et indexer des données, vous pouvez essayer les exercices suivants :

Utilisez le client OpenSearch Python pour travailler avec des collections de recherche vectorielle. Consultez ce didacticiel sur GitHub.
Utilisez le client OpenSearch Java pour travailler avec des collections de recherche vectorielle. Consultez ce didacticiel sur GitHub.
Configuré LangChain pour être utilisé OpenSearch comme magasin de vecteurs. LangChain est un framework open source permettant de développer des applications basées sur des modèles de langage. Pour plus d’informations, consultez la documentation LangChain .

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Points de terminaison de collecte

Utilisation des politiques de cycle de vie des données