@pulumi/azure-native
Version:
[](https://slack.pulumi.com) [](https://npmjs.com/package/@pulumi/azure-native) [![Python version](https://badge.fury.io/py/pu
1,331 lines • 78.7 kB
TypeScript
export declare const AllowedContentLevel: {
readonly Low: "Low";
readonly Medium: "Medium";
readonly High: "High";
};
/**
* Level at which content is filtered.
*/
export type AllowedContentLevel = (typeof AllowedContentLevel)[keyof typeof AllowedContentLevel];
export declare const ApplicationSharingPolicy: {
readonly Personal: "Personal";
readonly Shared: "Shared";
};
/**
* Policy for sharing applications on this compute instance among users of parent workspace. If Personal, only the creator can access applications on this compute instance. When Shared, any workspace user can access applications on this instance depending on his/her assigned role.
*/
export type ApplicationSharingPolicy = (typeof ApplicationSharingPolicy)[keyof typeof ApplicationSharingPolicy];
export declare const AuthMode: {
readonly AAD: "AAD";
};
/**
* [Required] Authentication mode for the endpoint.
*/
export type AuthMode = (typeof AuthMode)[keyof typeof AuthMode];
export declare const AutoRebuildSetting: {
readonly Disabled: "Disabled";
readonly OnBaseImageUpdate: "OnBaseImageUpdate";
};
/**
* Defines if image needs to be rebuilt based on base image changes.
*/
export type AutoRebuildSetting = (typeof AutoRebuildSetting)[keyof typeof AutoRebuildSetting];
export declare const BatchDeploymentConfigurationType: {
readonly Model: "Model";
readonly PipelineComponent: "PipelineComponent";
};
/**
* [Required] The type of the deployment
*/
export type BatchDeploymentConfigurationType = (typeof BatchDeploymentConfigurationType)[keyof typeof BatchDeploymentConfigurationType];
export declare const BatchLoggingLevel: {
readonly Info: "Info";
readonly Warning: "Warning";
readonly Debug: "Debug";
};
/**
* Logging level for batch inference operation.
*/
export type BatchLoggingLevel = (typeof BatchLoggingLevel)[keyof typeof BatchLoggingLevel];
export declare const BatchOutputAction: {
readonly SummaryOnly: "SummaryOnly";
readonly AppendRow: "AppendRow";
};
/**
* Indicates how the output will be organized.
*/
export type BatchOutputAction = (typeof BatchOutputAction)[keyof typeof BatchOutputAction];
export declare const BlockedTransformers: {
/**
* Target encoding for text data.
*/
readonly TextTargetEncoder: "TextTargetEncoder";
/**
* Ohe hot encoding creates a binary feature transformation.
*/
readonly OneHotEncoder: "OneHotEncoder";
/**
* Target encoding for categorical data.
*/
readonly CatTargetEncoder: "CatTargetEncoder";
/**
* Tf-Idf stands for, term-frequency times inverse document-frequency. This is a common term weighting scheme for identifying information from documents.
*/
readonly TfIdf: "TfIdf";
/**
* Weight of Evidence encoding is a technique used to encode categorical variables. It uses the natural log of the P(1)/P(0) to create weights.
*/
readonly WoETargetEncoder: "WoETargetEncoder";
/**
* Label encoder converts labels/categorical variables in a numerical form.
*/
readonly LabelEncoder: "LabelEncoder";
/**
* Word embedding helps represents words or phrases as a vector, or a series of numbers.
*/
readonly WordEmbedding: "WordEmbedding";
/**
* Naive Bayes is a classified that is used for classification of discrete features that are categorically distributed.
*/
readonly NaiveBayes: "NaiveBayes";
/**
* Count Vectorizer converts a collection of text documents to a matrix of token counts.
*/
readonly CountVectorizer: "CountVectorizer";
/**
* Hashing One Hot Encoder can turn categorical variables into a limited number of new features. This is often used for high-cardinality categorical features.
*/
readonly HashOneHotEncoder: "HashOneHotEncoder";
};
/**
* Enum for all classification models supported by AutoML.
*/
export type BlockedTransformers = (typeof BlockedTransformers)[keyof typeof BlockedTransformers];
export declare const CapabilityHostKind: {
readonly Agents: "Agents";
};
/**
* Kind of this capability host.
*/
export type CapabilityHostKind = (typeof CapabilityHostKind)[keyof typeof CapabilityHostKind];
export declare const CategoricalDataDriftMetric: {
/**
* The Jensen Shannon Distance (JSD) metric.
*/
readonly JensenShannonDistance: "JensenShannonDistance";
/**
* The Population Stability Index (PSI) metric.
*/
readonly PopulationStabilityIndex: "PopulationStabilityIndex";
/**
* The Pearsons Chi Squared Test metric.
*/
readonly PearsonsChiSquaredTest: "PearsonsChiSquaredTest";
};
/**
* [Required] The categorical data drift metric to calculate.
*/
export type CategoricalDataDriftMetric = (typeof CategoricalDataDriftMetric)[keyof typeof CategoricalDataDriftMetric];
export declare const CategoricalDataQualityMetric: {
/**
* Calculates the rate of null values.
*/
readonly NullValueRate: "NullValueRate";
/**
* Calculates the rate of data type errors.
*/
readonly DataTypeErrorRate: "DataTypeErrorRate";
/**
* Calculates the rate values are out of bounds.
*/
readonly OutOfBoundsRate: "OutOfBoundsRate";
};
/**
* [Required] The categorical data quality metric to calculate.
*/
export type CategoricalDataQualityMetric = (typeof CategoricalDataQualityMetric)[keyof typeof CategoricalDataQualityMetric];
export declare const CategoricalPredictionDriftMetric: {
/**
* The Jensen Shannon Distance (JSD) metric.
*/
readonly JensenShannonDistance: "JensenShannonDistance";
/**
* The Population Stability Index (PSI) metric.
*/
readonly PopulationStabilityIndex: "PopulationStabilityIndex";
/**
* The Pearsons Chi Squared Test metric.
*/
readonly PearsonsChiSquaredTest: "PearsonsChiSquaredTest";
};
/**
* [Required] The categorical prediction drift metric to calculate.
*/
export type CategoricalPredictionDriftMetric = (typeof CategoricalPredictionDriftMetric)[keyof typeof CategoricalPredictionDriftMetric];
export declare const ClassificationModels: {
/**
* Logistic regression is a fundamental classification technique.
* It belongs to the group of linear classifiers and is somewhat similar to polynomial and linear regression.
* Logistic regression is fast and relatively uncomplicated, and it's convenient for you to interpret the results.
* Although it's essentially a method for binary classification, it can also be applied to multiclass problems.
*/
readonly LogisticRegression: "LogisticRegression";
/**
* SGD: Stochastic gradient descent is an optimization algorithm often used in machine learning applications
* to find the model parameters that correspond to the best fit between predicted and actual outputs.
*/
readonly SGD: "SGD";
/**
* The multinomial Naive Bayes classifier is suitable for classification with discrete features (e.g., word counts for text classification).
* The multinomial distribution normally requires integer feature counts. However, in practice, fractional counts such as tf-idf may also work.
*/
readonly MultinomialNaiveBayes: "MultinomialNaiveBayes";
/**
* Naive Bayes classifier for multivariate Bernoulli models.
*/
readonly BernoulliNaiveBayes: "BernoulliNaiveBayes";
/**
* A support vector machine (SVM) is a supervised machine learning model that uses classification algorithms for two-group classification problems.
* After giving an SVM model sets of labeled training data for each category, they're able to categorize new text.
*/
readonly SVM: "SVM";
/**
* A support vector machine (SVM) is a supervised machine learning model that uses classification algorithms for two-group classification problems.
* After giving an SVM model sets of labeled training data for each category, they're able to categorize new text.
* Linear SVM performs best when input data is linear, i.e., data can be easily classified by drawing the straight line between classified values on a plotted graph.
*/
readonly LinearSVM: "LinearSVM";
/**
* K-nearest neighbors (KNN) algorithm uses 'feature similarity' to predict the values of new datapoints
* which further means that the new data point will be assigned a value based on how closely it matches the points in the training set.
*/
readonly KNN: "KNN";
/**
* Decision Trees are a non-parametric supervised learning method used for both classification and regression tasks.
* The goal is to create a model that predicts the value of a target variable by learning simple decision rules inferred from the data features.
*/
readonly DecisionTree: "DecisionTree";
/**
* Random forest is a supervised learning algorithm.
* The "forest" it builds, is an ensemble of decision trees, usually trained with the "bagging" method.
* The general idea of the bagging method is that a combination of learning models increases the overall result.
*/
readonly RandomForest: "RandomForest";
/**
* Extreme Trees is an ensemble machine learning algorithm that combines the predictions from many decision trees. It is related to the widely used random forest algorithm.
*/
readonly ExtremeRandomTrees: "ExtremeRandomTrees";
/**
* LightGBM is a gradient boosting framework that uses tree based learning algorithms.
*/
readonly LightGBM: "LightGBM";
/**
* The technique of transiting week learners into a strong learner is called Boosting. The gradient boosting algorithm process works on this theory of execution.
*/
readonly GradientBoosting: "GradientBoosting";
/**
* XGBoost: Extreme Gradient Boosting Algorithm. This algorithm is used for structured data where target column values can be divided into distinct class values.
*/
readonly XGBoostClassifier: "XGBoostClassifier";
};
/**
* Enum for all classification models supported by AutoML.
*/
export type ClassificationModels = (typeof ClassificationModels)[keyof typeof ClassificationModels];
export declare const ClassificationMultilabelPrimaryMetrics: {
/**
* AUC is the Area under the curve.
* This metric represents arithmetic mean of the score for each class,
* weighted by the number of true instances in each class.
*/
readonly AUCWeighted: "AUCWeighted";
/**
* Accuracy is the ratio of predictions that exactly match the true class labels.
*/
readonly Accuracy: "Accuracy";
/**
* Normalized macro recall is recall macro-averaged and normalized, so that random
* performance has a score of 0, and perfect performance has a score of 1.
*/
readonly NormMacroRecall: "NormMacroRecall";
/**
* The arithmetic mean of the average precision score for each class, weighted by
* the number of true instances in each class.
*/
readonly AveragePrecisionScoreWeighted: "AveragePrecisionScoreWeighted";
/**
* The arithmetic mean of precision for each class, weighted by number of true instances in each class.
*/
readonly PrecisionScoreWeighted: "PrecisionScoreWeighted";
/**
* Intersection Over Union. Intersection of predictions divided by union of predictions.
*/
readonly IOU: "IOU";
};
/**
* Primary metric to optimize for this task.
*/
export type ClassificationMultilabelPrimaryMetrics = (typeof ClassificationMultilabelPrimaryMetrics)[keyof typeof ClassificationMultilabelPrimaryMetrics];
export declare const ClassificationPrimaryMetrics: {
/**
* AUC is the Area under the curve.
* This metric represents arithmetic mean of the score for each class,
* weighted by the number of true instances in each class.
*/
readonly AUCWeighted: "AUCWeighted";
/**
* Accuracy is the ratio of predictions that exactly match the true class labels.
*/
readonly Accuracy: "Accuracy";
/**
* Normalized macro recall is recall macro-averaged and normalized, so that random
* performance has a score of 0, and perfect performance has a score of 1.
*/
readonly NormMacroRecall: "NormMacroRecall";
/**
* The arithmetic mean of the average precision score for each class, weighted by
* the number of true instances in each class.
*/
readonly AveragePrecisionScoreWeighted: "AveragePrecisionScoreWeighted";
/**
* The arithmetic mean of precision for each class, weighted by number of true instances in each class.
*/
readonly PrecisionScoreWeighted: "PrecisionScoreWeighted";
};
/**
* Primary metric for Text-Classification task.
*/
export type ClassificationPrimaryMetrics = (typeof ClassificationPrimaryMetrics)[keyof typeof ClassificationPrimaryMetrics];
export declare const ClusterPurpose: {
readonly FastProd: "FastProd";
readonly DenseProd: "DenseProd";
readonly DevTest: "DevTest";
};
/**
* Intended usage of the cluster
*/
export type ClusterPurpose = (typeof ClusterPurpose)[keyof typeof ClusterPurpose];
export declare const ComputeInstanceAuthorizationType: {
readonly Personal: "personal";
};
/**
* The Compute Instance Authorization type. Available values are personal (default).
*/
export type ComputeInstanceAuthorizationType = (typeof ComputeInstanceAuthorizationType)[keyof typeof ComputeInstanceAuthorizationType];
export declare const ComputePowerAction: {
readonly Start: "Start";
readonly Stop: "Stop";
};
/**
* [Required] The compute power action.
*/
export type ComputePowerAction = (typeof ComputePowerAction)[keyof typeof ComputePowerAction];
export declare const ComputeRecurrenceFrequency: {
/**
* Minute frequency
*/
readonly Minute: "Minute";
/**
* Hour frequency
*/
readonly Hour: "Hour";
/**
* Day frequency
*/
readonly Day: "Day";
/**
* Week frequency
*/
readonly Week: "Week";
/**
* Month frequency
*/
readonly Month: "Month";
};
/**
* [Required] The frequency to trigger schedule.
*/
export type ComputeRecurrenceFrequency = (typeof ComputeRecurrenceFrequency)[keyof typeof ComputeRecurrenceFrequency];
export declare const ComputeTriggerType: {
readonly Recurrence: "Recurrence";
readonly Cron: "Cron";
};
/**
* [Required] The schedule trigger type.
*/
export type ComputeTriggerType = (typeof ComputeTriggerType)[keyof typeof ComputeTriggerType];
export declare const ComputeType: {
readonly AKS: "AKS";
readonly Kubernetes: "Kubernetes";
readonly AmlCompute: "AmlCompute";
readonly ComputeInstance: "ComputeInstance";
readonly DataFactory: "DataFactory";
readonly VirtualMachine: "VirtualMachine";
readonly HDInsight: "HDInsight";
readonly Databricks: "Databricks";
readonly DataLakeAnalytics: "DataLakeAnalytics";
readonly SynapseSpark: "SynapseSpark";
};
/**
* The type of compute
*/
export type ComputeType = (typeof ComputeType)[keyof typeof ComputeType];
export declare const ComputeWeekDay: {
/**
* Monday weekday
*/
readonly Monday: "Monday";
/**
* Tuesday weekday
*/
readonly Tuesday: "Tuesday";
/**
* Wednesday weekday
*/
readonly Wednesday: "Wednesday";
/**
* Thursday weekday
*/
readonly Thursday: "Thursday";
/**
* Friday weekday
*/
readonly Friday: "Friday";
/**
* Saturday weekday
*/
readonly Saturday: "Saturday";
/**
* Sunday weekday
*/
readonly Sunday: "Sunday";
};
/**
* Enum of weekday
*/
export type ComputeWeekDay = (typeof ComputeWeekDay)[keyof typeof ComputeWeekDay];
export declare const ConnectionAuthType: {
readonly PAT: "PAT";
readonly ManagedIdentity: "ManagedIdentity";
readonly UsernamePassword: "UsernamePassword";
readonly None: "None";
readonly SAS: "SAS";
readonly AccountKey: "AccountKey";
readonly ServicePrincipal: "ServicePrincipal";
readonly AccessKey: "AccessKey";
readonly ApiKey: "ApiKey";
readonly CustomKeys: "CustomKeys";
readonly OAuth2: "OAuth2";
readonly AAD: "AAD";
};
/**
* Authentication type of the connection target
*/
export type ConnectionAuthType = (typeof ConnectionAuthType)[keyof typeof ConnectionAuthType];
export declare const ConnectionCategory: {
readonly PythonFeed: "PythonFeed";
readonly ContainerRegistry: "ContainerRegistry";
readonly Git: "Git";
readonly S3: "S3";
readonly Snowflake: "Snowflake";
readonly AzureSqlDb: "AzureSqlDb";
readonly AzureSynapseAnalytics: "AzureSynapseAnalytics";
readonly AzureMySqlDb: "AzureMySqlDb";
readonly AzurePostgresDb: "AzurePostgresDb";
readonly ADLSGen2: "ADLSGen2";
readonly Redis: "Redis";
readonly ApiKey: "ApiKey";
readonly AzureOpenAI: "AzureOpenAI";
readonly AIServices: "AIServices";
readonly CognitiveSearch: "CognitiveSearch";
readonly CognitiveService: "CognitiveService";
readonly CustomKeys: "CustomKeys";
readonly AzureBlob: "AzureBlob";
readonly AzureOneLake: "AzureOneLake";
readonly CosmosDb: "CosmosDb";
readonly CosmosDbMongoDbApi: "CosmosDbMongoDbApi";
readonly AzureDataExplorer: "AzureDataExplorer";
readonly AzureMariaDb: "AzureMariaDb";
readonly AzureDatabricksDeltaLake: "AzureDatabricksDeltaLake";
readonly AzureSqlMi: "AzureSqlMi";
readonly AzureTableStorage: "AzureTableStorage";
readonly AmazonRdsForOracle: "AmazonRdsForOracle";
readonly AmazonRdsForSqlServer: "AmazonRdsForSqlServer";
readonly AmazonRedshift: "AmazonRedshift";
readonly Db2: "Db2";
readonly Drill: "Drill";
readonly GoogleBigQuery: "GoogleBigQuery";
readonly Greenplum: "Greenplum";
readonly Hbase: "Hbase";
readonly Hive: "Hive";
readonly Impala: "Impala";
readonly Informix: "Informix";
readonly MariaDb: "MariaDb";
readonly MicrosoftAccess: "MicrosoftAccess";
readonly MySql: "MySql";
readonly Netezza: "Netezza";
readonly Oracle: "Oracle";
readonly Phoenix: "Phoenix";
readonly PostgreSql: "PostgreSql";
readonly Presto: "Presto";
readonly SapOpenHub: "SapOpenHub";
readonly SapBw: "SapBw";
readonly SapHana: "SapHana";
readonly SapTable: "SapTable";
readonly Spark: "Spark";
readonly SqlServer: "SqlServer";
readonly Sybase: "Sybase";
readonly Teradata: "Teradata";
readonly Vertica: "Vertica";
readonly Pinecone: "Pinecone";
readonly Cassandra: "Cassandra";
readonly Couchbase: "Couchbase";
readonly MongoDbV2: "MongoDbV2";
readonly MongoDbAtlas: "MongoDbAtlas";
readonly AmazonS3Compatible: "AmazonS3Compatible";
readonly FileServer: "FileServer";
readonly FtpServer: "FtpServer";
readonly GoogleCloudStorage: "GoogleCloudStorage";
readonly Hdfs: "Hdfs";
readonly OracleCloudStorage: "OracleCloudStorage";
readonly Sftp: "Sftp";
readonly GenericHttp: "GenericHttp";
readonly ODataRest: "ODataRest";
readonly Odbc: "Odbc";
readonly GenericRest: "GenericRest";
readonly AmazonMws: "AmazonMws";
readonly Concur: "Concur";
readonly Dynamics: "Dynamics";
readonly DynamicsAx: "DynamicsAx";
readonly DynamicsCrm: "DynamicsCrm";
readonly GoogleAdWords: "GoogleAdWords";
readonly Hubspot: "Hubspot";
readonly Jira: "Jira";
readonly Magento: "Magento";
readonly Marketo: "Marketo";
readonly Office365: "Office365";
readonly Eloqua: "Eloqua";
readonly Responsys: "Responsys";
readonly OracleServiceCloud: "OracleServiceCloud";
readonly PayPal: "PayPal";
readonly QuickBooks: "QuickBooks";
readonly Salesforce: "Salesforce";
readonly SalesforceServiceCloud: "SalesforceServiceCloud";
readonly SalesforceMarketingCloud: "SalesforceMarketingCloud";
readonly SapCloudForCustomer: "SapCloudForCustomer";
readonly SapEcc: "SapEcc";
readonly ServiceNow: "ServiceNow";
readonly SharePointOnlineList: "SharePointOnlineList";
readonly Shopify: "Shopify";
readonly Square: "Square";
readonly WebTable: "WebTable";
readonly Xero: "Xero";
readonly Zoho: "Zoho";
readonly GenericContainerRegistry: "GenericContainerRegistry";
readonly Elasticsearch: "Elasticsearch";
readonly OpenAI: "OpenAI";
readonly Serp: "Serp";
readonly BingLLMSearch: "BingLLMSearch";
readonly Serverless: "Serverless";
readonly ManagedOnlineEndpoint: "ManagedOnlineEndpoint";
};
/**
* Category of the connection
*/
export type ConnectionCategory = (typeof ConnectionCategory)[keyof typeof ConnectionCategory];
export declare const ContainerType: {
readonly StorageInitializer: "StorageInitializer";
readonly InferenceServer: "InferenceServer";
};
/**
* The type of container to retrieve logs from.
*/
export type ContainerType = (typeof ContainerType)[keyof typeof ContainerType];
export declare const ContentSafetyStatus: {
readonly Enabled: "Enabled";
readonly Disabled: "Disabled";
};
/**
* [Required] Specifies the status of content safety.
*/
export type ContentSafetyStatus = (typeof ContentSafetyStatus)[keyof typeof ContentSafetyStatus];
export declare const CredentialsType: {
readonly AccountKey: "AccountKey";
readonly Certificate: "Certificate";
readonly None: "None";
readonly Sas: "Sas";
readonly ServicePrincipal: "ServicePrincipal";
};
/**
* [Required] Credential type used to authentication with storage.
*/
export type CredentialsType = (typeof CredentialsType)[keyof typeof CredentialsType];
export declare const DataCollectionMode: {
readonly Enabled: "Enabled";
readonly Disabled: "Disabled";
};
/**
* Enable or disable data collection.
*/
export type DataCollectionMode = (typeof DataCollectionMode)[keyof typeof DataCollectionMode];
export declare const DataType: {
readonly Uri_file: "uri_file";
readonly Uri_folder: "uri_folder";
readonly Mltable: "mltable";
};
/**
* [Required] Specifies the type of data.
*/
export type DataType = (typeof DataType)[keyof typeof DataType];
export declare const DatasetType: {
readonly Tabular: "tabular";
readonly File: "file";
};
/**
* Specifies dataset type.
*/
export type DatasetType = (typeof DatasetType)[keyof typeof DatasetType];
export declare const DatastoreType: {
readonly AzureBlob: "AzureBlob";
readonly AzureDataLakeGen1: "AzureDataLakeGen1";
readonly AzureDataLakeGen2: "AzureDataLakeGen2";
readonly AzureFile: "AzureFile";
readonly OneLake: "OneLake";
};
/**
* [Required] Storage type backing the datastore.
*/
export type DatastoreType = (typeof DatastoreType)[keyof typeof DatastoreType];
export declare const DatastoreTypeArm: {
readonly Blob: "blob";
readonly Adls: "adls";
readonly Adls_gen2: "adls-gen2";
readonly Dbfs: "dbfs";
readonly File: "file";
readonly Mysqldb: "mysqldb";
readonly Sqldb: "sqldb";
readonly Psqldb: "psqldb";
};
/**
* Specifies datastore type.
*/
export type DatastoreTypeArm = (typeof DatastoreTypeArm)[keyof typeof DatastoreTypeArm];
export declare const DeploymentModelVersionUpgradeOption: {
readonly OnceNewDefaultVersionAvailable: "OnceNewDefaultVersionAvailable";
readonly OnceCurrentVersionExpired: "OnceCurrentVersionExpired";
readonly NoAutoUpgrade: "NoAutoUpgrade";
};
/**
* Deployment model version upgrade option.
*/
export type DeploymentModelVersionUpgradeOption = (typeof DeploymentModelVersionUpgradeOption)[keyof typeof DeploymentModelVersionUpgradeOption];
export declare const DistributionType: {
readonly PyTorch: "PyTorch";
readonly TensorFlow: "TensorFlow";
readonly Mpi: "Mpi";
};
/**
* [Required] Specifies the type of distribution framework.
*/
export type DistributionType = (typeof DistributionType)[keyof typeof DistributionType];
export declare const DockerSpecificationType: {
readonly Build: "Build";
readonly Image: "Image";
};
/**
* [Required] Docker specification must be either Build or Image
*/
export type DockerSpecificationType = (typeof DockerSpecificationType)[keyof typeof DockerSpecificationType];
export declare const EarlyTerminationPolicyType: {
readonly Bandit: "Bandit";
readonly MedianStopping: "MedianStopping";
readonly TruncationSelection: "TruncationSelection";
};
/**
* [Required] Name of policy configuration
*/
export type EarlyTerminationPolicyType = (typeof EarlyTerminationPolicyType)[keyof typeof EarlyTerminationPolicyType];
export declare const EgressPublicNetworkAccessType: {
readonly Enabled: "Enabled";
readonly Disabled: "Disabled";
};
/**
* If Enabled, allow egress public network access. If Disabled, this will create secure egress. Default: Enabled.
*/
export type EgressPublicNetworkAccessType = (typeof EgressPublicNetworkAccessType)[keyof typeof EgressPublicNetworkAccessType];
export declare const EmailNotificationEnableType: {
readonly JobCompleted: "JobCompleted";
readonly JobFailed: "JobFailed";
readonly JobCancelled: "JobCancelled";
};
/**
* Enum to determine the email notification type.
*/
export type EmailNotificationEnableType = (typeof EmailNotificationEnableType)[keyof typeof EmailNotificationEnableType];
export declare const EncryptionStatus: {
readonly Enabled: "Enabled";
readonly Disabled: "Disabled";
};
/**
* Indicates whether or not the encryption is enabled for the workspace.
*/
export type EncryptionStatus = (typeof EncryptionStatus)[keyof typeof EncryptionStatus];
export declare const EndpointAuthMode: {
readonly AMLToken: "AMLToken";
readonly Key: "Key";
readonly AADToken: "AADToken";
};
/**
* [Required] The authentication method for invoking the endpoint (data plane operation). Use 'Key' for key-based authentication. Use 'AMLToken' for Azure Machine Learning token-based authentication. Use 'AADToken' for Microsoft Entra token-based authentication.
*/
export type EndpointAuthMode = (typeof EndpointAuthMode)[keyof typeof EndpointAuthMode];
export declare const EndpointComputeType: {
readonly Managed: "Managed";
readonly Kubernetes: "Kubernetes";
readonly AzureMLCompute: "AzureMLCompute";
};
/**
* [Required] The compute type of the endpoint.
*/
export type EndpointComputeType = (typeof EndpointComputeType)[keyof typeof EndpointComputeType];
export declare const EndpointServiceConnectionStatus: {
readonly Approved: "Approved";
readonly Pending: "Pending";
readonly Rejected: "Rejected";
readonly Disconnected: "Disconnected";
};
/**
* Connection status of the service consumer with the service provider
*/
export type EndpointServiceConnectionStatus = (typeof EndpointServiceConnectionStatus)[keyof typeof EndpointServiceConnectionStatus];
export declare const EnvironmentVariableType: {
readonly Local: "local";
};
/**
* Type of the Environment Variable. Possible values are: local - For local variable
*/
export type EnvironmentVariableType = (typeof EnvironmentVariableType)[keyof typeof EnvironmentVariableType];
export declare const FeatureAttributionMetric: {
/**
* The Normalized Discounted Cumulative Gain metric.
*/
readonly NormalizedDiscountedCumulativeGain: "NormalizedDiscountedCumulativeGain";
};
/**
* [Required] The feature attribution metric to calculate.
*/
export type FeatureAttributionMetric = (typeof FeatureAttributionMetric)[keyof typeof FeatureAttributionMetric];
export declare const FeatureDataType: {
readonly String: "String";
readonly Integer: "Integer";
readonly Long: "Long";
readonly Float: "Float";
readonly Double: "Double";
readonly Binary: "Binary";
readonly Datetime: "Datetime";
readonly Boolean: "Boolean";
};
/**
* Specifies the data type
*/
export type FeatureDataType = (typeof FeatureDataType)[keyof typeof FeatureDataType];
export declare const FeatureImportanceMode: {
/**
* Disables computing feature importance within a signal.
*/
readonly Disabled: "Disabled";
/**
* Enables computing feature importance within a signal.
*/
readonly Enabled: "Enabled";
};
/**
* The mode of operation for computing feature importance.
*/
export type FeatureImportanceMode = (typeof FeatureImportanceMode)[keyof typeof FeatureImportanceMode];
export declare const FeatureLags: {
/**
* No feature lags generated.
*/
readonly None: "None";
/**
* System auto-generates feature lags.
*/
readonly Auto: "Auto";
};
/**
* Flag for generating lags for the numeric features with 'auto' or null.
*/
export type FeatureLags = (typeof FeatureLags)[keyof typeof FeatureLags];
export declare const FeaturizationMode: {
/**
* Auto mode, system performs featurization without any custom featurization inputs.
*/
readonly Auto: "Auto";
/**
* Custom featurization.
*/
readonly Custom: "Custom";
/**
* Featurization off. 'Forecasting' task cannot use this value.
*/
readonly Off: "Off";
};
/**
* Featurization mode - User can keep the default 'Auto' mode and AutoML will take care of necessary transformation of the data in featurization phase.
* If 'Off' is selected then no featurization is done.
* If 'Custom' is selected then user can specify additional inputs to customize how featurization is done.
*/
export type FeaturizationMode = (typeof FeaturizationMode)[keyof typeof FeaturizationMode];
export declare const FirewallSku: {
readonly Standard: "Standard";
readonly Basic: "Basic";
};
/**
* Firewall Sku used for FQDN Rules
*/
export type FirewallSku = (typeof FirewallSku)[keyof typeof FirewallSku];
export declare const ForecastHorizonMode: {
/**
* Forecast horizon to be determined automatically.
*/
readonly Auto: "Auto";
/**
* Use the custom forecast horizon.
*/
readonly Custom: "Custom";
};
/**
* [Required] Set forecast horizon value selection mode.
*/
export type ForecastHorizonMode = (typeof ForecastHorizonMode)[keyof typeof ForecastHorizonMode];
export declare const ForecastingModels: {
/**
* Auto-Autoregressive Integrated Moving Average (ARIMA) model uses time-series data and statistical analysis to interpret the data and make future predictions.
* This model aims to explain data by using time series data on its past values and uses linear regression to make predictions.
*/
readonly AutoArima: "AutoArima";
/**
* Prophet is a procedure for forecasting time series data based on an additive model where non-linear trends are fit with yearly, weekly, and daily seasonality, plus holiday effects.
* It works best with time series that have strong seasonal effects and several seasons of historical data. Prophet is robust to missing data and shifts in the trend, and typically handles outliers well.
*/
readonly Prophet: "Prophet";
/**
* The Naive forecasting model makes predictions by carrying forward the latest target value for each time-series in the training data.
*/
readonly Naive: "Naive";
/**
* The Seasonal Naive forecasting model makes predictions by carrying forward the latest season of target values for each time-series in the training data.
*/
readonly SeasonalNaive: "SeasonalNaive";
/**
* The Average forecasting model makes predictions by carrying forward the average of the target values for each time-series in the training data.
*/
readonly Average: "Average";
/**
* The Seasonal Average forecasting model makes predictions by carrying forward the average value of the latest season of data for each time-series in the training data.
*/
readonly SeasonalAverage: "SeasonalAverage";
/**
* Exponential smoothing is a time series forecasting method for univariate data that can be extended to support data with a systematic trend or seasonal component.
*/
readonly ExponentialSmoothing: "ExponentialSmoothing";
/**
* An Autoregressive Integrated Moving Average with Explanatory Variable (ARIMAX) model can be viewed as a multiple regression model with one or more autoregressive (AR) terms and/or one or more moving average (MA) terms.
* This method is suitable for forecasting when data is stationary/non stationary, and multivariate with any type of data pattern, i.e., level/trend /seasonality/cyclicity.
*/
readonly Arimax: "Arimax";
/**
* TCNForecaster: Temporal Convolutional Networks Forecaster. //TODO: Ask forecasting team for brief intro.
*/
readonly TCNForecaster: "TCNForecaster";
/**
* Elastic net is a popular type of regularized linear regression that combines two popular penalties, specifically the L1 and L2 penalty functions.
*/
readonly ElasticNet: "ElasticNet";
/**
* The technique of transiting week learners into a strong learner is called Boosting. The gradient boosting algorithm process works on this theory of execution.
*/
readonly GradientBoosting: "GradientBoosting";
/**
* Decision Trees are a non-parametric supervised learning method used for both classification and regression tasks.
* The goal is to create a model that predicts the value of a target variable by learning simple decision rules inferred from the data features.
*/
readonly DecisionTree: "DecisionTree";
/**
* K-nearest neighbors (KNN) algorithm uses 'feature similarity' to predict the values of new datapoints
* which further means that the new data point will be assigned a value based on how closely it matches the points in the training set.
*/
readonly KNN: "KNN";
/**
* Lasso model fit with Least Angle Regression a.k.a. Lars. It is a Linear Model trained with an L1 prior as regularizer.
*/
readonly LassoLars: "LassoLars";
/**
* SGD: Stochastic gradient descent is an optimization algorithm often used in machine learning applications
* to find the model parameters that correspond to the best fit between predicted and actual outputs.
* It's an inexact but powerful technique.
*/
readonly SGD: "SGD";
/**
* Random forest is a supervised learning algorithm.
* The "forest" it builds, is an ensemble of decision trees, usually trained with the "bagging" method.
* The general idea of the bagging method is that a combination of learning models increases the overall result.
*/
readonly RandomForest: "RandomForest";
/**
* Extreme Trees is an ensemble machine learning algorithm that combines the predictions from many decision trees. It is related to the widely used random forest algorithm.
*/
readonly ExtremeRandomTrees: "ExtremeRandomTrees";
/**
* LightGBM is a gradient boosting framework that uses tree based learning algorithms.
*/
readonly LightGBM: "LightGBM";
/**
* XGBoostRegressor: Extreme Gradient Boosting Regressor is a supervised machine learning model using ensemble of base learners.
*/
readonly XGBoostRegressor: "XGBoostRegressor";
};
/**
* Enum for all forecasting models supported by AutoML.
*/
export type ForecastingModels = (typeof ForecastingModels)[keyof typeof ForecastingModels];
export declare const ForecastingPrimaryMetrics: {
/**
* The Spearman's rank coefficient of correlation is a non-parametric measure of rank correlation.
*/
readonly SpearmanCorrelation: "SpearmanCorrelation";
/**
* The Normalized Root Mean Squared Error (NRMSE) the RMSE facilitates the comparison between models with different scales.
*/
readonly NormalizedRootMeanSquaredError: "NormalizedRootMeanSquaredError";
/**
* The R2 score is one of the performance evaluation measures for forecasting-based machine learning models.
*/
readonly R2Score: "R2Score";
/**
* The Normalized Mean Absolute Error (NMAE) is a validation metric to compare the Mean Absolute Error (MAE) of (time) series with different scales.
*/
readonly NormalizedMeanAbsoluteError: "NormalizedMeanAbsoluteError";
};
/**
* Primary metric for forecasting task.
*/
export type ForecastingPrimaryMetrics = (typeof ForecastingPrimaryMetrics)[keyof typeof ForecastingPrimaryMetrics];
export declare const Goal: {
readonly Minimize: "Minimize";
readonly Maximize: "Maximize";
};
/**
* [Required] Defines supported metric goals for hyperparameter tuning
*/
export type Goal = (typeof Goal)[keyof typeof Goal];
export declare const Header: {
readonly All_files_have_same_headers: "all_files_have_same_headers";
readonly Only_first_file_has_headers: "only_first_file_has_headers";
readonly No_headers: "no_headers";
readonly Combine_all_files_headers: "combine_all_files_headers";
};
/**
* Header type.
*/
export type Header = (typeof Header)[keyof typeof Header];
export declare const IdentityConfigurationType: {
readonly Managed: "Managed";
readonly AMLToken: "AMLToken";
readonly UserIdentity: "UserIdentity";
};
/**
* [Required] Specifies the type of identity framework.
*/
export type IdentityConfigurationType = (typeof IdentityConfigurationType)[keyof typeof IdentityConfigurationType];
export declare const ImageAnnotationType: {
readonly Classification: "Classification";
readonly BoundingBox: "BoundingBox";
readonly InstanceSegmentation: "InstanceSegmentation";
};
/**
* Annotation type of image labeling job.
*/
export type ImageAnnotationType = (typeof ImageAnnotationType)[keyof typeof ImageAnnotationType];
export declare const ImageType: {
readonly Docker: "docker";
readonly Azureml: "azureml";
};
/**
* Type of the image. Possible values are: docker - For docker images. azureml - For AzureML images
*/
export type ImageType = (typeof ImageType)[keyof typeof ImageType];
export declare const IncrementalDataRefresh: {
readonly Enabled: "Enabled";
readonly Disabled: "Disabled";
};
/**
* Indicates whether to enable incremental data refresh.
*/
export type IncrementalDataRefresh = (typeof IncrementalDataRefresh)[keyof typeof IncrementalDataRefresh];
export declare const InputDeliveryMode: {
readonly ReadOnlyMount: "ReadOnlyMount";
readonly ReadWriteMount: "ReadWriteMount";
readonly Download: "Download";
readonly Direct: "Direct";
readonly EvalMount: "EvalMount";
readonly EvalDownload: "EvalDownload";
};
/**
* Input Asset Delivery Mode.
*/
export type InputDeliveryMode = (typeof InputDeliveryMode)[keyof typeof InputDeliveryMode];
export declare const InstanceSegmentationPrimaryMetrics: {
/**
* Mean Average Precision (MAP) is the average of AP (Average Precision).
* AP is calculated for each class and averaged to get the MAP.
*/
readonly MeanAveragePrecision: "MeanAveragePrecision";
};
/**
* Primary metric to optimize for this task.
*/
export type InstanceSegmentationPrimaryMetrics = (typeof InstanceSegmentationPrimaryMetrics)[keyof typeof InstanceSegmentationPrimaryMetrics];
export declare const IsolationMode: {
readonly Disabled: "Disabled";
readonly AllowInternetOutbound: "AllowInternetOutbound";
readonly AllowOnlyApprovedOutbound: "AllowOnlyApprovedOutbound";
};
/**
* Isolation mode for the managed network of a machine learning workspace.
*/
export type IsolationMode = (typeof IsolationMode)[keyof typeof IsolationMode];
export declare const JobInputType: {
readonly Literal: "literal";
readonly Uri_file: "uri_file";
readonly Uri_folder: "uri_folder";
readonly Mltable: "mltable";
readonly Custom_model: "custom_model";
readonly Mlflow_model: "mlflow_model";
readonly Triton_model: "triton_model";
};
/**
* [Required] Specifies the type of job.
*/
export type JobInputType = (typeof JobInputType)[keyof typeof JobInputType];
export declare const JobLimitsType: {
readonly Command: "Command";
readonly Sweep: "Sweep";
};
/**
* [Required] JobLimit type.
*/
export type JobLimitsType = (typeof JobLimitsType)[keyof typeof JobLimitsType];
export declare const JobOutputType: {
readonly Uri_file: "uri_file";
readonly Uri_folder: "uri_folder";
readonly Mltable: "mltable";
readonly Custom_model: "custom_model";
readonly Mlflow_model: "mlflow_model";
readonly Triton_model: "triton_model";
};
/**
* [Required] Specifies the type of job.
*/
export type JobOutputType = (typeof JobOutputType)[keyof typeof JobOutputType];
export declare const JobTier: {
readonly Null: "Null";
readonly Spot: "Spot";
readonly Basic: "Basic";
readonly Standard: "Standard";
readonly Premium: "Premium";
};
/**
* Controls the compute job tier
*/
export type JobTier = (typeof JobTier)[keyof typeof JobTier];
export declare const JobType: {
readonly AutoML: "AutoML";
readonly Command: "Command";
readonly Sweep: "Sweep";
readonly Pipeline: "Pipeline";
readonly Spark: "Spark";
};
/**
* [Required] Specifies the type of job.
*/
export type JobType = (typeof JobType)[keyof typeof JobType];
export declare const LearningRateScheduler: {
/**
* No learning rate scheduler selected.
*/
readonly None: "None";
/**
* Cosine Annealing With Warmup.
*/
readonly WarmupCosine: "WarmupCosine";
/**
* Step learning rate scheduler.
*/
readonly Step: "Step";
};
/**
* Type of learning rate scheduler. Must be 'warmup_cosine' or 'step'.
*/
export type LearningRateScheduler = (typeof LearningRateScheduler)[keyof typeof LearningRateScheduler];
export declare const LinkedServiceLinkType: {
readonly Synapse: "Synapse";
};
/**
* Type of the link target.
*/
export type LinkedServiceLinkType = (typeof LinkedServiceLinkType)[keyof typeof LinkedServiceLinkType];
export declare const LoadBalancerType: {
readonly PublicIp: "PublicIp";
readonly InternalLoadBalancer: "InternalLoadBalancer";
};
/**
* Load Balancer Type
*/
export type LoadBalancerType = (typeof LoadBalancerType)[keyof typeof LoadBalancerType];
export declare const LogVerbosity: {
/**
* No logs emitted.
*/
readonly NotSet: "NotSet";
/**
* Debug and above log statements logged.
*/
readonly Debug: "Debug";
/**
* Info and above log statements logged.
*/
readonly Info: "Info";
/**
* Warning and above log statements logged.
*/
readonly Warning: "Warning";
/**
* Error and above log statements logged.
*/
readonly Error: "Error";
/**
* Only critical statements logged.
*/
readonly Critical: "Critical";
};
/**
* Log verbosity for the job.
*/
export type LogVerbosity = (typeof LogVerbosity)[keyof typeof LogVerbosity];
export declare const MLAssistConfigurationType: {
readonly Enabled: "Enabled";
readonly Disabled: "Disabled";
};
/**
* [Required] Indicates whether MLAssist feature is enabled.
*/
export type MLAssistConfigurationType = (typeof MLAssistConfigurationType)[keyof typeof MLAssistConfigurationType];
export declare const ManagedNetworkKind: {
readonly V1: "V1";
readonly V2: "V2";
};
/**
* The Kind of the managed network. Users can switch from V1 to V2 for granular access controls, but cannot switch back to V1 once V2 is enabled.
*/
export type ManagedNetworkKind = (typeof ManagedNetworkKind)[keyof typeof ManagedNetworkKind];
export declare const ManagedNetworkStatus: {
readonly Inactive: "Inactive";
readonly Active: "Active";
};
/**
* Status for the managed network of a machine learning workspace.
*/
export type ManagedNetworkStatus = (typeof ManagedNetworkStatus)[keyof typeof ManagedNetworkStatus];
export declare const ManagedServiceIdentityType: {
readonly None: "None";
readonly SystemAssigned: "SystemAssigned";
readonly UserAssigned: "UserAssigned";
readonly SystemAssigned_UserAssigned: "SystemAssigned,UserAssigned";
};
/**
* Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
*/
export type ManagedServiceIdentityType = (typeof ManagedServiceIdentityType)[keyof typeof ManagedServiceIdentityType];
export declare const MaterializationStoreType: {
readonly None: "None";
readonly Online: "Online";
readonly Offline: "Offline";
readonly OnlineAndOffline: "OnlineAndOffline";
};
/**
* Specifies the stores to which materialization should happen
*/
export type MaterializationStoreType = (typeof MaterializationStoreType)[keyof typeof MaterializationStoreType];
export declare const MediaType: {
readonly Image: "Image";
readonly Text: "Text";
};
/**
* [Required] Media type of the job.
*/
export type MediaType = (typeof MediaType)[keyof typeof MediaType];
export declare const ModelSize: {
/**
* No value selected.
*/
readonly None: "None";
/**
* Small size.
*/
readonly Small: "Small";
/**
* Medium size.
*/
readonly Medium: "Medium";
/**
* Large size.
*/
readonly Large: "Large";
/**
* Extra large size.
*/
readonly ExtraLarge: "ExtraLarge";
};
/**
* Model size. Must be 'small', 'medium', 'large', or 'xlarge'.
* Note: training run may get into CUDA OOM if the model size is too big.
* Note: This settings is only supported for the 'yolov5' algorithm.
*/
export type ModelSize = (typeof ModelSize)[keyof typeof ModelSize];
export declare const ModelTaskType: {
readonly Classification: "Classification";
readonly Regression: "Regression";
};
/**
* [Required] The machine learning task type of the monitored model.
*/
export type ModelTaskType = (typeof ModelTaskType)[keyof typeof ModelTaskType];
export declare const MonitorComputeIdentityType: {
/**
* Authenticates through user's AML token.
*/
readonly AmlToken: "AmlToken";
/**
* Authenticates through a user-provided managed identity.
*/
readonly ManagedIdentity: "ManagedIdentity";
};
/**
* [Required] Specifies the type of identity to use within the monitoring jobs.
*/
export type MonitorComputeIdentityType = (typeof MonitorComputeIdentityType)[keyof typeof MonitorComputeIdentityType];
export declare const MonitorComputeType: {
/**
* Serverless Spark compute.
*/
readonly ServerlessSpark: "ServerlessSpark";
};
/**
* [Required] Specifies the type of signal to monitor.
*/
export type MonitorComputeType = (typeof MonitorComputeType)[keyof typeof MonitorComputeType];
export declare const MonitoringFeatureDataType: {
/**
* Used for features of numerical data type.
*/
readonly Numerical: "Numerical";
/**
* Used for features of categorical data type.
*/
readonly Categorical: "Categorical";
};
/**
* [Required] Specifies the data type of the metric threshold.
*/
export type MonitoringFeatureDataType = (typeof MonitoringFeatureDataType)[keyof typeof MonitoringFeatureDataType];
export declare const MonitoringFeatureFilterType: {
/**
* Includes all features.
*/
readonly AllFeatures: "AllFeatures";
/**
* Only includes the top contributing features, measured by feature attribution.
*/
readonly TopNByAttribution: "TopNByAttribution";
/**
* Includes a user-defined subset of features.
*/
readonly FeatureSubset: "FeatureSubset";
};
/**
* [Required] Specifies the feature filter to leverage when selecting features to calculate metrics over.
*/
export type MonitoringFeatureFilterType = (typeof MonitoringFeatureFilterType)[keyof typeof MonitoringFeatureFilterType];
export declare const MonitoringInputDataType: {
/**
* An input data with a fixed window size.
*/
readonly Static: "Static";
/**
* An input data which rolls relatively to the monitor's current run time.
*/
readonly Rolling: "Rolling";
/**
* An input data with tabular format which doesn't require preprocessing.
*/
readonly Fixed: "Fixed";
};
/**
* [Required] Specifies the type of signal to monitor.
*/
export type MonitoringInputDataType = (typeof MonitoringInputDataType)[keyof typeof MonitoringInputDataType];
export declare const MonitoringNotificationType: {
/**
* Enables email notifications through AML notifications.
*/
readonly AmlNotification: "AmlNotification";
};
export type MonitoringNotificationType = (typeof MonitoringNotificationType)[keyof typeof MonitoringNotificationType];
export declare const MonitoringSignalType: {
/**
* Tracks model input data distribution change, comparing against training data or past production data.
*/
readonly DataDrift: "DataDrift";
/**
* Tracks prediction result data distribution change, comparing against validation/test label data or past production data.
*/
readonly PredictionDrift: "PredictionDrift";
/**
* Tracks model input data integrity.
*/
readonly DataQuality: "DataQuality";
/**
* Tracks feature importance change in production, comparing against feature importance at training time.
*/
readonly FeatureAttributionDrift: "FeatureAttributionDrift";
/**
* Tracks a custom signal provided by users.
*/
readonly Custom: "Custom";
};
/**
* [Required] Specifies the type of signal to monitor.
*/
export type MonitoringSignalType = (typeof MonitoringSignalType)[keyof typeof MonitoringSignalType];
export declare const MultiSelect: {
readonly Enabled: "Enabled";
readonly Disabled: "Disabled";
};
/**
* Indicates whether it is allowed to select multiple classes in this category.
*/
export type MultiSelect = (typeof MultiSelect)[keyof typeof MultiSelect];
export declare const NCrossValidationsMode: {
/**
* Determine N-Cross validations value automatically. Supported only for 'Forecasting' AutoML task.
*/
readonly Auto: "Auto";
/**
* Use custom N-Cross validations value.
*/
readonly Custom: "Custom";
};
/**
* [Required] Mode for determining N-Cross validatio