Partager via

Réduire la taille de vecteurs via la quantification, les types de données étroits et les options de stockage

  • Article

Cet article explique l’utilisation de la quantification de vecteurs et d’autres techniques pour réduire la taille de vecteurs dans Azure AI Search. L’index de recherche spécifie des définitions de champ vectoriel, y compris des propriétés utilisées pour spécifier des types de données restreints ou contrôler si une copie du contenu vectoriel est conservée pour les résultats de la recherche. La quantification est également spécifiée dans l’index et attribuée aux champs vectoriels via son profil vectoriel.

La plupart des fonctionnalités décrites dans cet article sont en disponibilité générale dans l’API REST 2024-07-01 et dans les packages du Kit de développement logiciel (SDK) Azure ciblant cette version. La préversion la plus récente ajoute la prise en charge des dimensions tronquées si vous utilisez text-embedding-3-large ou text-embedding-3-small pour la vectorisation.

Un exemple à la fin de cet article montre les variations en taille de vecteur pour chacune des approches décrites dans cet article.

Évaluer les options

Pour commencer, passez en revue les trois approches permettant de réduire la quantité de stockage utilisée par les champs vectoriels. Ces approches ne s’excluent pas mutuellement et peuvent être associées pour obtenir une réduction maximale de la taille de vecteur.

Nous recommandons la quantification intégrée, car elle compresse la taille des vecteurs en mémoire et sur le disque avec un minimum d’effort, ce qui tend à offrir le plus d’avantages dans la plupart des scénarios. En revanche, les types étroits (à l’exception de float 16) nécessitent un effort spécial pour les créer et stored enregistre sur un stockage sur disque, ce qui n’est pas aussi coûteux que la mémoire.

Approche Pourquoi utiliser cette option
Ajouter une quantification binaire ou scalaire Utilisez une quantification pour compresser des incorporations float32 ou float16 natives en int8 (scalaire) ou Byte (binaire). Cette option réduit le stockage en mémoire et sur disque sans dégradation des performances des requêtes. Les types de données plus petits, comme int8 ou Byte, produisent des index vectoriels moins riches en contenu que ceux avec des incorporations plus grandes. Pour compenser la perte d'informations, la compression intégrée inclut des options de traitement post-requête utilisant des intégrations non compressées et un suréchantillonnage pour renvoyer des résultats plus pertinents. Le reclassement et le suréchantillonnage sont des fonctionnalités spécifiques de la quantification intégrée des champs float32 ou float16 et ne peuvent pas être utilisés sur les incorporations soumises à une quantification personnalisée.
Tronquer des dimensions pour les modèles text-embedding-3 compatibles MRL (préversion) Choisissez l’option permettant d’utiliser moins de dimensions sur les modèles text-embedding-3. Sur Azure OpenAI, ces modèles ont été réentraînés avec la technique Matryoshka Representation Learning (MRL), qui produit plusieurs représentations vectorielles à différents niveaux de compression. Cette approche produit des recherches plus rapides et réduit les coûts de stockage, avec une perte minimale d’informations sémantiques. Dans Recherche Azure AI, la prise en charge de MRL vient en complément de la quantification scalaire et binaire. Quand vous utilisez ces méthodes de quantification, vous pouvez aussi spécifier une propriété truncateDimension sur vos champs vectoriels pour réduire la dimensionnalité des incorporations de texte.
Attribuer des types de données primitifs plus petits aux champs vectoriels Les types de données étroits, tels que float16, int16, int8 et Byte (binaire) consomment moins d’espace dans la mémoire et sur le disque, mais vous devez disposer d’un modèle d’incorporation qui génère des vecteurs dans un format de données étroit. Ou bien, vous devez disposer d’une logique de quantification personnalisée qui génère de petites données. Un troisième cas d’utilisation nécessitant moins d’efforts consiste à recaster des incorporations float32 natives produites par la plupart des modèles en float16. Pour plus d’informations sur les vecteurs binaires, consultez Indexer les vecteurs binaires.
Éliminer le stockage facultatif des vecteurs récupérables Les vecteurs renvoyés dans une réponse à une requête sont stockés séparément des vecteurs utilisés lors de l'exécution de la requête. Si vous n’avez pas besoin de retourner des vecteurs, vous pouvez désactiver le stockage récupérable, ce qui réduit le stockage global par disque par champ de jusqu’à 50 %.

Toutes ces options sont définies sur un index vide. Pour implémenter l’un d’entre eux, utilisez le Portail Azure, les API REST ou un package du Kit de développement logiciel (SDK) Azure ciblant cette version d’API.

Une fois l'index défini, vous pouvez charger et indexer les documents dans le cadre d'une étape distincte.

Option 1 : configurer la quantification

Nous recommandons la quantification pour réduire la taille de vecteurs, car elle diminue les exigences de stockage sur disque pour les incorporations float16 et float32. Pour décaler les effets d’un index plus petit, vous pouvez ajouter un suréchantillonnage et un reclassement sur des vecteurs non compressés.

La quantification s’applique aux champs vectoriels recevant des vecteurs de type float. Dans les exemples de cet article, le type de données du champ est Collection(Edm.Single) pour les incorporations float32 entrantes, mais float16 est également pris en charge. Quand les vecteurs sont reçus sur un champ ayant la compression configurée, le moteur effectue automatiquement une quantification pour réduire l’empreinte mémoire des données vectorielles dans la mémoire et sur le disque.

Deux types de quantification sont pris en charge :

  • La quantification scalaire compresse les valeurs flottantes en types de données plus étroits. Recherche Azure AI prend actuellement en charge int8, qui est 8 bits, ce qui réduit la taille d’index vectoriel par quatre.

  • La quantification binaire convertit des floats en bits binaires qui prennent jusqu’à 1 bit. Ce qui se traduit par une taille d’index vectoriel réduite jusqu’à 28 fois.

Pour utiliser la quantification intégrée, suivez ces étapes :

  • Utiliser Créer un index ou Créer ou mettre à jour un index pour spécifier la compression vectorielle
  • Ajouter vectorSearch.compressions à un index de recherche
  • Ajouter une configuration scalarQuantization ou binaryQuantization et lui donner un nom
  • Définir des propriétés facultatives pour atténuer les effets de l’indexation avec perte
  • Créer un profil vectoriel qui utilise la configuration nommée
  • Créer un profil vectoriel ayant le nouveau profil vectoriel
  • Charger l’index avec des données float32 ou float16 quantifiées pendant l’indexation par la configuration définie
  • Vous pouvez également interroger des données quantifiées en utilisant le paramètre de suréchantillonnage si vous voulez remplacer la valeur par défaut

Ajouter « compressions » à un index de recherche

L’exemple suivant montre une définition d’index partiel avec une collection de champs qui inclut un champ vectoriel et une section vectorSearch.compressions.

Cet exemple inclut scalarQuantization ou binaryQuantization. Vous pouvez spécifier autant de configurations de compression que nécessaire, puis attribuez celles souhaitées au profil vectoriel.

POST https://[servicename].search.windows.net/indexes?api-version=2024-07-01

{
  "name": "my-index",
  "fields": [
    { "name": "Id", "type": "Edm.String", "key": true, "retrievable": true, "searchable": true, "filterable": true },
    { "name": "content", "type": "Edm.String", "retrievable": true, "searchable": true },
    { "name": "vectorContent", "type": "Collection(Edm.Single)", "retrievable": false, "searchable": true, "dimensions": 1536,"vectorSearchProfile": "vector-profile-1"},
  ],
  "vectorSearch": {
        "profiles": [ ],
        "algorithms": [ ],
        "compressions": [
          {
            "name": "use-scalar",
            "kind": "scalarQuantization",
            "scalarQuantizationParameters": {
              "quantizedDataType": "int8"
            },
            "rerankWithOriginalVectors": true,
            "defaultOversampling": 10
          },
          {
            "name": "use-binary",
            "kind": "binaryQuantization",
            "rerankWithOriginalVectors": true,
            "defaultOversampling": 10
          }
        ]
    }
}

Points essentiels :

  • kind doit être défini sur scalarQuantization ou binaryQuantization

  • rerankWithOriginalVectors utilise les vecteurs originaux non compressés pour recalculer la similarité et reclasser les meilleurs résultats renvoyés par la requête de recherche initiale. Les vecteurs non compressés existent dans l'index de recherche même si stored sont faux. Cette propriété est facultative. La valeur par défaut est true.

  • defaultOversampling considère un ensemble plus large de résultats potentiels pour compenser la réduction des informations résultant de la quantification. La formule des résultats potentiels consiste en le k dans la requête, avec un multiplicateur de suréchantillonnage. Par exemple, si la requête spécifie un k de 5 et que le suréchantillonnage est de 20, alors la requête demande effectivement 100 documents à utiliser dans le reclassement, en utilisant le vecteur non compressé d'origine à cette fin. Seuls les résultats k les mieux classés sont renvoyés. Cette propriété est facultative. La valeur par défaut est 4.

  • quantizedDataType est facultatif et s’applique à la quantification scalaire uniquement. Si vous l’ajoutez, il doit être défini sur int8. Il s’agit du seul type de données primitif pris en charge pour la quantification scalaire à l’heure actuelle. La valeur par défaut est int8.

Ajouter l’algorithme HNSW

Vérifiez que votre index a l’algorithme HNSW (Hierarchical Navigable Small Worlds). La quantification intégrée n'est pas prise en charge avec KNN exhaustif.

"vectorSearch": {
    "profiles": [ ],
    "algorithms": [
      {
          "name": "use-hnsw",
          "kind": "hnsw",
          "hnswParameters": {
              "m": 4,
              "efConstruction": 400,
              "efSearch": 500,
              "metric": "cosine"
          }
      }
    ],
     "compressions": [ <see previous section>] 
}

Créer et attribuer un profil vectoriel

Pour utiliser une nouvelle configuration de quantification, vous devez créer un profil vectoriel. La création d'un nouveau profil vectoriel est nécessaire pour créer des index compressés en mémoire. Votre nouveau profil utilise HNSW.

  1. Dans la même définition d’index, créez un profil vectoriel et ajoutez une propriété de compression et un algorithme. Voici deux profils, un pour chaque approche de quantification.

    "vectorSearch": {
    "profiles": [
       {
          "name": "vector-profile-hnsw-scalar",
          "compression": "use-scalar", 
          "algorithm": "use-hnsw",
          "vectorizer": null
       },
       {
          "name": "vector-profile-hnsw-binary",
          "compression": "use-binary", 
          "algorithm": "use-hnsw",
          "vectorizer": null
       }
     ],
     "algorithms": [  <see previous section> ],
     "compressions": [ <see previous section> ] 
}

  2. Attribuez un profil vectoriel à un nouveau champ vectoriel. Le type de données du champ est soit float32 ou soit float16.

    Dans Recherche Azure AI, les équivalents EDM (Entity Data Model) des types float32 et float16 sont Collection(Edm.Single) et Collection(Edm.Half), respectivement.

    {
   "name": "vectorContent",
   "type": "Collection(Edm.Single)",
   "searchable": true,
   "retrievable": true,
   "dimensions": 1536,
   "vectorSearchProfile": "vector-profile-hnsw-scalar",
}

  3. Chargez l'index à l'aide d'indexeurs pour l'indexation du modèle pull ou d'API pour l'indexation du modèle push.

La quantification scalaire réduit la résolution de chaque nombre dans chaque intégration vectorielle. Au lieu de décrire chaque nombre comme un nombre à virgule flottante de 16 bits ou 32 bits, il utilise un entier de 8 bits. Il identifie une plage de nombres (généralement le minimum et le maximum du 99e percentile) et les divise en un nombre fini de niveaux ou de catégories, en attribuant à chaque catégorie un identifiant. Dans la quantification scalaire 8 bits, il existe 2 ^ 8, soit 256, bacs possibles.

Chaque composante du vecteur est mappée à la valeur représentative la plus proche au sein de cet ensemble de niveaux de quantification dans un processus semblable à l'arrondi d'un nombre réel à l'entier le plus proche. Dans le vecteur quantifié de 8 bits, le numéro d'identification remplace la valeur d'origine. Après quantification, chaque vecteur est représenté par un tableau d'identifiants pour les bacs auxquels appartiennent ses composants. Ces vecteurs quantifiés nécessitent beaucoup moins de bits à stocker par rapport au vecteur d'origine, réduisant ainsi les besoins de stockage et l'empreinte mémoire.

Fonctionnement de la quantification scalaire dans Recherche Azure AI

La quantification binaire compresse des vecteurs hautement dimensionnels en représentant chaque composant en tant que bit unique, 0 ou 1. Cette méthode réduit considérablement l’empreinte mémoire et accélère les opérations de comparaison vectorielle qui sont essentielles pour les tâches de recherche et d’extraction. Les tests de point de référence montrent jusqu’à 96 % de réduction en taille d’index vectoriel.

C’est particulièrement efficace pour les incorporations ayant des dimensions supérieures à 1024. Pour les dimensions plus petites, nous vous recommandons de tester la qualité de la quantification binaire ou d’essayer le type scalaire à la place. De plus, nous avons constaté que la quantification binaire fonctionne très bien lorsque les incorporations sont centrées sur zéro. La plupart des modèles d’incorporation connus tels qu’OpenAI, Cohere et Mistral sont centrés sur zéro.

Utiliser la compression et les dimensions tronquées de MRL (préversion)

La compression multiniveau de MRL économise du stockage vectoriel et améliore les temps de réponse des requêtes pour les requêtes vectorielles basées sur des incorporations de texte. Dans Recherche Azure AI, la prise en charge de MRL est offerte seulement en combinaison avec une autre méthode de quantification. L’utilisation de la quantification binaire avec MRL permet une réduction maximale de la taille de l’index vectoriel. Pour obtenir une réduction maximale du stockage, utilisez la quantification binaire avec MRL et stored défini sur false.

Cette fonctionnalité est en version préliminaire. Elle est disponible dans 2024-09-01-preview et dans les packages du Kit de développement logiciel (SDK) bêta ciblant cette préversion de l’API.

Spécifications

  • Text-embedding-3-small, Text-embedding-3-large (contenu texte uniquement).
  • Nouveaux champs vectoriels de type Edm.Half ou Edm.Single (vous ne pouvez pas ajouter la compression MRL à un champ existant).
  • Algorithme HNSW (pas de prise en charge de l’algorithme KNN exhaustif dans cette préversion).
  • Configurer une quantification scalaire ou binaire Nous vous recommandons la quantification binaire.

Clients pris en charge

Le portail Azure et Azure AI Studio ne sont pas pris en charge pour l’instant.

Comment utiliser des incorporations de texte étendues par MRL

MRL est une fonctionnalité du modèle d’incorporation de texte. Pour bénéficier de ces fonctionnalités dans Recherche Azure AI, procédez comme suit.

  1. Spécifiez un objet vectorSearch.compressions dans votre définition d’index.
  2. Incluez une méthode de quantification, scalaire ou binaire (recommandée).
  3. Incluez le paramètre truncationDimension défini sur 512, ou 256 si vous utilisez le modèle text-embedding-3-large.
  4. Spécifiez un profil vectoriel qui spécifie l’algorithme HNSW et l’objet de compression vectorielle.
  5. Affectez le profil vectoriel à un champ vectoriel de type Edm.Half ou Edm.Single dans la collection de champs.

Aucune modification des requêtes n’est nécessaire pour utiliser un modèle d’incorporation de texte compatible MRL. La vectorisation intégrée, les conversions de texte à requête au moment de la requête, le classement sémantique et d’autres fonctionnalités d’amélioration de la pertinence, comme le reclassement avec des vecteurs d’origine et le suréchantillonnage, ne sont pas affectés par la prise en charge de MRL.

L’indexation est plus lente en raison des étapes supplémentaires, mais les requêtes seront plus rapides.

Exemple de configuration de recherche vectorielle qui prend en charge MRL

L’exemple suivant illustre une configuration de recherche vectorielle qui répond aux exigences et aux recommandations de MRL.

truncationDimension est une propriété de compression. Elle spécifie dans quelle mesure réduire le graphique vectoriel en mémoire, en combinaison avec une méthode de compression, comme une compression scalaire ou binaire. Nous vous recommandons d’utiliser 1 024 ou plus pour truncationDimension avec la quantification binaire. Une dimensionnalité inférieure à 1 000 dégrade la qualité des résultats de la recherche lors de l’utilisation de MRL et de la compression binaire.

{ 
  "vectorSearch": { 
    "profiles": [ 
      { 
        "name": "use-bq-with-mrl", 
        "compression": "use-mrl,use-bq", 
        "algorithm": "use-hnsw" 
      } 
    ],
    "algorithms": [
       {
          "name": "use-hnsw",
          "kind": "hnsw",
          "hnswParameters": {
             "m": 4,
             "efConstruction": 400,
             "efSearch": 500,
             "metric": "cosine"
          }
       }
    ],
    "compressions": [ 
      { 
        "name": "use-mrl", 
        "kind": "truncation", 
        "rerankWithOriginalVectors": true, 
        "defaultOversampling": 10, 
        "truncationDimension": 1024
      }, 
      { 
        "name": "use-bq", 
        "kind": "binaryQuantization", 
        "rerankWithOriginalVectors": true,
        "defaultOversampling": 10
       } 
    ] 
  } 
}

Voici un exemple de définition d’un champ vectoriel entièrement spécifié qui satisfait aux exigences de MRL.

Rappelez-vous que les champs vectoriels doivent être de type Edm.Half ou Edm.Single. Les champs vectoriels doivent avoir une propriété vectorSearchProfile qui détermine les paramètres d’algorithme et de compression. Les champs vectoriels ont une propriété dimensions utilisée afin de spécifier le nombre de dimensions pour le scoring et les résultats du classement. Sa valeur doit être la limite de dimensions du modèle que vous utilisez (1 536 pour text-embedding-3-small).

{
    "name": "text_vector",
    "type": "Collection(Edm.Single)",
    "searchable": true,
    "filterable": false,
    "retrievable": false,
    "stored": false,
    "sortable": false,
    "facetable": false,
    "key": false,
    "indexAnalyzer": null,
    "searchAnalyzer": null,
    "analyzer": null,
    "normalizer": null,
    "dimensions": 1536,
    "vectorSearchProfile": "use-bq-with-mrl",
    "vectorEncoding": null,
    "synonymMaps": []
}

Option 2 : Attribuer des types de données restreints aux champs vectoriels

Un moyen facile pour réduire la taille de vecteur consiste à stoker des incorporations dans un format de données plus petit. La plupart des modèles d’incorporation génèrent des nombres à virgules flottantes de 32 bits mais, si vous quantifiez vos vecteurs ou si votre modèle d’incorporation le prend en charge en natif, il est possible que la génération soit float16, int16 ou int8, ce qui est sensiblement plus petit que float32. Vous pouvez héberger ces tailles de vecteur plus petites en attribuant un type de données étroit à un champ vectoriel. Dans l’index vectoriel, les types de données étroits consomment moins de stockage.

  1. Passez en revue les types de données utilisés par des champs vectoriels pour l’utilisation recommandée :

    • Collection(Edm.Single) Virgule flottante 32 bits (par défaut)
    • Collection(Edm.Half) Virgule flottante 16 bits (étroit)
    • Collection(Edm.Int16) Entier signé 16 bits (étroit)
    • Collection(Edm.SByte) Entier signé 8 bits (étroit)
    • Collection(Edm.Byte) Entier non signé 8 bits (uniquement autorisé avec des types de données binaires compressés)

  2. Dans la liste, déterminez le type de données valide pour la sortie de votre modèle d’intégration ou pour les vecteurs soumis à une quantification personnalisée.

    Le tableau suivant fournit des liens vers plusieurs modèles d'incorporation qui utilisent un type de données étroit (Collection(Edm.Half)) sans quantification supplémentaire. Vous pouvez caster de float32 vers float16 (en utilisant Collection(Edm.Half)) sans travail supplémentaire.

    Modèle d'intégration Sortie native Attribuer ce type dans Recherche Azure AI
    text-embedding-ada-002 Float32 Collection(Edm.Single) ou Collection(Edm.Half)
    text-embedding-3-small Float32 Collection(Edm.Single) ou Collection(Edm.Half)
    text-embedding-3-large Float32 Collection(Edm.Single) ou Collection(Edm.Half)
    Modèles d'intégration Cohere V3 avec int8 embedding_type Int8 Collection(Edm.SByte)

    D’autres types de données étroits peuvent être utilisés si votre modèle émet des incorporations dans le format de données plus petit, ou si vous avez une quantification personnalisée qui convertit des vecteurs vers un format plus petit.

  3. Assurez-vous de comprendre les compromis d’un type de données restreint. Collection(Edm.Half) contient moins d’informations, ce qui entraîne une résolution plus faible. Si vos données sont homogènes ou denses, la perte de détails ou de nuances supplémentaires pourrait conduire à des résultats inacceptables au moment de la requête, car moins de détails peuvent être utilisés pour distinguer les vecteurs proches.

  4. Définir et construire l'index. Vous pouvez utiliser le Portail Azure, Créer ou mettre à jour un index (API REST) ou un package de Kit de développement logiciel (SDK) Azure pour cette étape.

  5. Vérifier les résultats. En supposant que le champ vectoriel est marqué comme récupérable, utilisez l’Explorateur de recherche ou Recherche – POST pour vérifier que le contenu du champ correspond au type de données.

    Pour vérifier la taille de l’index vectoriel, utilisez le Portail Azure ou GET Statistics (API REST).

Remarque

Le type de données du champ est utilisé pour créer la structure physique des données. Si vous souhaitez modifier un type de données ultérieurement, supprimez et reconstruisez l'index ou créez un deuxième champ avec la nouvelle définition.

Option 3 : Définir la propriété stored pour supprimer le stockage récupérable

La propriété stored est une valeur booléenne sur une définition de champ vectoriel qui détermine si le stockage est alloué au contenu de champ vectoriel récupérable. La propriété stored a la valeur true par défaut. Si vous n'avez pas besoin de contenu vectoriel dans une réponse à une requête, vous pouvez économiser jusqu'à 50 % de stockage par champ en définissant la valeur stored sur false.

Considérations pour définir stored sur la valeur false :

  • Étant donné que les vecteurs ne sont pas lisibles par l’être humain, vous pouvez les omettre des résultats envoyés aux grands modèles de langage dans des scénarios RAG et des résultats rendus sur une page de recherche. Conservez-les toutefois si vous utilisez des vecteurs dans un processus en aval qui consomme un contenu vectoriel.

  • Toutefois, si votre stratégie d’indexation inclut des mises à jour partielles de documents telles que « merge » ou « mergeOrUpload » sur un document, sachez que la définition de stored sur la valeur false entraîne l’omission du champ non stocké pendant la fusion. Sur chaque opération « merge » ou » mergeOrUpload », vous devez fournir les champs vectoriels en plus des autres champs non vectoriels que vous mettez à jour. Dans le cas contraire, le vecteur est supprimé.

N’oubliez pas que l’attribution de stored est irréversible. Elle est définie pendant la création d’index sur des champs vectoriels lors de la création de structures de données physiques. Si vous souhaitez que le contenu vectoriel soit récupérable ultérieurement, vous devez supprimer et reconstruire l’index, ou créer et charger un nouveau champ doté de la nouvelle attribution.

L'exemple suivant montre la collection de champs d'un index de recherche. Définissez stored sur false pour supprimer définitivement le stockage récupérable pour le champ vectoriel.

PUT https://[service-name].search.windows.net/indexes/demo-index?api-version=2024-07-01 
   Content-Type: application/json  
   api-key: [admin key]  
 
     { 
       "name": "demo-index", 
       "fields": [ 
         { 
           "name": "vectorContent", 
           "type": "Collection(Edm.Single)", 
           "retrievable": false, 
           "stored": false, 
           "dimensions": 1536, 
           "vectorSearchProfile": "vectorProfile" 
         } 
       ] 
     }

Points essentiels :

  • S'applique uniquement aux champs vectoriels.

  • Affecte le stockage sur disque, pas la mémoire, et n'a aucun effet sur les requêtes. L'exécution de la requête utilise un index vectoriel distinct qui n'est pas affecté par la propriété stored.

  • La propriété stored est définie lors de la création de l'index sur les champs vectoriels et est irréversible. Si vous souhaitez que le contenu soit récupérable ultérieurement, vous devez supprimer et reconstruire l'index, ou créer et charger un nouveau champ doté de la nouvelle attribution.

  • Les valeurs par défaut sont stored définies sur true et retrievable sur false. Dans une configuration par défaut, une copie récupérable est stockée, mais elle n'est pas automatiquement renvoyée dans les résultats. Lorsque stored c'est vrai, vous pouvez basculer retrievable entre vrai et faux à tout moment sans avoir à reconstruire un index. Quand stored est faux, retrievable doit être faux et ne peut pas être modifié.

Exemple : techniques de compression vectorielle

Voici du code Python qui montre la quantification, les types de données étroits et l’utilisation de la propriété stockée : Exemple de code : options de stockages et quantification vectorielle en utilisant Python.

Ce code crée et compare le stockage et la taille d’index vectoriel pour chaque option :

****************************************
Index Name: compressiontest-baseline
Storage Size: 21.3613MB
Vector Size: 4.8277MB
****************************************
Index Name: compressiontest-compression
Storage Size: 17.7604MB
Vector Size: 1.2242MB
****************************************
Index Name: compressiontest-narrow
Storage Size: 16.5567MB
Vector Size: 2.4254MB
****************************************
Index Name: compressiontest-no-stored
Storage Size: 10.9224MB
Vector Size: 4.8277MB
****************************************
Index Name: compressiontest-all-options
Storage Size: 4.9192MB
Vector Size: 1.2242MB

Les API Recherche signalent la taille de vecteur et de stockage au niveau de l’index. Les index, et non les champs, doivent donc être la base de la comparaison. Utilisez GET Index Statistics ou une API équivalente dans les Kits de développement logiciel (SDK) Azure pour obtenir la taille de vecteur.

Interroger un champ vectoriel quantifié en utilisant le suréchantillonnage

La syntaxe de requête d’un champ vectoriel compressé ou quantifié est la même que pour des champs vectoriels non compressés, sauf si vous souhaitez remplacer les paramètres associés au suréchantillonnage ou au reclassement par les vecteurs d’origine.

N’oubliez pas que la définition de compression vectorielle dans l’index a des paramètres pour rerankWithOriginalVectors et defaultOversampling afin d’atténuer les effets d’un index vectoriel plus petit. Vous pouvez remplacer les valeurs par défaut afin de faire varier le comportement au moment de la requête. Par exemple, si defaultOversampling est 10.0, vous pouvez le remplacer par autre chose dans la demande de requête.

Vous pouvez définir le paramètre de suréchantillonnage même si l'index n'a pas explicitement de définition rerankWithOriginalVectors ou defaultOversampling. Fournir oversampling au moment de la requête remplace les paramètres d'index pour cette requête et exécute la requête rerankWithOriginalVectors avec la valeur true.

POST https://[service-name].search.windows.net/indexes/demo-index/docs/search?api-version=2024-07-01   
  Content-Type: application/json   
  api-key: [admin key]   

    {    
       "vectorQueries": [
            {    
                "kind": "vector",    
                "vector": [8, 2, 3, 4, 3, 5, 2, 1],    
                "fields": "myvector",
                "oversampling": 12.0,
                "k": 5   
            }
      ]    
    }

Points essentiels :

  • S'applique aux champs vectoriels soumis à une compression vectorielle, conformément à l'affectation du profil vectoriel.

  • Remplace la valeur defaultOversampling ou introduit un suréchantillonnage au moment de la requête, même si la configuration de compression de l'index ne spécifie pas d'options de suréchantillonnage ou de reclassement.

Voir aussi