pulumi-gcp 7.8.0a1706805960__py3-none-any.whl → 7.8.0a1706829616__py3-none-any.whl

pulumi_gcp/vertex/outputs.py

@@ -2257,17 +2257,27 @@ class GetAiIndexDeployedIndexResult(dict):
     def __init__(__self__, *,
                  deployed_index_id: str,
                  index_endpoint: str):
+        """
+        :param str deployed_index_id: The ID of the DeployedIndex in the above IndexEndpoint.
+        :param str index_endpoint: A resource name of the IndexEndpoint.
+        """
         pulumi.set(__self__, "deployed_index_id", deployed_index_id)
         pulumi.set(__self__, "index_endpoint", index_endpoint)
 
     @property
     @pulumi.getter(name="deployedIndexId")
     def deployed_index_id(self) -> str:
+        """
+        The ID of the DeployedIndex in the above IndexEndpoint.
+        """
         return pulumi.get(self, "deployed_index_id")
 
     @property
     @pulumi.getter(name="indexEndpoint")
     def index_endpoint(self) -> str:
+        """
+        A resource name of the IndexEndpoint.
+        """
         return pulumi.get(self, "index_endpoint")
 
 
@@ -2276,17 +2286,27 @@ class GetAiIndexIndexStatResult(dict):
     def __init__(__self__, *,
                  shards_count: int,
                  vectors_count: str):
+        """
+        :param int shards_count: The number of shards in the Index.
+        :param str vectors_count: The number of vectors in the Index.
+        """
         pulumi.set(__self__, "shards_count", shards_count)
         pulumi.set(__self__, "vectors_count", vectors_count)
 
     @property
     @pulumi.getter(name="shardsCount")
     def shards_count(self) -> int:
+        """
+        The number of shards in the Index.
+        """
         return pulumi.get(self, "shards_count")
 
     @property
     @pulumi.getter(name="vectorsCount")
     def vectors_count(self) -> str:
+        """
+        The number of vectors in the Index.
+        """
         return pulumi.get(self, "vectors_count")
 
 
@@ -2296,6 +2316,17 @@ class GetAiIndexMetadataResult(dict):
                  configs: Sequence['outputs.GetAiIndexMetadataConfigResult'],
                  contents_delta_uri: str,
                  is_complete_overwrite: bool):
+        """
+        :param Sequence['GetAiIndexMetadataConfigArgs'] configs: The configuration of the Matching Engine Index.
+        :param str contents_delta_uri: Allows inserting, updating  or deleting the contents of the Matching Engine Index.
+               The string must be a valid Cloud Storage directory path. If this
+               field is set when calling IndexService.UpdateIndex, then no other
+               Index field can be also updated as part of the same call.
+               The expected structure and format of the files this URI points to is
+               described at https://cloud.google.com/vertex-ai/docs/matching-engine/using-matching-engine#input-data-format
+        :param bool is_complete_overwrite: If this field is set together with contentsDeltaUri when calling IndexService.UpdateIndex,
+               then existing content of the Index will be replaced by the data from the contentsDeltaUri.
+        """
         pulumi.set(__self__, "configs", configs)
         pulumi.set(__self__, "contents_delta_uri", contents_delta_uri)
         pulumi.set(__self__, "is_complete_overwrite", is_complete_overwrite)
@@ -2303,16 +2334,31 @@ class GetAiIndexMetadataResult(dict):
     @property
     @pulumi.getter
     def configs(self) -> Sequence['outputs.GetAiIndexMetadataConfigResult']:
+        """
+        The configuration of the Matching Engine Index.
+        """
         return pulumi.get(self, "configs")
 
     @property
     @pulumi.getter(name="contentsDeltaUri")
     def contents_delta_uri(self) -> str:
+        """
+        Allows inserting, updating  or deleting the contents of the Matching Engine Index.
+        The string must be a valid Cloud Storage directory path. If this
+        field is set when calling IndexService.UpdateIndex, then no other
+        Index field can be also updated as part of the same call.
+        The expected structure and format of the files this URI points to is
+        described at https://cloud.google.com/vertex-ai/docs/matching-engine/using-matching-engine#input-data-format
+        """
         return pulumi.get(self, "contents_delta_uri")
 
     @property
     @pulumi.getter(name="isCompleteOverwrite")
     def is_complete_overwrite(self) -> bool:
+        """
+        If this field is set together with contentsDeltaUri when calling IndexService.UpdateIndex,
+        then existing content of the Index will be replaced by the data from the contentsDeltaUri.
+        """
         return pulumi.get(self, "is_complete_overwrite")
 
 
@@ -2325,6 +2371,27 @@ class GetAiIndexMetadataConfigResult(dict):
                  distance_measure_type: str,
                  feature_norm_type: str,
                  shard_size: str):
+        """
+        :param Sequence['GetAiIndexMetadataConfigAlgorithmConfigArgs'] algorithm_configs: The configuration with regard to the algorithms used for efficient search.
+        :param int approximate_neighbors_count: The default number of neighbors to find via approximate search before exact reordering is
+               performed. Exact reordering is a procedure where results returned by an
+               approximate search algorithm are reordered via a more expensive distance computation.
+               Required if tree-AH algorithm is used.
+        :param int dimensions: The number of dimensions of the input vectors.
+        :param str distance_measure_type: The distance measure used in nearest neighbor search. The value must be one of the followings:
+               * SQUARED_L2_DISTANCE: Euclidean (L_2) Distance
+               * L1_DISTANCE: Manhattan (L_1) Distance
+               * COSINE_DISTANCE: Cosine Distance. Defined as 1 - cosine similarity.
+               * DOT_PRODUCT_DISTANCE: Dot Product Distance. Defined as a negative of the dot product
+        :param str feature_norm_type: Type of normalization to be carried out on each vector. The value must be one of the followings:
+               * UNIT_L2_NORM: Unit L2 normalization type
+               * NONE: No normalization type is specified.
+        :param str shard_size: Index data is split into equal parts to be processed. These are called "shards".
+               The shard size must be specified when creating an index. The value must be one of the followings:
+               * SHARD_SIZE_SMALL: Small (2GB)
+               * SHARD_SIZE_MEDIUM: Medium (20GB)
+               * SHARD_SIZE_LARGE: Large (50GB)
+        """
         pulumi.set(__self__, "algorithm_configs", algorithm_configs)
         pulumi.set(__self__, "approximate_neighbors_count", approximate_neighbors_count)
         pulumi.set(__self__, "dimensions", dimensions)
@@ -2335,31 +2402,62 @@ class GetAiIndexMetadataConfigResult(dict):
     @property
     @pulumi.getter(name="algorithmConfigs")
     def algorithm_configs(self) -> Sequence['outputs.GetAiIndexMetadataConfigAlgorithmConfigResult']:
+        """
+        The configuration with regard to the algorithms used for efficient search.
+        """
         return pulumi.get(self, "algorithm_configs")
 
     @property
     @pulumi.getter(name="approximateNeighborsCount")
     def approximate_neighbors_count(self) -> int:
+        """
+        The default number of neighbors to find via approximate search before exact reordering is
+        performed. Exact reordering is a procedure where results returned by an
+        approximate search algorithm are reordered via a more expensive distance computation.
+        Required if tree-AH algorithm is used.
+        """
         return pulumi.get(self, "approximate_neighbors_count")
 
     @property
     @pulumi.getter
     def dimensions(self) -> int:
+        """
+        The number of dimensions of the input vectors.
+        """
         return pulumi.get(self, "dimensions")
 
     @property
     @pulumi.getter(name="distanceMeasureType")
     def distance_measure_type(self) -> str:
+        """
+        The distance measure used in nearest neighbor search. The value must be one of the followings:
+        * SQUARED_L2_DISTANCE: Euclidean (L_2) Distance
+        * L1_DISTANCE: Manhattan (L_1) Distance
+        * COSINE_DISTANCE: Cosine Distance. Defined as 1 - cosine similarity.
+        * DOT_PRODUCT_DISTANCE: Dot Product Distance. Defined as a negative of the dot product
+        """
         return pulumi.get(self, "distance_measure_type")
 
     @property
     @pulumi.getter(name="featureNormType")
     def feature_norm_type(self) -> str:
+        """
+        Type of normalization to be carried out on each vector. The value must be one of the followings:
+        * UNIT_L2_NORM: Unit L2 normalization type
+        * NONE: No normalization type is specified.
+        """
         return pulumi.get(self, "feature_norm_type")
 
     @property
     @pulumi.getter(name="shardSize")
     def shard_size(self) -> str:
+        """
+        Index data is split into equal parts to be processed. These are called "shards".
+        The shard size must be specified when creating an index. The value must be one of the followings:
+        * SHARD_SIZE_SMALL: Small (2GB)
+        * SHARD_SIZE_MEDIUM: Medium (20GB)
+        * SHARD_SIZE_LARGE: Large (50GB)
+        """
         return pulumi.get(self, "shard_size")
 
 
@@ -2368,17 +2466,31 @@ class GetAiIndexMetadataConfigAlgorithmConfigResult(dict):
     def __init__(__self__, *,
                  brute_force_configs: Sequence['outputs.GetAiIndexMetadataConfigAlgorithmConfigBruteForceConfigResult'],
                  tree_ah_configs: Sequence['outputs.GetAiIndexMetadataConfigAlgorithmConfigTreeAhConfigResult']):
+        """
+        :param Sequence['GetAiIndexMetadataConfigAlgorithmConfigBruteForceConfigArgs'] brute_force_configs: Configuration options for using brute force search, which simply implements the
+               standard linear search in the database for each query.
+        :param Sequence['GetAiIndexMetadataConfigAlgorithmConfigTreeAhConfigArgs'] tree_ah_configs: Configuration options for using the tree-AH algorithm (Shallow tree + Asymmetric Hashing).
+               Please refer to this paper for more details: https://arxiv.org/abs/1908.10396
+        """
         pulumi.set(__self__, "brute_force_configs", brute_force_configs)
         pulumi.set(__self__, "tree_ah_configs", tree_ah_configs)
 
     @property
     @pulumi.getter(name="bruteForceConfigs")
     def brute_force_configs(self) -> Sequence['outputs.GetAiIndexMetadataConfigAlgorithmConfigBruteForceConfigResult']:
+        """
+        Configuration options for using brute force search, which simply implements the
+        standard linear search in the database for each query.
+        """
         return pulumi.get(self, "brute_force_configs")
 
     @property
     @pulumi.getter(name="treeAhConfigs")
     def tree_ah_configs(self) -> Sequence['outputs.GetAiIndexMetadataConfigAlgorithmConfigTreeAhConfigResult']:
+        """
+        Configuration options for using the tree-AH algorithm (Shallow tree + Asymmetric Hashing).
+        Please refer to this paper for more details: https://arxiv.org/abs/1908.10396
+        """
         return pulumi.get(self, "tree_ah_configs")
 
 
@@ -2393,17 +2505,29 @@ class GetAiIndexMetadataConfigAlgorithmConfigTreeAhConfigResult(dict):
     def __init__(__self__, *,
                  leaf_node_embedding_count: int,
                  leaf_nodes_to_search_percent: int):
+        """
+        :param int leaf_node_embedding_count: Number of embeddings on each leaf node. The default value is 1000 if not set.
+        :param int leaf_nodes_to_search_percent: The default percentage of leaf nodes that any query may be searched. Must be in
+               range 1-100, inclusive. The default value is 10 (means 10%) if not set.
+        """
         pulumi.set(__self__, "leaf_node_embedding_count", leaf_node_embedding_count)
         pulumi.set(__self__, "leaf_nodes_to_search_percent", leaf_nodes_to_search_percent)
 
     @property
     @pulumi.getter(name="leafNodeEmbeddingCount")
     def leaf_node_embedding_count(self) -> int:
+        """
+        Number of embeddings on each leaf node. The default value is 1000 if not set.
+        """
         return pulumi.get(self, "leaf_node_embedding_count")
 
     @property
     @pulumi.getter(name="leafNodesToSearchPercent")
     def leaf_nodes_to_search_percent(self) -> int:
+        """
+        The default percentage of leaf nodes that any query may be searched. Must be in
+        range 1-100, inclusive. The default value is 10 (means 10%) if not set.
+        """
         return pulumi.get(self, "leaf_nodes_to_search_percent")