diff --git a/google/cloud/bigquery/enums.py b/google/cloud/bigquery/enums.py index 3247372e3..eb33e4276 100644 --- a/google/cloud/bigquery/enums.py +++ b/google/cloud/bigquery/enums.py @@ -33,6 +33,7 @@ "DATETIME", "GEOGRAPHY", "NUMERIC", + "BIGNUMERIC", ) ) @@ -81,6 +82,7 @@ class SqlTypeNames(str, enum.Enum): FLOAT = "FLOAT" FLOAT64 = "FLOAT" NUMERIC = "NUMERIC" + BIGNUMERIC = "BIGNUMERIC" BOOLEAN = "BOOLEAN" BOOL = "BOOLEAN" GEOGRAPHY = "GEOGRAPHY" # NOTE: not available in legacy types diff --git a/google/cloud/bigquery_v2/__init__.py b/google/cloud/bigquery_v2/__init__.py index c1989c3b0..ebcc26bef 100644 --- a/google/cloud/bigquery_v2/__init__.py +++ b/google/cloud/bigquery_v2/__init__.py @@ -27,6 +27,7 @@ from .types.standard_sql import StandardSqlDataType from .types.standard_sql import StandardSqlField from .types.standard_sql import StandardSqlStructType +from .types.table_reference import TableReference __all__ = ( @@ -41,4 +42,5 @@ "StandardSqlDataType", "StandardSqlField", "StandardSqlStructType", + "TableReference", ) diff --git a/google/cloud/bigquery_v2/proto/encryption_config.proto b/google/cloud/bigquery_v2/proto/encryption_config.proto index 54445f0fa..1c0512a17 100644 --- a/google/cloud/bigquery_v2/proto/encryption_config.proto +++ b/google/cloud/bigquery_v2/proto/encryption_config.proto @@ -1,4 +1,4 @@ -// Copyright 2019 Google LLC. +// Copyright 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -11,7 +11,6 @@ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. -// syntax = "proto3"; diff --git a/google/cloud/bigquery_v2/proto/model.proto b/google/cloud/bigquery_v2/proto/model.proto index 13d980774..2d400dddd 100644 --- a/google/cloud/bigquery_v2/proto/model.proto +++ b/google/cloud/bigquery_v2/proto/model.proto @@ -1,4 +1,4 @@ -// Copyright 2019 Google LLC. +// Copyright 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -11,7 +11,6 @@ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. -// syntax = "proto3"; @@ -22,6 +21,7 @@ import "google/api/field_behavior.proto"; import "google/cloud/bigquery/v2/encryption_config.proto"; import "google/cloud/bigquery/v2/model_reference.proto"; import "google/cloud/bigquery/v2/standard_sql.proto"; +import "google/cloud/bigquery/v2/table_reference.proto"; import "google/protobuf/empty.proto"; import "google/protobuf/timestamp.proto"; import "google/protobuf/wrappers.proto"; @@ -62,6 +62,32 @@ service ModelService { } message Model { + message SeasonalPeriod { + enum SeasonalPeriodType { + SEASONAL_PERIOD_TYPE_UNSPECIFIED = 0; + + // No seasonality + NO_SEASONALITY = 1; + + // Daily period, 24 hours. + DAILY = 2; + + // Weekly period, 7 days. + WEEKLY = 3; + + // Monthly period, 30 days or irregular. + MONTHLY = 4; + + // Quarterly period, 90 days or irregular. + QUARTERLY = 5; + + // Yearly period, 365 days or irregular. + YEARLY = 6; + } + + + } + message KmeansEnums { // Indicates the method used to initialize the centroids for KMeans // clustering algorithm. @@ -74,6 +100,9 @@ message Model { // Initializes the centroids using data specified in // kmeans_initialization_column. CUSTOM = 2; + + // Initializes with kmeans++. + KMEANS_PLUS_PLUS = 3; } @@ -280,6 +309,73 @@ message Model { repeated Cluster clusters = 3; } + // Evaluation metrics used by weighted-ALS models specified by + // feedback_type=implicit. + message RankingMetrics { + // Calculates a precision per user for all the items by ranking them and + // then averages all the precisions across all the users. + google.protobuf.DoubleValue mean_average_precision = 1; + + // Similar to the mean squared error computed in regression and explicit + // recommendation models except instead of computing the rating directly, + // the output from evaluate is computed against a preference which is 1 or 0 + // depending on if the rating exists or not. + google.protobuf.DoubleValue mean_squared_error = 2; + + // A metric to determine the goodness of a ranking calculated from the + // predicted confidence by comparing it to an ideal rank measured by the + // original ratings. + google.protobuf.DoubleValue normalized_discounted_cumulative_gain = 3; + + // Determines the goodness of a ranking by computing the percentile rank + // from the predicted confidence and dividing it by the original rank. + google.protobuf.DoubleValue average_rank = 4; + } + + // Model evaluation metrics for ARIMA forecasting models. + message ArimaForecastingMetrics { + // Model evaluation metrics for a single ARIMA forecasting model. + message ArimaSingleModelForecastingMetrics { + // Non-seasonal order. + ArimaOrder non_seasonal_order = 1; + + // Arima fitting metrics. + ArimaFittingMetrics arima_fitting_metrics = 2; + + // Is arima model fitted with drift or not. It is always false when d + // is not 1. + bool has_drift = 3; + + // The id to indicate different time series. + string time_series_id = 4; + + // Seasonal periods. Repeated because multiple periods are supported + // for one time series. + repeated SeasonalPeriod.SeasonalPeriodType seasonal_periods = 5; + } + + // Non-seasonal order. + repeated ArimaOrder non_seasonal_order = 1; + + // Arima model fitting metrics. + repeated ArimaFittingMetrics arima_fitting_metrics = 2; + + // Seasonal periods. Repeated because multiple periods are supported for one + // time series. + repeated SeasonalPeriod.SeasonalPeriodType seasonal_periods = 3; + + // Whether Arima model fitted with drift or not. It is always false when d + // is not 1. + repeated bool has_drift = 4; + + // Id to differentiate different time series for the large-scale case. + repeated string time_series_id = 5; + + // Repeated as there can be many metric sets (one for each model) in + // auto-arima and the large-scale case. + repeated ArimaSingleModelForecastingMetrics arima_single_model_forecasting_metrics = 6; + } + // Evaluation metrics of a model. These are either computed on all training // data or just the eval data based on whether eval data was used during // training. These are not present for imported models. @@ -297,7 +393,71 @@ message Model { // Populated for clustering models. ClusteringMetrics clustering_metrics = 4; + + // Populated for implicit feedback type matrix factorization models. + RankingMetrics ranking_metrics = 5; + + // Populated for ARIMA models. + ArimaForecastingMetrics arima_forecasting_metrics = 6; + } + } + + // Data split result. This contains references to the training and evaluation + // data tables that were used to train the model. + message DataSplitResult { + // Table reference of the training data after split. + TableReference training_table = 1; + + // Table reference of the evaluation data after split. + TableReference evaluation_table = 2; + } + + // Arima order, can be used for both non-seasonal and seasonal parts. + message ArimaOrder { + // Order of the autoregressive part. + int64 p = 1; + + // Order of the differencing part. + int64 d = 2; + + // Order of the moving-average part. + int64 q = 3; + } + + // ARIMA model fitting metrics. + message ArimaFittingMetrics { + // Log-likelihood. + double log_likelihood = 1; + + // AIC. + double aic = 2; + + // Variance. + double variance = 3; + } + + // Global explanations containing the top most important features + // after training. + message GlobalExplanation { + // Explanation for a single feature. + message Explanation { + // Full name of the feature. For non-numerical features, will be + // formatted like .. Overall size of + // feature name will always be truncated to first 120 characters. + string feature_name = 1; + + // Attribution of feature. + google.protobuf.DoubleValue attribution = 2; } + + // A list of the top global explanations. Sorted by absolute value of + // attribution in descending order. + repeated Explanation explanations = 1; + + // Class label for this set of global explanations. Will be empty/null for + // binary logistic and linear regression models. Sorted alphabetically in + // descending order. + string class_label = 2; } // Information about a single training query run for the model. @@ -367,6 +527,12 @@ message Model { // training data. Only applicable for classification models. map label_class_weights = 17; + // User column specified for matrix factorization models. + string user_column = 18; + + // Item column specified for matrix factorization models. + string item_column = 19; + // Distance type for clustering models. DistanceType distance_type = 20; @@ -380,12 +546,83 @@ message Model { // Optimization strategy for training linear regression models. OptimizationStrategy optimization_strategy = 23; + // Hidden units for dnn models. + repeated int64 hidden_units = 24; + + // Batch size for dnn models. + int64 batch_size = 25; + + // Dropout probability for dnn models. + google.protobuf.DoubleValue dropout = 26; + + // Maximum depth of a tree for boosted tree models. + int64 max_tree_depth = 27; + + // Subsample fraction of the training data to grow tree to prevent + // overfitting for boosted tree models. + double subsample = 28; + + // Minimum split loss for boosted tree models. + google.protobuf.DoubleValue min_split_loss = 29; + + // Num factors specified for matrix factorization models. + int64 num_factors = 30; + + // Feedback type that specifies which algorithm to run for matrix + // factorization. + FeedbackType feedback_type = 31; + + // Hyperparameter for matrix factoration when implicit feedback type is + // specified. + google.protobuf.DoubleValue wals_alpha = 32; + // The method used to initialize the centroids for kmeans algorithm. KmeansEnums.KmeansInitializationMethod kmeans_initialization_method = 33; // The column used to provide the initial centroids for kmeans algorithm // when kmeans_initialization_method is CUSTOM. string kmeans_initialization_column = 34; + + // Column to be designated as time series timestamp for ARIMA model. + string time_series_timestamp_column = 35; + + // Column to be designated as time series data for ARIMA model. + string time_series_data_column = 36; + + // Whether to enable auto ARIMA or not. + bool auto_arima = 37; + + // A specification of the non-seasonal part of the ARIMA model: the three + // components (p, d, q) are the AR order, the degree of differencing, and + // the MA order. + ArimaOrder non_seasonal_order = 38; + + // The data frequency of a time series. + DataFrequency data_frequency = 39; + + // Include drift when fitting an ARIMA model. + bool include_drift = 41; + + // The geographical region based on which the holidays are considered in + // time series modeling. If a valid value is specified, then holiday + // effects modeling is enabled. + HolidayRegion holiday_region = 42; + + // The id column that will be used to indicate different time series to + // forecast in parallel. + string time_series_id_column = 43; + + // The number of periods ahead that need to be forecasted. + int64 horizon = 44; + + // Whether to preserve the input structs in output feature names. + // Suppose there is a struct A with field b. + // When false (default), the output feature name is A_b. + // When true, the output feature name is A.b. + bool preserve_input_structs = 45; + + // The max value of non-seasonal p and q. + int64 auto_arima_max_order = 46; } // Information about a single iteration of the training run. @@ -403,6 +640,53 @@ message Model { google.protobuf.Int64Value cluster_size = 3; } + // (Auto-)arima fitting result. Wrap everything in ArimaResult for easier + // refactoring if we want to use model-specific iteration results. + message ArimaResult { + // Arima coefficients. + message ArimaCoefficients { + // Auto-regressive coefficients, an array of double. + repeated double auto_regressive_coefficients = 1; + + // Moving-average coefficients, an array of double. + repeated double moving_average_coefficients = 2; + + // Intercept coefficient, just a double not an array. + double intercept_coefficient = 3; + } + + // Arima model information. + message ArimaModelInfo { + // Non-seasonal order. + ArimaOrder non_seasonal_order = 1; + + // Arima coefficients. + ArimaCoefficients arima_coefficients = 2; + + // Arima fitting metrics. + ArimaFittingMetrics arima_fitting_metrics = 3; + + // Whether Arima model fitted with drift or not. It is always false + // when d is not 1. + bool has_drift = 4; + + // The id to indicate different time series. + string time_series_id = 5; + + // Seasonal periods. Repeated because multiple periods are supported + // for one time series. + repeated SeasonalPeriod.SeasonalPeriodType seasonal_periods = 6; + } + + // This message is repeated because there are multiple arima models + // fitted in auto-arima. For non-auto-arima model, its size is one. + repeated ArimaModelInfo arima_model_info = 1; + + // Seasonal periods. Repeated because multiple periods are supported for + // one time series. + repeated SeasonalPeriod.SeasonalPeriodType seasonal_periods = 2; + } + // Index of the iteration, 0 based. google.protobuf.Int32Value index = 1; @@ -420,6 +704,8 @@ message Model { // Information about top clusters for clustering models. repeated ClusterInfo cluster_infos = 8; + + ArimaResult arima_result = 9; } // Options that were used for this training run, includes @@ -435,6 +721,15 @@ message Model { // The evaluation metrics over training/eval data that were computed at the // end of training. EvaluationMetrics evaluation_metrics = 7; + + // Data split result of the training run. Only set when the input data is + // actually split. + DataSplitResult data_split_result = 9; + + // Global explanations for important features of the model. For multi-class + // models, there is one entry for each label class. For other models, there + // is only one entry in the list. + repeated GlobalExplanation global_explanations = 10; } // Indicates the type of the Model. @@ -450,8 +745,32 @@ message Model { // K-means clustering model. KMEANS = 3; + // Matrix factorization model. + MATRIX_FACTORIZATION = 4; + + // [Beta] DNN classifier model. + DNN_CLASSIFIER = 5; + // [Beta] An imported TensorFlow model. TENSORFLOW = 6; + + // [Beta] DNN regressor model. + DNN_REGRESSOR = 7; + + // [Beta] Boosted tree regressor model. + BOOSTED_TREE_REGRESSOR = 9; + + // [Beta] Boosted tree classifier model. + BOOSTED_TREE_CLASSIFIER = 10; + + // [Beta] ARIMA model. + ARIMA = 11; + + // [Beta] AutoML Tables regression model. + AUTOML_REGRESSOR = 12; + + // [Beta] AutoML Tables classification model. + AUTOML_CLASSIFIER = 13; } // Loss metric to evaluate model training performance. @@ -497,6 +816,243 @@ message Model { AUTO_SPLIT = 5; } + // Type of supported data frequency for time series forecasting models. + enum DataFrequency { + DATA_FREQUENCY_UNSPECIFIED = 0; + + // Automatically inferred from timestamps. + AUTO_FREQUENCY = 1; + + // Yearly data. + YEARLY = 2; + + // Quarterly data. + QUARTERLY = 3; + + // Monthly data. + MONTHLY = 4; + + // Weekly data. + WEEKLY = 5; + + // Daily data. + DAILY = 6; + + // Hourly data. + HOURLY = 7; + } + + // Type of supported holiday regions for time series forecasting models. + enum HolidayRegion { + // Holiday region unspecified. + HOLIDAY_REGION_UNSPECIFIED = 0; + + // Global. + GLOBAL = 1; + + // North America. + NA = 2; + + // Japan and Asia Pacific: Korea, Greater China, India, Australia, and New + // Zealand. + JAPAC = 3; + + // Europe, the Middle East and Africa. + EMEA = 4; + + // Latin America and the Caribbean. + LAC = 5; + + // United Arab Emirates + AE = 6; + + // Argentina + AR = 7; + + // Austria + AT = 8; + + // Australia + AU = 9; + + // Belgium + BE = 10; + + // Brazil + BR = 11; + + // Canada + CA = 12; + + // Switzerland + CH = 13; + + // Chile + CL = 14; + + // China + CN = 15; + + // Colombia + CO = 16; + + // Czechoslovakia + CS = 17; + + // Czech Republic + CZ = 18; + + // Germany + DE = 19; + + // Denmark + DK = 20; + + // Algeria + DZ = 21; + + // Ecuador + EC = 22; + + // Estonia + EE = 23; + + // Egypt + EG = 24; + + // Spain + ES = 25; + + // Finland + FI = 26; + + // France + FR = 27; + + // Great Britain (United Kingdom) + GB = 28; + + // Greece + GR = 29; + + // Hong Kong + HK = 30; + + // Hungary + HU = 31; + + // Indonesia + ID = 32; + + // Ireland + IE = 33; + + // Israel + IL = 34; + + // India + IN = 35; + + // Iran + IR = 36; + + // Italy + IT = 37; + + // Japan + JP = 38; + + // Korea (South) + KR = 39; + + // Latvia + LV = 40; + + // Morocco + MA = 41; + + // Mexico + MX = 42; + + // Malaysia + MY = 43; + + // Nigeria + NG = 44; + + // Netherlands + NL = 45; + + // Norway + NO = 46; + + // New Zealand + NZ = 47; + + // Peru + PE = 48; + + // Philippines + PH = 49; + + // Pakistan + PK = 50; + + // Poland + PL = 51; + + // Portugal + PT = 52; + + // Romania + RO = 53; + + // Serbia + RS = 54; + + // Russian Federation + RU = 55; + + // Saudi Arabia + SA = 56; + + // Sweden + SE = 57; + + // Singapore + SG = 58; + + // Slovenia + SI = 59; + + // Slovakia + SK = 60; + + // Thailand + TH = 61; + + // Turkey + TR = 62; + + // Taiwan + TW = 63; + + // Ukraine + UA = 64; + + // United States + US = 65; + + // Venezuela + VE = 66; + + // Viet Nam + VN = 67; + + // South Africa + ZA = 68; + } + // Indicates the learning rate optimization strategy to use. enum LearnRateStrategy { LEARN_RATE_STRATEGY_UNSPECIFIED = 0; @@ -519,6 +1075,17 @@ message Model { NORMAL_EQUATION = 2; } + // Indicates the training algorithm to use for matrix factorization models. + enum FeedbackType { + FEEDBACK_TYPE_UNSPECIFIED = 0; + + // Use weighted-als for implicit feedback problems. + IMPLICIT = 1; + + // Use nonweighted-als for explicit feedback problems. + EXPLICIT = 2; + } + // Output only. A hash of this resource. string etag = 1 [(google.api.field_behavior) = OUTPUT_ONLY]; @@ -558,8 +1125,9 @@ message Model { // Custom encryption configuration (e.g., Cloud KMS keys). This shows the // encryption configuration of the model data while stored in BigQuery - // storage. - google.cloud.bigquery.v2.EncryptionConfiguration encryption_configuration = 17; + // storage. This field can be used with PatchModel to update encryption key + // for an already encrypted model. + EncryptionConfiguration encryption_configuration = 17; // Output only. Type of the model resource. ModelType model_type = 7 [(google.api.field_behavior) = OUTPUT_ONLY]; diff --git a/google/cloud/bigquery_v2/proto/model_reference.proto b/google/cloud/bigquery_v2/proto/model_reference.proto index fadd17514..c3d1a49a8 100644 --- a/google/cloud/bigquery_v2/proto/model_reference.proto +++ b/google/cloud/bigquery_v2/proto/model_reference.proto @@ -1,4 +1,4 @@ -// Copyright 2019 Google LLC. +// Copyright 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -11,7 +11,6 @@ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. -// syntax = "proto3"; diff --git a/google/cloud/bigquery_v2/proto/standard_sql.proto b/google/cloud/bigquery_v2/proto/standard_sql.proto index ff69dfc4e..1514eccbb 100644 --- a/google/cloud/bigquery_v2/proto/standard_sql.proto +++ b/google/cloud/bigquery_v2/proto/standard_sql.proto @@ -1,4 +1,4 @@ -// Copyright 2019 Google LLC. +// Copyright 2020 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -11,7 +11,6 @@ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. -// syntax = "proto3"; @@ -73,6 +72,9 @@ message StandardSqlDataType { // Encoded as a decimal string. NUMERIC = 23; + // Encoded as a decimal string. + BIGNUMERIC = 24; + // Encoded as a list with types matching Type.array_type. ARRAY = 16; diff --git a/google/cloud/bigquery_v2/proto/table_reference.proto b/google/cloud/bigquery_v2/proto/table_reference.proto new file mode 100644 index 000000000..ba02f80c4 --- /dev/null +++ b/google/cloud/bigquery_v2/proto/table_reference.proto @@ -0,0 +1,39 @@ +// Copyright 2020 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package google.cloud.bigquery.v2; + +import "google/api/field_behavior.proto"; +import "google/api/annotations.proto"; + +option go_package = "google.golang.org/genproto/googleapis/cloud/bigquery/v2;bigquery"; +option java_outer_classname = "TableReferenceProto"; +option java_package = "com.google.cloud.bigquery.v2"; + +message TableReference { + // Required. The ID of the project containing this table. + string project_id = 1 [(google.api.field_behavior) = REQUIRED]; + + // Required. The ID of the dataset containing this table. + string dataset_id = 2 [(google.api.field_behavior) = REQUIRED]; + + // Required. The ID of the table. The ID must contain only + // letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum + // length is 1,024 characters. Certain operations allow + // suffixing of the table ID with a partition decorator, such as + // `sample_table$20190123`. + string table_id = 3 [(google.api.field_behavior) = REQUIRED]; +} diff --git a/google/cloud/bigquery_v2/types/__init__.py b/google/cloud/bigquery_v2/types/__init__.py index a8839c74e..1e354641a 100644 --- a/google/cloud/bigquery_v2/types/__init__.py +++ b/google/cloud/bigquery_v2/types/__init__.py @@ -22,6 +22,7 @@ StandardSqlField, StandardSqlStructType, ) +from .table_reference import TableReference from .model import ( Model, GetModelRequest, @@ -38,6 +39,7 @@ "StandardSqlDataType", "StandardSqlField", "StandardSqlStructType", + "TableReference", "Model", "GetModelRequest", "PatchModelRequest", diff --git a/google/cloud/bigquery_v2/types/model.py b/google/cloud/bigquery_v2/types/model.py index a00720d48..3a7bbf43b 100644 --- a/google/cloud/bigquery_v2/types/model.py +++ b/google/cloud/bigquery_v2/types/model.py @@ -21,6 +21,7 @@ from google.cloud.bigquery_v2.types import encryption_config from google.cloud.bigquery_v2.types import model_reference as gcb_model_reference from google.cloud.bigquery_v2.types import standard_sql +from google.cloud.bigquery_v2.types import table_reference from google.protobuf import timestamp_pb2 as timestamp # type: ignore from google.protobuf import wrappers_pb2 as wrappers # type: ignore @@ -84,7 +85,9 @@ class Model(proto.Message): Custom encryption configuration (e.g., Cloud KMS keys). This shows the encryption configuration of the model data while stored in - BigQuery storage. + BigQuery storage. This field can be used with + PatchModel to update encryption key for an + already encrypted model. model_type (~.gcb_model.Model.ModelType): Output only. Type of the model resource. training_runs (Sequence[~.gcb_model.Model.TrainingRun]): @@ -105,7 +108,15 @@ class ModelType(proto.Enum): LINEAR_REGRESSION = 1 LOGISTIC_REGRESSION = 2 KMEANS = 3 + MATRIX_FACTORIZATION = 4 + DNN_CLASSIFIER = 5 TENSORFLOW = 6 + DNN_REGRESSOR = 7 + BOOSTED_TREE_REGRESSOR = 9 + BOOSTED_TREE_CLASSIFIER = 10 + ARIMA = 11 + AUTOML_REGRESSOR = 12 + AUTOML_CLASSIFIER = 13 class LossType(proto.Enum): r"""Loss metric to evaluate model training performance.""" @@ -132,6 +143,93 @@ class DataSplitMethod(proto.Enum): NO_SPLIT = 4 AUTO_SPLIT = 5 + class DataFrequency(proto.Enum): + r"""Type of supported data frequency for time series forecasting + models. + """ + DATA_FREQUENCY_UNSPECIFIED = 0 + AUTO_FREQUENCY = 1 + YEARLY = 2 + QUARTERLY = 3 + MONTHLY = 4 + WEEKLY = 5 + DAILY = 6 + HOURLY = 7 + + class HolidayRegion(proto.Enum): + r"""Type of supported holiday regions for time series forecasting + models. + """ + HOLIDAY_REGION_UNSPECIFIED = 0 + GLOBAL = 1 + NA = 2 + JAPAC = 3 + EMEA = 4 + LAC = 5 + AE = 6 + AR = 7 + AT = 8 + AU = 9 + BE = 10 + BR = 11 + CA = 12 + CH = 13 + CL = 14 + CN = 15 + CO = 16 + CS = 17 + CZ = 18 + DE = 19 + DK = 20 + DZ = 21 + EC = 22 + EE = 23 + EG = 24 + ES = 25 + FI = 26 + FR = 27 + GB = 28 + GR = 29 + HK = 30 + HU = 31 + ID = 32 + IE = 33 + IL = 34 + IN = 35 + IR = 36 + IT = 37 + JP = 38 + KR = 39 + LV = 40 + MA = 41 + MX = 42 + MY = 43 + NG = 44 + NL = 45 + NO = 46 + NZ = 47 + PE = 48 + PH = 49 + PK = 50 + PL = 51 + PT = 52 + RO = 53 + RS = 54 + RU = 55 + SA = 56 + SE = 57 + SG = 58 + SI = 59 + SK = 60 + TH = 61 + TR = 62 + TW = 63 + UA = 64 + US = 65 + VE = 66 + VN = 67 + ZA = 68 + class LearnRateStrategy(proto.Enum): r"""Indicates the learning rate optimization strategy to use.""" LEARN_RATE_STRATEGY_UNSPECIFIED = 0 @@ -144,6 +242,27 @@ class OptimizationStrategy(proto.Enum): BATCH_GRADIENT_DESCENT = 1 NORMAL_EQUATION = 2 + class FeedbackType(proto.Enum): + r"""Indicates the training algorithm to use for matrix + factorization models. + """ + FEEDBACK_TYPE_UNSPECIFIED = 0 + IMPLICIT = 1 + EXPLICIT = 2 + + class SeasonalPeriod(proto.Message): + r"""""" + + class SeasonalPeriodType(proto.Enum): + r"""""" + SEASONAL_PERIOD_TYPE_UNSPECIFIED = 0 + NO_SEASONALITY = 1 + DAILY = 2 + WEEKLY = 3 + MONTHLY = 4 + QUARTERLY = 5 + YEARLY = 6 + class KmeansEnums(proto.Message): r"""""" @@ -154,6 +273,7 @@ class KmeansInitializationMethod(proto.Enum): KMEANS_INITIALIZATION_METHOD_UNSPECIFIED = 0 RANDOM = 1 CUSTOM = 2 + KMEANS_PLUS_PLUS = 3 class RegressionMetrics(proto.Message): r"""Evaluation metrics for regression and explicit feedback type @@ -529,6 +649,129 @@ class CategoryCount(proto.Message): proto.MESSAGE, number=3, message="Model.ClusteringMetrics.Cluster", ) + class RankingMetrics(proto.Message): + r"""Evaluation metrics used by weighted-ALS models specified by + feedback_type=implicit. + + Attributes: + mean_average_precision (~.wrappers.DoubleValue): + Calculates a precision per user for all the + items by ranking them and then averages all the + precisions across all the users. + mean_squared_error (~.wrappers.DoubleValue): + Similar to the mean squared error computed in + regression and explicit recommendation models + except instead of computing the rating directly, + the output from evaluate is computed against a + preference which is 1 or 0 depending on if the + rating exists or not. + normalized_discounted_cumulative_gain (~.wrappers.DoubleValue): + A metric to determine the goodness of a + ranking calculated from the predicted confidence + by comparing it to an ideal rank measured by the + original ratings. + average_rank (~.wrappers.DoubleValue): + Determines the goodness of a ranking by + computing the percentile rank from the predicted + confidence and dividing it by the original rank. + """ + + mean_average_precision = proto.Field( + proto.MESSAGE, number=1, message=wrappers.DoubleValue, + ) + + mean_squared_error = proto.Field( + proto.MESSAGE, number=2, message=wrappers.DoubleValue, + ) + + normalized_discounted_cumulative_gain = proto.Field( + proto.MESSAGE, number=3, message=wrappers.DoubleValue, + ) + + average_rank = proto.Field( + proto.MESSAGE, number=4, message=wrappers.DoubleValue, + ) + + class ArimaForecastingMetrics(proto.Message): + r"""Model evaluation metrics for ARIMA forecasting models. + + Attributes: + non_seasonal_order (Sequence[~.gcb_model.Model.ArimaOrder]): + Non-seasonal order. + arima_fitting_metrics (Sequence[~.gcb_model.Model.ArimaFittingMetrics]): + Arima model fitting metrics. + seasonal_periods (Sequence[~.gcb_model.Model.SeasonalPeriod.SeasonalPeriodType]): + Seasonal periods. Repeated because multiple + periods are supported for one time series. + has_drift (Sequence[bool]): + Whether Arima model fitted with drift or not. + It is always false when d is not 1. + time_series_id (Sequence[str]): + Id to differentiate different time series for + the large-scale case. + arima_single_model_forecasting_metrics (Sequence[~.gcb_model.Model.ArimaForecastingMetrics.ArimaSingleModelForecastingMetrics]): + Repeated as there can be many metric sets + (one for each model) in auto-arima and the + large-scale case. + """ + + class ArimaSingleModelForecastingMetrics(proto.Message): + r"""Model evaluation metrics for a single ARIMA forecasting + model. + + Attributes: + non_seasonal_order (~.gcb_model.Model.ArimaOrder): + Non-seasonal order. + arima_fitting_metrics (~.gcb_model.Model.ArimaFittingMetrics): + Arima fitting metrics. + has_drift (bool): + Is arima model fitted with drift or not. It + is always false when d is not 1. + time_series_id (str): + The id to indicate different time series. + seasonal_periods (Sequence[~.gcb_model.Model.SeasonalPeriod.SeasonalPeriodType]): + Seasonal periods. Repeated because multiple + periods are supported for one time series. + """ + + non_seasonal_order = proto.Field( + proto.MESSAGE, number=1, message="Model.ArimaOrder", + ) + + arima_fitting_metrics = proto.Field( + proto.MESSAGE, number=2, message="Model.ArimaFittingMetrics", + ) + + has_drift = proto.Field(proto.BOOL, number=3) + + time_series_id = proto.Field(proto.STRING, number=4) + + seasonal_periods = proto.RepeatedField( + proto.ENUM, number=5, enum="Model.SeasonalPeriod.SeasonalPeriodType", + ) + + non_seasonal_order = proto.RepeatedField( + proto.MESSAGE, number=1, message="Model.ArimaOrder", + ) + + arima_fitting_metrics = proto.RepeatedField( + proto.MESSAGE, number=2, message="Model.ArimaFittingMetrics", + ) + + seasonal_periods = proto.RepeatedField( + proto.ENUM, number=3, enum="Model.SeasonalPeriod.SeasonalPeriodType", + ) + + has_drift = proto.RepeatedField(proto.BOOL, number=4) + + time_series_id = proto.RepeatedField(proto.STRING, number=5) + + arima_single_model_forecasting_metrics = proto.RepeatedField( + proto.MESSAGE, + number=6, + message="Model.ArimaForecastingMetrics.ArimaSingleModelForecastingMetrics", + ) + class EvaluationMetrics(proto.Message): r"""Evaluation metrics of a model. These are either computed on all training data or just the eval data based on whether eval @@ -547,6 +790,11 @@ class EvaluationMetrics(proto.Message): classification/classifier models. clustering_metrics (~.gcb_model.Model.ClusteringMetrics): Populated for clustering models. + ranking_metrics (~.gcb_model.Model.RankingMetrics): + Populated for implicit feedback type matrix + factorization models. + arima_forecasting_metrics (~.gcb_model.Model.ArimaForecastingMetrics): + Populated for ARIMA models. """ regression_metrics = proto.Field( @@ -571,6 +819,116 @@ class EvaluationMetrics(proto.Message): proto.MESSAGE, number=4, oneof="metrics", message="Model.ClusteringMetrics", ) + ranking_metrics = proto.Field( + proto.MESSAGE, number=5, oneof="metrics", message="Model.RankingMetrics", + ) + + arima_forecasting_metrics = proto.Field( + proto.MESSAGE, + number=6, + oneof="metrics", + message="Model.ArimaForecastingMetrics", + ) + + class DataSplitResult(proto.Message): + r"""Data split result. This contains references to the training + and evaluation data tables that were used to train the model. + + Attributes: + training_table (~.table_reference.TableReference): + Table reference of the training data after + split. + evaluation_table (~.table_reference.TableReference): + Table reference of the evaluation data after + split. + """ + + training_table = proto.Field( + proto.MESSAGE, number=1, message=table_reference.TableReference, + ) + + evaluation_table = proto.Field( + proto.MESSAGE, number=2, message=table_reference.TableReference, + ) + + class ArimaOrder(proto.Message): + r"""Arima order, can be used for both non-seasonal and seasonal + parts. + + Attributes: + p (int): + Order of the autoregressive part. + d (int): + Order of the differencing part. + q (int): + Order of the moving-average part. + """ + + p = proto.Field(proto.INT64, number=1) + + d = proto.Field(proto.INT64, number=2) + + q = proto.Field(proto.INT64, number=3) + + class ArimaFittingMetrics(proto.Message): + r"""ARIMA model fitting metrics. + + Attributes: + log_likelihood (float): + Log-likelihood. + aic (float): + AIC. + variance (float): + Variance. + """ + + log_likelihood = proto.Field(proto.DOUBLE, number=1) + + aic = proto.Field(proto.DOUBLE, number=2) + + variance = proto.Field(proto.DOUBLE, number=3) + + class GlobalExplanation(proto.Message): + r"""Global explanations containing the top most important + features after training. + + Attributes: + explanations (Sequence[~.gcb_model.Model.GlobalExplanation.Explanation]): + A list of the top global explanations. Sorted + by absolute value of attribution in descending + order. + class_label (str): + Class label for this set of global + explanations. Will be empty/null for binary + logistic and linear regression models. Sorted + alphabetically in descending order. + """ + + class Explanation(proto.Message): + r"""Explanation for a single feature. + + Attributes: + feature_name (str): + Full name of the feature. For non-numerical features, will + be formatted like .. + Overall size of feature name will always be truncated to + first 120 characters. + attribution (~.wrappers.DoubleValue): + Attribution of feature. + """ + + feature_name = proto.Field(proto.STRING, number=1) + + attribution = proto.Field( + proto.MESSAGE, number=2, message=wrappers.DoubleValue, + ) + + explanations = proto.RepeatedField( + proto.MESSAGE, number=1, message="Model.GlobalExplanation.Explanation", + ) + + class_label = proto.Field(proto.STRING, number=2) + class TrainingRun(proto.Message): r"""Information about a single training query run for the model. @@ -587,6 +945,14 @@ class TrainingRun(proto.Message): evaluation_metrics (~.gcb_model.Model.EvaluationMetrics): The evaluation metrics over training/eval data that were computed at the end of training. + data_split_result (~.gcb_model.Model.DataSplitResult): + Data split result of the training run. Only + set when the input data is actually split. + global_explanations (Sequence[~.gcb_model.Model.GlobalExplanation]): + Global explanations for important features of + the model. For multi-class models, there is one + entry for each label class. For other models, + there is only one entry in the list. """ class TrainingOptions(proto.Message): @@ -651,6 +1017,12 @@ class TrainingOptions(proto.Message): Weights associated with each label class, for rebalancing the training data. Only applicable for classification models. + user_column (str): + User column specified for matrix + factorization models. + item_column (str): + Item column specified for matrix + factorization models. distance_type (~.gcb_model.Model.DistanceType): Distance type for clustering models. num_clusters (int): @@ -661,12 +1033,71 @@ class TrainingOptions(proto.Message): optimization_strategy (~.gcb_model.Model.OptimizationStrategy): Optimization strategy for training linear regression models. + hidden_units (Sequence[int]): + Hidden units for dnn models. + batch_size (int): + Batch size for dnn models. + dropout (~.wrappers.DoubleValue): + Dropout probability for dnn models. + max_tree_depth (int): + Maximum depth of a tree for boosted tree + models. + subsample (float): + Subsample fraction of the training data to + grow tree to prevent overfitting for boosted + tree models. + min_split_loss (~.wrappers.DoubleValue): + Minimum split loss for boosted tree models. + num_factors (int): + Num factors specified for matrix + factorization models. + feedback_type (~.gcb_model.Model.FeedbackType): + Feedback type that specifies which algorithm + to run for matrix factorization. + wals_alpha (~.wrappers.DoubleValue): + Hyperparameter for matrix factoration when + implicit feedback type is specified. kmeans_initialization_method (~.gcb_model.Model.KmeansEnums.KmeansInitializationMethod): The method used to initialize the centroids for kmeans algorithm. kmeans_initialization_column (str): The column used to provide the initial centroids for kmeans algorithm when kmeans_initialization_method is CUSTOM. + time_series_timestamp_column (str): + Column to be designated as time series + timestamp for ARIMA model. + time_series_data_column (str): + Column to be designated as time series data + for ARIMA model. + auto_arima (bool): + Whether to enable auto ARIMA or not. + non_seasonal_order (~.gcb_model.Model.ArimaOrder): + A specification of the non-seasonal part of + the ARIMA model: the three components (p, d, q) + are the AR order, the degree of differencing, + and the MA order. + data_frequency (~.gcb_model.Model.DataFrequency): + The data frequency of a time series. + include_drift (bool): + Include drift when fitting an ARIMA model. + holiday_region (~.gcb_model.Model.HolidayRegion): + The geographical region based on which the + holidays are considered in time series modeling. + If a valid value is specified, then holiday + effects modeling is enabled. + time_series_id_column (str): + The id column that will be used to indicate + different time series to forecast in parallel. + horizon (int): + The number of periods ahead that need to be + forecasted. + preserve_input_structs (bool): + Whether to preserve the input structs in output feature + names. Suppose there is a struct A with field b. When false + (default), the output feature name is A_b. When true, the + output feature name is A.b. + auto_arima_max_order (int): + The max value of non-seasonal p and q. """ max_iterations = proto.Field(proto.INT64, number=1) @@ -713,6 +1144,10 @@ class TrainingOptions(proto.Message): label_class_weights = proto.MapField(proto.STRING, proto.DOUBLE, number=17) + user_column = proto.Field(proto.STRING, number=18) + + item_column = proto.Field(proto.STRING, number=19) + distance_type = proto.Field( proto.ENUM, number=20, enum="Model.DistanceType", ) @@ -725,6 +1160,32 @@ class TrainingOptions(proto.Message): proto.ENUM, number=23, enum="Model.OptimizationStrategy", ) + hidden_units = proto.RepeatedField(proto.INT64, number=24) + + batch_size = proto.Field(proto.INT64, number=25) + + dropout = proto.Field( + proto.MESSAGE, number=26, message=wrappers.DoubleValue, + ) + + max_tree_depth = proto.Field(proto.INT64, number=27) + + subsample = proto.Field(proto.DOUBLE, number=28) + + min_split_loss = proto.Field( + proto.MESSAGE, number=29, message=wrappers.DoubleValue, + ) + + num_factors = proto.Field(proto.INT64, number=30) + + feedback_type = proto.Field( + proto.ENUM, number=31, enum="Model.FeedbackType", + ) + + wals_alpha = proto.Field( + proto.MESSAGE, number=32, message=wrappers.DoubleValue, + ) + kmeans_initialization_method = proto.Field( proto.ENUM, number=33, @@ -733,6 +1194,34 @@ class TrainingOptions(proto.Message): kmeans_initialization_column = proto.Field(proto.STRING, number=34) + time_series_timestamp_column = proto.Field(proto.STRING, number=35) + + time_series_data_column = proto.Field(proto.STRING, number=36) + + auto_arima = proto.Field(proto.BOOL, number=37) + + non_seasonal_order = proto.Field( + proto.MESSAGE, number=38, message="Model.ArimaOrder", + ) + + data_frequency = proto.Field( + proto.ENUM, number=39, enum="Model.DataFrequency", + ) + + include_drift = proto.Field(proto.BOOL, number=41) + + holiday_region = proto.Field( + proto.ENUM, number=42, enum="Model.HolidayRegion", + ) + + time_series_id_column = proto.Field(proto.STRING, number=43) + + horizon = proto.Field(proto.INT64, number=44) + + preserve_input_structs = proto.Field(proto.BOOL, number=45) + + auto_arima_max_order = proto.Field(proto.INT64, number=46) + class IterationResult(proto.Message): r"""Information about a single iteration of the training run. @@ -753,6 +1242,8 @@ class IterationResult(proto.Message): cluster_infos (Sequence[~.gcb_model.Model.TrainingRun.IterationResult.ClusterInfo]): Information about top clusters for clustering models. + arima_result (~.gcb_model.Model.TrainingRun.IterationResult.ArimaResult): + """ class ClusterInfo(proto.Message): @@ -779,6 +1270,102 @@ class ClusterInfo(proto.Message): proto.MESSAGE, number=3, message=wrappers.Int64Value, ) + class ArimaResult(proto.Message): + r"""(Auto-)arima fitting result. Wrap everything in ArimaResult + for easier refactoring if we want to use model-specific + iteration results. + + Attributes: + arima_model_info (Sequence[~.gcb_model.Model.TrainingRun.IterationResult.ArimaResult.ArimaModelInfo]): + This message is repeated because there are + multiple arima models fitted in auto-arima. For + non-auto-arima model, its size is one. + seasonal_periods (Sequence[~.gcb_model.Model.SeasonalPeriod.SeasonalPeriodType]): + Seasonal periods. Repeated because multiple + periods are supported for one time series. + """ + + class ArimaCoefficients(proto.Message): + r"""Arima coefficients. + + Attributes: + auto_regressive_coefficients (Sequence[float]): + Auto-regressive coefficients, an array of + double. + moving_average_coefficients (Sequence[float]): + Moving-average coefficients, an array of + double. + intercept_coefficient (float): + Intercept coefficient, just a double not an + array. + """ + + auto_regressive_coefficients = proto.RepeatedField( + proto.DOUBLE, number=1 + ) + + moving_average_coefficients = proto.RepeatedField( + proto.DOUBLE, number=2 + ) + + intercept_coefficient = proto.Field(proto.DOUBLE, number=3) + + class ArimaModelInfo(proto.Message): + r"""Arima model information. + + Attributes: + non_seasonal_order (~.gcb_model.Model.ArimaOrder): + Non-seasonal order. + arima_coefficients (~.gcb_model.Model.TrainingRun.IterationResult.ArimaResult.ArimaCoefficients): + Arima coefficients. + arima_fitting_metrics (~.gcb_model.Model.ArimaFittingMetrics): + Arima fitting metrics. + has_drift (bool): + Whether Arima model fitted with drift or not. + It is always false when d is not 1. + time_series_id (str): + The id to indicate different time series. + seasonal_periods (Sequence[~.gcb_model.Model.SeasonalPeriod.SeasonalPeriodType]): + Seasonal periods. Repeated because multiple + periods are supported for one time series. + """ + + non_seasonal_order = proto.Field( + proto.MESSAGE, number=1, message="Model.ArimaOrder", + ) + + arima_coefficients = proto.Field( + proto.MESSAGE, + number=2, + message="Model.TrainingRun.IterationResult.ArimaResult.ArimaCoefficients", + ) + + arima_fitting_metrics = proto.Field( + proto.MESSAGE, number=3, message="Model.ArimaFittingMetrics", + ) + + has_drift = proto.Field(proto.BOOL, number=4) + + time_series_id = proto.Field(proto.STRING, number=5) + + seasonal_periods = proto.RepeatedField( + proto.ENUM, + number=6, + enum="Model.SeasonalPeriod.SeasonalPeriodType", + ) + + arima_model_info = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="Model.TrainingRun.IterationResult.ArimaResult.ArimaModelInfo", + ) + + seasonal_periods = proto.RepeatedField( + proto.ENUM, + number=2, + enum="Model.SeasonalPeriod.SeasonalPeriodType", + ) + index = proto.Field(proto.MESSAGE, number=1, message=wrappers.Int32Value,) duration_ms = proto.Field( @@ -801,6 +1388,12 @@ class ClusterInfo(proto.Message): message="Model.TrainingRun.IterationResult.ClusterInfo", ) + arima_result = proto.Field( + proto.MESSAGE, + number=9, + message="Model.TrainingRun.IterationResult.ArimaResult", + ) + training_options = proto.Field( proto.MESSAGE, number=1, message="Model.TrainingRun.TrainingOptions", ) @@ -815,6 +1408,14 @@ class ClusterInfo(proto.Message): proto.MESSAGE, number=7, message="Model.EvaluationMetrics", ) + data_split_result = proto.Field( + proto.MESSAGE, number=9, message="Model.DataSplitResult", + ) + + global_explanations = proto.RepeatedField( + proto.MESSAGE, number=10, message="Model.GlobalExplanation", + ) + etag = proto.Field(proto.STRING, number=1) model_reference = proto.Field( diff --git a/google/cloud/bigquery_v2/types/standard_sql.py b/google/cloud/bigquery_v2/types/standard_sql.py index 72f12f284..1a32a3c75 100644 --- a/google/cloud/bigquery_v2/types/standard_sql.py +++ b/google/cloud/bigquery_v2/types/standard_sql.py @@ -58,6 +58,7 @@ class TypeKind(proto.Enum): DATETIME = 21 GEOGRAPHY = 22 NUMERIC = 23 + BIGNUMERIC = 24 ARRAY = 16 STRUCT = 17 diff --git a/google/cloud/bigquery_v2/types/table_reference.py b/google/cloud/bigquery_v2/types/table_reference.py new file mode 100644 index 000000000..d213e8bb6 --- /dev/null +++ b/google/cloud/bigquery_v2/types/table_reference.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- + +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +import proto # type: ignore + + +__protobuf__ = proto.module( + package="google.cloud.bigquery.v2", manifest={"TableReference",}, +) + + +class TableReference(proto.Message): + r""" + + Attributes: + project_id (str): + Required. The ID of the project containing + this table. + dataset_id (str): + Required. The ID of the dataset containing + this table. + table_id (str): + Required. The ID of the table. The ID must contain only + letters (a-z, A-Z), numbers (0-9), or underscores (_). The + maximum length is 1,024 characters. Certain operations allow + suffixing of the table ID with a partition decorator, such + as ``sample_table$20190123``. + """ + + project_id = proto.Field(proto.STRING, number=1) + + dataset_id = proto.Field(proto.STRING, number=2) + + table_id = proto.Field(proto.STRING, number=3) + + +__all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/synth.metadata b/synth.metadata index 008810630..db77e463d 100644 --- a/synth.metadata +++ b/synth.metadata @@ -4,15 +4,15 @@ "git": { "name": ".", "remote": "https://github.com/googleapis/python-bigquery.git", - "sha": "31644d380b35a76a9147801a4b6b0271c246fd0c" + "sha": "5178b55682f5e264bfc082cde26acb1fdc953a18" } }, { "git": { "name": "googleapis", "remote": "https://github.com/googleapis/googleapis.git", - "sha": "c941026e5e3d600817a20e9ab4d4be03dff21a68", - "internalRef": "334645418" + "sha": "215c12ade72d9d9616457d9b8b2f8a37f38e79f3", + "internalRef": "337113354" } }, { @@ -101,18 +101,19 @@ "google/cloud/bigquery_v2/proto/model.proto", "google/cloud/bigquery_v2/proto/model_reference.proto", "google/cloud/bigquery_v2/proto/standard_sql.proto", + "google/cloud/bigquery_v2/proto/table_reference.proto", "google/cloud/bigquery_v2/py.typed", "google/cloud/bigquery_v2/types/__init__.py", "google/cloud/bigquery_v2/types/encryption_config.py", "google/cloud/bigquery_v2/types/model.py", "google/cloud/bigquery_v2/types/model_reference.py", "google/cloud/bigquery_v2/types/standard_sql.py", + "google/cloud/bigquery_v2/types/table_reference.py", "mypy.ini", "renovate.json", "samples/AUTHORING_GUIDE.md", "samples/CONTRIBUTING.md", "scripts/decrypt-secrets.sh", - "scripts/fixup_bigquery_v2_keywords.py", "scripts/readme-gen/readme_gen.py", "scripts/readme-gen/templates/README.tmpl.rst", "scripts/readme-gen/templates/auth.tmpl.rst",