diff --git a/CHANGELOG.md b/CHANGELOG.md index a99e0ecd91..a0539af01e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,26 @@ [1]: https://pypi.org/project/bigframes/#history +## [1.20.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v1.19.0...v1.20.0) (2024-09-25) + + +### Features + +* Add bigframes.bigquery.approx_top_count ([#1010](https://github.com/googleapis/python-bigquery-dataframes/issues/1010)) ([3263bd7](https://github.com/googleapis/python-bigquery-dataframes/commit/3263bd70cff01bc18f1ae4ac3d5aa7f9d70fd4b7)) +* Add bigframes.ml.compose.SQLScalarColumnTransformer to create custom SQL-based transformations ([#955](https://github.com/googleapis/python-bigquery-dataframes/issues/955)) ([1930b4e](https://github.com/googleapis/python-bigquery-dataframes/commit/1930b4efe60295751ceef89c2a824923a35b19af)) +* Allow multiple columns input for llm models ([#998](https://github.com/googleapis/python-bigquery-dataframes/issues/998)) ([2fe5e48](https://github.com/googleapis/python-bigquery-dataframes/commit/2fe5e48c56bbc359d3769824c83745d65a001dd7)) + + +### Bug Fixes + +* Fix __repr__ caching with partial ordering ([#1016](https://github.com/googleapis/python-bigquery-dataframes/issues/1016)) ([208a984](https://github.com/googleapis/python-bigquery-dataframes/commit/208a98475389f59d4e32e0cfbcc46824cac278a6)) + + +### Documentation + +* Limit pypi notebook to 7 days and add more info about differences with partial ordering mode ([#1013](https://github.com/googleapis/python-bigquery-dataframes/issues/1013)) ([3c54399](https://github.com/googleapis/python-bigquery-dataframes/commit/3c543990297ec3be0e30425ee841546217e26d2a)) +* Move and edit existing linear-regression tutorial snippet ([#991](https://github.com/googleapis/python-bigquery-dataframes/issues/991)) ([4cb62fd](https://github.com/googleapis/python-bigquery-dataframes/commit/4cb62fd74fc1ac3bb21da23b8639464a9ae3525d)) + ## [1.19.0](https://github.com/googleapis/python-bigquery-dataframes/compare/v1.18.0...v1.19.0) (2024-09-24) diff --git a/bigframes/bigquery/__init__.py b/bigframes/bigquery/__init__.py index 303120b88a..28a818e709 100644 --- a/bigframes/bigquery/__init__.py +++ b/bigframes/bigquery/__init__.py @@ -272,6 +272,46 @@ def json_extract_array( return series._apply_unary_op(ops.JSONExtractArray(json_path=json_path)) +# Approximate aggrgate functions defined from +# https://cloud.google.com/bigquery/docs/reference/standard-sql/approximate_aggregate_functions + + +def approx_top_count( + series: series.Series, + number: int, +) -> series.Series: + """Returns the approximate top elements of `expression` as an array of STRUCTs. + The number parameter specifies the number of elements returned. + + Each `STRUCT` contains two fields. The first field (named `value`) contains an input + value. The second field (named `count`) contains an `INT64` specifying the number + of times the value was returned. + + Returns `NULL` if there are zero input rows. + + **Examples:** + + >>> import bigframes.pandas as bpd + >>> import bigframes.bigquery as bbq + >>> bpd.options.display.progress_bar = None + >>> s = bpd.Series(["apple", "apple", "pear", "pear", "pear", "banana"]) + >>> bbq.approx_top_count(s, number=2) + [{'value': 'pear', 'count': 3}, {'value': 'apple', 'count': 2}] + + Args: + series (bigframes.series.Series): + The Series with any data type that the `GROUP BY` clause supports. + number (int): + An integer specifying the number of times the value was returned. + + Returns: + bigframes.series.Series: A new Series with the result data. + """ + if number < 1: + raise ValueError("The number of approx_top_count must be at least 1") + return series._apply_aggregation(agg_ops.ApproxTopCountOp(number=number)) + + def struct(value: dataframe.DataFrame) -> series.Series: """Takes a DataFrame and converts it into a Series of structs with each struct entry corresponding to a DataFrame row and each struct field diff --git a/bigframes/core/compile/aggregate_compiler.py b/bigframes/core/compile/aggregate_compiler.py index 91a3045efb..b65953934d 100644 --- a/bigframes/core/compile/aggregate_compiler.py +++ b/bigframes/core/compile/aggregate_compiler.py @@ -11,6 +11,9 @@ # 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. + +from __future__ import annotations + import functools import typing from typing import cast, List, Optional @@ -19,6 +22,7 @@ import bigframes_vendored.ibis.expr.operations as vendored_ibis_ops import ibis import ibis.expr.datatypes as ibis_dtypes +import ibis.expr.operations as ibis_ops import ibis.expr.types as ibis_types import pandas as pd @@ -196,6 +200,34 @@ def _( return cast(ibis_types.NumericValue, value) +@compile_unary_agg.register +def _( + op: agg_ops.ApproxTopCountOp, + column: ibis_types.Column, + window=None, +) -> ibis_types.ArrayColumn: + # APPROX_TOP_COUNT has very few allowed windows. + if window is not None: + raise NotImplementedError( + f"Approx top count with windowing is not supported. {constants.FEEDBACK_LINK}" + ) + + # Define a user-defined function (UDF) that approximates the top counts of an expression. + # The type of value is dynamically matching the input column. + def approx_top_count(expression, number: ibis_dtypes.int64): # type: ignore + ... + + return_type = ibis_dtypes.Array( + ibis_dtypes.Struct.from_tuples( + [("value", column.type()), ("count", ibis_dtypes.int64)] + ) + ) + approx_top_count.__annotations__["return"] = return_type + udf_op = ibis_ops.udf.agg.builtin(approx_top_count) + + return udf_op(expression=column, number=op.number) + + @compile_unary_agg.register @numeric_op def _( diff --git a/bigframes/core/tree_properties.py b/bigframes/core/tree_properties.py index 4978e75e38..1b0fe0d072 100644 --- a/bigframes/core/tree_properties.py +++ b/bigframes/core/tree_properties.py @@ -44,8 +44,8 @@ def can_fast_head(node: nodes.BigFrameNode) -> bool: """Can get head fast if can push head operator down to leafs and operators preserve rows.""" if isinstance(node, nodes.LeafNode): return node.supports_fast_head - if isinstance(node, nodes.UnaryNode): - return node.row_preserving and can_fast_head(node.child) + if isinstance(node, (nodes.ProjectionNode, nodes.SelectionNode)): + return can_fast_head(node.child) return False diff --git a/bigframes/dataframe.py b/bigframes/dataframe.py index 49a668f008..47c93bfa30 100644 --- a/bigframes/dataframe.py +++ b/bigframes/dataframe.py @@ -643,7 +643,6 @@ def __repr__(self) -> str: if opts.repr_mode == "deferred": return formatter.repr_query_job(self._compute_dry_run()) - self._cached() # TODO(swast): pass max_columns and get the true column count back. Maybe # get 1 more column than we have requested so that pandas can add the # ... for us? @@ -2303,52 +2302,19 @@ def melt( self._block.melt(id_col_ids, val_col_ids, var_name, value_name) ) - _NUMERIC_DESCRIBE_AGGS = ( - "count", - "mean", - "std", - "min", - "25%", - "50%", - "75%", - "max", - ) - _NON_NUMERIC_DESCRIBE_AGGS = ("count", "nunique") - def describe(self, include: None | Literal["all"] = None) -> DataFrame: - - allowed_non_numeric_types = { - bigframes.dtypes.STRING_DTYPE, - bigframes.dtypes.BOOL_DTYPE, - bigframes.dtypes.BYTES_DTYPE, - } - if include is None: numeric_df = self._drop_non_numeric(permissive=False) if len(numeric_df.columns) == 0: # Describe eligible non-numeric columns - result = self.select_dtypes(include=allowed_non_numeric_types).agg( - self._NON_NUMERIC_DESCRIBE_AGGS - ) - else: - # Otherwise, only describe numeric columns - result = numeric_df.agg(self._NUMERIC_DESCRIBE_AGGS) - return typing.cast(DataFrame, result) + return self._describe_non_numeric() - elif include == "all": - numeric_result = typing.cast( - DataFrame, - self._drop_non_numeric(permissive=False).agg( - self._NUMERIC_DESCRIBE_AGGS - ), - ) + # Otherwise, only describe numeric columns + return self._describe_numeric() - non_numeric_result = typing.cast( - DataFrame, - self.select_dtypes(include=allowed_non_numeric_types).agg( - self._NON_NUMERIC_DESCRIBE_AGGS - ), - ) + elif include == "all": + numeric_result = self._describe_numeric() + non_numeric_result = self._describe_non_numeric() if len(numeric_result.columns) == 0: return non_numeric_result @@ -2365,6 +2331,35 @@ def describe(self, include: None | Literal["all"] = None) -> DataFrame: else: raise ValueError(f"Unsupported include type: {include}") + def _describe_numeric(self) -> DataFrame: + return typing.cast( + DataFrame, + self._drop_non_numeric(permissive=False).agg( + [ + "count", + "mean", + "std", + "min", + "25%", + "50%", + "75%", + "max", + ] + ), + ) + + def _describe_non_numeric(self) -> DataFrame: + return typing.cast( + DataFrame, + self.select_dtypes( + include={ + bigframes.dtypes.STRING_DTYPE, + bigframes.dtypes.BOOL_DTYPE, + bigframes.dtypes.BYTES_DTYPE, + } + ).agg(["count", "nunique"]), + ) + def skew(self, *, numeric_only: bool = False): if not numeric_only: frame = self._raise_on_non_numeric("skew") diff --git a/bigframes/ml/base.py b/bigframes/ml/base.py index 6ae06c9d9f..81181b58cf 100644 --- a/bigframes/ml/base.py +++ b/bigframes/ml/base.py @@ -198,10 +198,6 @@ def _extract_output_names(self): # pass the columns that are not transformed if "transformSql" not in transform_col_dict: continue - transform_sql: str = transform_col_dict["transformSql"] - if not transform_sql.startswith("ML."): - continue - output_names.append(transform_col_dict["name"]) self._output_names = output_names diff --git a/bigframes/ml/compose.py b/bigframes/ml/compose.py index 3cfa1851f5..08c9761cc3 100644 --- a/bigframes/ml/compose.py +++ b/bigframes/ml/compose.py @@ -46,6 +46,101 @@ ) +class SQLScalarColumnTransformer: + r""" + Wrapper for plain SQL code contained in a ColumnTransformer. + + Create a single column transformer in plain sql. + This transformer can only be used inside ColumnTransformer. + + When creating an instance '{0}' can be used as placeholder + for the column to transform: + + SQLScalarColumnTransformer("{0}+1") + + The default target column gets the prefix 'transformed\_' + but can also be changed when creating an instance: + + SQLScalarColumnTransformer("{0}+1", "inc_{0}") + + **Examples:** + + >>> from bigframes.ml.compose import ColumnTransformer, SQLScalarColumnTransformer + >>> import bigframes.pandas as bpd + + >>> df = bpd.DataFrame({'name': ["James", None, "Mary"], 'city': ["New York", "Boston", None]}) + >>> col_trans = ColumnTransformer([ + ... ("strlen", + ... SQLScalarColumnTransformer("CASE WHEN {0} IS NULL THEN 15 ELSE LENGTH({0}) END"), + ... ['name', 'city']), + ... ]) + >>> col_trans = col_trans.fit(df) + >>> df_transformed = col_trans.transform(df) + >>> df_transformed + transformed_name transformed_city + 0 5 8 + 1 15 6 + 2 4 15 + + [3 rows x 2 columns] + + SQLScalarColumnTransformer can be combined with other transformers, like StandardScaler: + + >>> col_trans = ColumnTransformer([ + ... ("identity", SQLScalarColumnTransformer("{0}", target_column="{0}"), ["col1", "col5"]), + ... ("increment", SQLScalarColumnTransformer("{0}+1", target_column="inc_{0}"), "col2"), + ... ("stdscale", preprocessing.StandardScaler(), "col3"), + ... # ... + ... ]) + + """ + + def __init__(self, sql: str, target_column: str = "transformed_{0}"): + super().__init__() + self._sql = sql + self._target_column = target_column.replace("`", "") + + PLAIN_COLNAME_RX = re.compile("^[a-z][a-z0-9_]*$", re.IGNORECASE) + + def escape(self, colname: str): + colname = colname.replace("`", "") + if self.PLAIN_COLNAME_RX.match(colname): + return colname + return f"`{colname}`" + + def _compile_to_sql( + self, X: bpd.DataFrame, columns: Optional[Iterable[str]] = None + ) -> List[str]: + if columns is None: + columns = X.columns + result = [] + for column in columns: + current_sql = self._sql.format(self.escape(column)) + current_target_column = self.escape(self._target_column.format(column)) + result.append(f"{current_sql} AS {current_target_column}") + return result + + def __repr__(self): + return f"SQLScalarColumnTransformer(sql='{self._sql}', target_column='{self._target_column}')" + + def __eq__(self, other) -> bool: + return type(self) is type(other) and self._keys() == other._keys() + + def __hash__(self) -> int: + return hash(self._keys()) + + def _keys(self): + return (self._sql, self._target_column) + + +# Type hints for transformers contained in ColumnTransformer +SingleColTransformer = Union[ + preprocessing.PreprocessingType, + impute.SimpleImputer, + SQLScalarColumnTransformer, +] + + @log_adapter.class_logger class ColumnTransformer( base.Transformer, @@ -60,7 +155,7 @@ def __init__( transformers: Iterable[ Tuple[ str, - Union[preprocessing.PreprocessingType, impute.SimpleImputer], + SingleColTransformer, Union[str, Iterable[str]], ] ], @@ -78,14 +173,12 @@ def _keys(self): @property def transformers_( self, - ) -> List[ - Tuple[str, Union[preprocessing.PreprocessingType, impute.SimpleImputer], str] - ]: + ) -> List[Tuple[str, SingleColTransformer, str,]]: """The collection of transformers as tuples of (name, transformer, column).""" result: List[ Tuple[ str, - Union[preprocessing.PreprocessingType, impute.SimpleImputer], + SingleColTransformer, str, ] ] = [] @@ -103,6 +196,8 @@ def transformers_( return result + AS_FLEXNAME_SUFFIX_RX = re.compile("^(.*)\\bAS\\s*`[^`]+`\\s*$", re.IGNORECASE) + @classmethod def _extract_from_bq_model( cls, @@ -114,7 +209,7 @@ def _extract_from_bq_model( transformers_set: Set[ Tuple[ str, - Union[preprocessing.PreprocessingType, impute.SimpleImputer], + SingleColTransformer, Union[str, List[str]], ] ] = set() @@ -130,8 +225,11 @@ def camel_to_snake(name): if "transformSql" not in transform_col_dict: continue transform_sql: str = transform_col_dict["transformSql"] - if not transform_sql.startswith("ML."): - continue + + # workaround for bug in bq_model returning " AS `...`" suffix for flexible names + flex_name_match = cls.AS_FLEXNAME_SUFFIX_RX.match(transform_sql) + if flex_name_match: + transform_sql = flex_name_match.group(1) output_names.append(transform_col_dict["name"]) found_transformer = False @@ -148,8 +246,22 @@ def camel_to_snake(name): found_transformer = True break if not found_transformer: - raise NotImplementedError( - f"Unsupported transformer type. {constants.FEEDBACK_LINK}" + if transform_sql.startswith("ML."): + raise NotImplementedError( + f"Unsupported transformer type. {constants.FEEDBACK_LINK}" + ) + + target_column = transform_col_dict["name"] + sql_transformer = SQLScalarColumnTransformer( + transform_sql, target_column=target_column + ) + input_column_name = f"?{target_column}" + transformers_set.add( + ( + camel_to_snake(sql_transformer.__class__.__name__), + sql_transformer, + input_column_name, + ) ) transformer = cls(transformers=list(transformers_set)) @@ -167,6 +279,8 @@ def _merge( assert len(transformers) > 0 _, transformer_0, column_0 = transformers[0] + if isinstance(transformer_0, SQLScalarColumnTransformer): + return self # SQLScalarColumnTransformer only work inside ColumnTransformer feature_columns_sorted = sorted( [ cast(str, feature_column.name) diff --git a/bigframes/ml/llm.py b/bigframes/ml/llm.py index 53a9d40c6e..3d11cd123e 100644 --- a/bigframes/ml/llm.py +++ b/bigframes/ml/llm.py @@ -244,7 +244,7 @@ def predict( Args: X (bigframes.dataframe.DataFrame or bigframes.series.Series): - Input DataFrame or Series, which contains only one column of prompts. + Input DataFrame or Series, can contain one or more columns. If multiple columns are in the DataFrame, it must contain a "prompt" column for prediction. Prompts can include preamble, questions, suggestions, instructions, or examples. temperature (float, default 0.0): @@ -307,14 +307,10 @@ def predict( (X,) = utils.convert_to_dataframe(X) - if len(X.columns) != 1: - raise ValueError( - f"Only support one column as input. {constants.FEEDBACK_LINK}" - ) - - # BQML identified the column by name - col_label = cast(blocks.Label, X.columns[0]) - X = X.rename(columns={col_label: "prompt"}) + if len(X.columns) == 1: + # BQML identified the column by name + col_label = cast(blocks.Label, X.columns[0]) + X = X.rename(columns={col_label: "prompt"}) options = { "temperature": temperature, @@ -522,7 +518,7 @@ def predict(self, X: Union[bpd.DataFrame, bpd.Series]) -> bpd.DataFrame: Args: X (bigframes.dataframe.DataFrame or bigframes.series.Series): - Input DataFrame, which needs to contain a column with name "content". Only the column will be used as input. Content can include preamble, questions, suggestions, instructions, or examples. + Input DataFrame or Series, can contain one or more columns. If multiple columns are in the DataFrame, it must contain a "content" column for prediction. Returns: bigframes.dataframe.DataFrame: DataFrame of shape (n_samples, n_input_columns + n_prediction_columns). Returns predicted values. @@ -531,14 +527,10 @@ def predict(self, X: Union[bpd.DataFrame, bpd.Series]) -> bpd.DataFrame: # Params reference: https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models (X,) = utils.convert_to_dataframe(X) - if len(X.columns) != 1: - raise ValueError( - f"Only support one column as input. {constants.FEEDBACK_LINK}" - ) - - # BQML identified the column by name - col_label = cast(blocks.Label, X.columns[0]) - X = X.rename(columns={col_label: "content"}) + if len(X.columns) == 1: + # BQML identified the column by name + col_label = cast(blocks.Label, X.columns[0]) + X = X.rename(columns={col_label: "content"}) options = { "flatten_json_output": True, @@ -679,7 +671,7 @@ def predict(self, X: Union[bpd.DataFrame, bpd.Series]) -> bpd.DataFrame: Args: X (bigframes.dataframe.DataFrame or bigframes.series.Series): - Input DataFrame, which needs to contain a column with name "content". Only the column will be used as input. Content can include preamble, questions, suggestions, instructions, or examples. + Input DataFrame or Series, can contain one or more columns. If multiple columns are in the DataFrame, it must contain a "content" column for prediction. Returns: bigframes.dataframe.DataFrame: DataFrame of shape (n_samples, n_input_columns + n_prediction_columns). Returns predicted values. @@ -688,14 +680,10 @@ def predict(self, X: Union[bpd.DataFrame, bpd.Series]) -> bpd.DataFrame: # Params reference: https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models (X,) = utils.convert_to_dataframe(X) - if len(X.columns) != 1: - raise ValueError( - f"Only support one column as input. {constants.FEEDBACK_LINK}" - ) - - # BQML identified the column by name - col_label = cast(blocks.Label, X.columns[0]) - X = X.rename(columns={col_label: "content"}) + if len(X.columns) == 1: + # BQML identified the column by name + col_label = cast(blocks.Label, X.columns[0]) + X = X.rename(columns={col_label: "content"}) options = { "flatten_json_output": True, @@ -893,7 +881,7 @@ def predict( Args: X (bigframes.dataframe.DataFrame or bigframes.series.Series): - Input DataFrame or Series, which contains only one column of prompts. + Input DataFrame or Series, can contain one or more columns. If multiple columns are in the DataFrame, it must contain a "prompt" column for prediction. Prompts can include preamble, questions, suggestions, instructions, or examples. temperature (float, default 0.9): @@ -938,14 +926,10 @@ def predict( (X,) = utils.convert_to_dataframe(X) - if len(X.columns) != 1: - raise ValueError( - f"Only support one column as input. {constants.FEEDBACK_LINK}" - ) - - # BQML identified the column by name - col_label = cast(blocks.Label, X.columns[0]) - X = X.rename(columns={col_label: "prompt"}) + if len(X.columns) == 1: + # BQML identified the column by name + col_label = cast(blocks.Label, X.columns[0]) + X = X.rename(columns={col_label: "prompt"}) options = { "temperature": temperature, @@ -1181,7 +1165,7 @@ def predict( Args: X (bigframes.dataframe.DataFrame or bigframes.series.Series): - Input DataFrame or Series, which contains only one column of prompts. + Input DataFrame or Series, can contain one or more columns. If multiple columns are in the DataFrame, it must contain a "prompt" column for prediction. Prompts can include preamble, questions, suggestions, instructions, or examples. max_output_tokens (int, default 128): @@ -1222,14 +1206,10 @@ def predict( (X,) = utils.convert_to_dataframe(X) - if len(X.columns) != 1: - raise ValueError( - f"Only support one column as input. {constants.FEEDBACK_LINK}" - ) - - # BQML identified the column by name - col_label = cast(blocks.Label, X.columns[0]) - X = X.rename(columns={col_label: "prompt"}) + if len(X.columns) == 1: + # BQML identified the column by name + col_label = cast(blocks.Label, X.columns[0]) + X = X.rename(columns={col_label: "prompt"}) options = { "max_output_tokens": max_output_tokens, diff --git a/bigframes/operations/aggregations.py b/bigframes/operations/aggregations.py index d071889ac4..faba7465d9 100644 --- a/bigframes/operations/aggregations.py +++ b/bigframes/operations/aggregations.py @@ -184,6 +184,23 @@ def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionT return input_types[0] +@dataclasses.dataclass(frozen=True) +class ApproxTopCountOp(UnaryAggregateOp): + name: typing.ClassVar[str] = "approx_top_count" + number: int + + def output_type(self, *input_types: dtypes.ExpressionType) -> dtypes.ExpressionType: + if not dtypes.is_orderable(input_types[0]): + raise TypeError(f"Type {input_types[0]} is not orderable") + + input_type = input_types[0] + fields = [ + pa.field("value", dtypes.bigframes_dtype_to_arrow_dtype(input_type)), + pa.field("count", pa.int64()), + ] + return pd.ArrowDtype(pa.list_(pa.struct(fields))) + + @dataclasses.dataclass(frozen=True) class MeanOp(UnaryAggregateOp): name: ClassVar[str] = "mean" diff --git a/bigframes/session/executor.py b/bigframes/session/executor.py index d2a2e0f1b2..f89b5aefec 100644 --- a/bigframes/session/executor.py +++ b/bigframes/session/executor.py @@ -360,11 +360,6 @@ def _cache_with_cluster_cols( def _cache_with_offsets(self, array_value: bigframes.core.ArrayValue): """Executes the query and uses the resulting table to rewrite future executions.""" - - if not self.strictly_ordered: - raise ValueError( - "Caching with offsets only supported in strictly ordered mode." - ) offset_column = bigframes.core.guid.generate_guid("bigframes_offsets") w_offsets, offset_column = array_value.promote_offsets() sql = self.compiler.compile_unordered(self._get_optimized_plan(w_offsets.node)) diff --git a/bigframes/version.py b/bigframes/version.py index 5dda345fcb..60f4942175 100644 --- a/bigframes/version.py +++ b/bigframes/version.py @@ -12,4 +12,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "1.19.0" +__version__ = "1.20.0" diff --git a/notebooks/dataframes/pypi.ipynb b/notebooks/dataframes/pypi.ipynb index 7b16412ff5..a62bd45768 100644 --- a/notebooks/dataframes/pypi.ipynb +++ b/notebooks/dataframes/pypi.ipynb @@ -40,6 +40,16 @@ "execution_count": 2, "metadata": {}, "outputs": [], + "source": [ + "# Choose a package which you want to visualize.\n", + "package_name = \"pandas\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], "source": [ "import bigframes.pandas as bpd\n", "\n", @@ -58,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -83,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -111,24 +121,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Limit to the most recent 30 days of data\n", + "## Limit to the most recent 7 days of data\n", "\n", - "The PyPI and deps.dev tables are partitioned by date. Query only the most recent 30 days of data to reduce the number of bytes scanned.\n", + "The PyPI and deps.dev tables are partitioned by date. Query only the most recent 7 days of data to reduce the number of bytes scanned.\n", "\n", "Just as with the default ordering mode, filters can be describe in a pandas-compatible way by passing a Boolean Series to the DataFrame's `__getitem__` accessor." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "import datetime\n", "\n", - "last_30_days = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=30)\n", - "pypi = pypi[pypi[\"timestamp\"] > last_30_days]\n", - "deps = deps[(deps[\"SnapshotAt\"] > last_30_days) & (deps[\"System\"] == \"PYPI\")]" + "now = datetime.datetime.now(datetime.timezone.utc)\n", + "last_7_days = now - datetime.timedelta(days=7)\n", + "last_30_days = now - datetime.timedelta(days=30)\n", + "pypi = pypi[pypi[\"timestamp\"] > last_7_days]\n", + "deps = deps[deps[\"SnapshotAt\"] > last_30_days] # deps are refreshed less frequently\n", + "deps = deps[deps[\"System\"] == \"PYPI\"]" ] }, { @@ -143,15 +156,295 @@ "```\n", "import datetime\n", "\n", - "last_30_days = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=30)\n", + "last_7_days = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=7)\n", "\n", "# Without ordering_mode = \"partial\", one must limit the data at \"read\" time to reduce bytes scanned.\n", "pypi = bpd.read_gbq_table(\n", " \"bigquery-public-data.pypi.file_downloads\",\n", " columns=[\"timestamp\", \"project\"],\n", - " filters=[(\"timestamp\", \">\", last_30_days)],\n", + " filters=[(\"timestamp\", \">\", last_7_days)],\n", ")\n", - "```" + "```\n", + "\n", + "`head()` is not available when no ordering has been established. It fails with `OrderRequiredError`. Use `peek()` instead to download a sample of the data. This will be much more efficient, as the query doesn't need to order all rows to determine which are first." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Query job 423d9d93-1495-4c76-b8c2-e830a6e19ff4 is DONE. 110.3 MB processed. Open Job" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timestampcountry_codeurlprojectfiledetailstls_protocoltls_cipher
02024-09-18 18:15:04+00:00US/packages/ff/c8/4cd4b2834012ffc71ae3fd69187f08...aiobreaker{'filename': 'aiobreaker-1.2.0-py3-none-any.wh...{'installer': {'name': 'pip', 'version': '21.1...TLSv1.3TLS_AES_128_GCM_SHA256
12024-09-18 18:29:50+00:00US/packages/21/8e/4562029e179226051cd4aa3135444d...aiobotocore{'filename': 'aiobotocore-1.3.0.tar.gz', 'proj...{'installer': {'name': 'pip', 'version': '24.1...TLSv1.2ECDHE-RSA-AES128-GCM-SHA256
22024-09-18 18:22:14+00:00US/packages/11/16/4226e59bb72e096d9809ccedf349a1...aiobotocore{'filename': 'aiobotocore-2.0.1.tar.gz', 'proj...{'installer': {'name': 'pip', 'version': '24.2...TLSv1.2ECDHE-RSA-AES128-GCM-SHA256
32024-09-18 18:22:08+00:00US/packages/11/16/4226e59bb72e096d9809ccedf349a1...aiobotocore{'filename': 'aiobotocore-2.0.1.tar.gz', 'proj...{'installer': {'name': 'pip', 'version': '24.2...TLSv1.2ECDHE-RSA-AES128-GCM-SHA256
42024-09-18 18:29:22+00:00US/packages/54/b7/453119271cc4c36b07fdeab9b0ff25...aiobotocore{'filename': 'aiobotocore-2.3.3.tar.gz', 'proj...{'installer': {'name': 'pip', 'version': '24.1...TLSv1.2ECDHE-RSA-AES128-GCM-SHA256
\n", + "
" + ], + "text/plain": [ + " timestamp country_code \\\n", + "0 2024-09-18 18:15:04+00:00 US \n", + "1 2024-09-18 18:29:50+00:00 US \n", + "2 2024-09-18 18:22:14+00:00 US \n", + "3 2024-09-18 18:22:08+00:00 US \n", + "4 2024-09-18 18:29:22+00:00 US \n", + "\n", + " url project \\\n", + "0 /packages/ff/c8/4cd4b2834012ffc71ae3fd69187f08... aiobreaker \n", + "1 /packages/21/8e/4562029e179226051cd4aa3135444d... aiobotocore \n", + "2 /packages/11/16/4226e59bb72e096d9809ccedf349a1... aiobotocore \n", + "3 /packages/11/16/4226e59bb72e096d9809ccedf349a1... aiobotocore \n", + "4 /packages/54/b7/453119271cc4c36b07fdeab9b0ff25... aiobotocore \n", + "\n", + " file \\\n", + "0 {'filename': 'aiobreaker-1.2.0-py3-none-any.wh... \n", + "1 {'filename': 'aiobotocore-1.3.0.tar.gz', 'proj... \n", + "2 {'filename': 'aiobotocore-2.0.1.tar.gz', 'proj... \n", + "3 {'filename': 'aiobotocore-2.0.1.tar.gz', 'proj... \n", + "4 {'filename': 'aiobotocore-2.3.3.tar.gz', 'proj... \n", + "\n", + " details tls_protocol \\\n", + "0 {'installer': {'name': 'pip', 'version': '21.1... TLSv1.3 \n", + "1 {'installer': {'name': 'pip', 'version': '24.1... TLSv1.2 \n", + "2 {'installer': {'name': 'pip', 'version': '24.2... TLSv1.2 \n", + "3 {'installer': {'name': 'pip', 'version': '24.2... TLSv1.2 \n", + "4 {'installer': {'name': 'pip', 'version': '24.1... TLSv1.2 \n", + "\n", + " tls_cipher \n", + "0 TLS_AES_128_GCM_SHA256 \n", + "1 ECDHE-RSA-AES128-GCM-SHA256 \n", + "2 ECDHE-RSA-AES128-GCM-SHA256 \n", + "3 ECDHE-RSA-AES128-GCM-SHA256 \n", + "4 ECDHE-RSA-AES128-GCM-SHA256 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Warning: Ensure bpd.options.bigquery.ordering_mode = \"partial\" or else\n", + "# this query() will cause a full table scan because of the sequential index.\n", + "assert bpd.options.bigquery.ordering_mode == \"partial\"\n", + "pypi.peek()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Query job 3a421217-59e2-4722-8382-0930f0a3b9ee is DONE. 1.5 MB processed. Open Job" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SnapshotAtSystemNameVersionDependencyMinimumDepth
02024-08-29 04:39:16.121656+00:00PYPIzxkane-cdk-construct-simple-nat0.2.89{'System': 'PYPI', 'Name': 'attrs', 'Version':...2
12024-08-29 04:39:16.121656+00:00PYPIzxkane-cdk-construct-simple-nat0.2.82{'System': 'PYPI', 'Name': 'attrs', 'Version':...2
22024-08-29 04:39:16.121656+00:00PYPIzxkane-cdk-construct-simple-nat0.2.88{'System': 'PYPI', 'Name': 'attrs', 'Version':...2
32024-08-29 04:39:16.121656+00:00PYPIzxkane-cdk-construct-simple-nat0.2.91{'System': 'PYPI', 'Name': 'attrs', 'Version':...2
42024-08-29 04:39:16.121656+00:00PYPIzxkane-cdk-construct-simple-nat0.2.77{'System': 'PYPI', 'Name': 'attrs', 'Version':...2
\n", + "
" + ], + "text/plain": [ + " SnapshotAt System Name \\\n", + "0 2024-08-29 04:39:16.121656+00:00 PYPI zxkane-cdk-construct-simple-nat \n", + "1 2024-08-29 04:39:16.121656+00:00 PYPI zxkane-cdk-construct-simple-nat \n", + "2 2024-08-29 04:39:16.121656+00:00 PYPI zxkane-cdk-construct-simple-nat \n", + "3 2024-08-29 04:39:16.121656+00:00 PYPI zxkane-cdk-construct-simple-nat \n", + "4 2024-08-29 04:39:16.121656+00:00 PYPI zxkane-cdk-construct-simple-nat \n", + "\n", + " Version Dependency MinimumDepth \n", + "0 0.2.89 {'System': 'PYPI', 'Name': 'attrs', 'Version':... 2 \n", + "1 0.2.82 {'System': 'PYPI', 'Name': 'attrs', 'Version':... 2 \n", + "2 0.2.88 {'System': 'PYPI', 'Name': 'attrs', 'Version':... 2 \n", + "3 0.2.91 {'System': 'PYPI', 'Name': 'attrs', 'Version':... 2 \n", + "4 0.2.77 {'System': 'PYPI', 'Name': 'attrs', 'Version':... 2 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "deps.peek()" ] }, { @@ -167,7 +460,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -185,11 +478,111 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "Query job 5b69917f-9ed7-483a-9241-0083acea9990 is DONE. 1.1 GB processed. Open Job" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Query job ac94c55d-ce8e-4694-ad97-55c933cf3053 is DONE. 123 Bytes processed. Open Job" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NameDependencyNamesize
0pandaspytz168
1pandasnumpy168
2pandaspython-dateutil168
3pandassix168
4pandastzdata56
\n", + "
" + ], + "text/plain": [ + " Name DependencyName size\n", + "0 pandas pytz 168\n", + "1 pandas numpy 168\n", + "2 pandas python-dateutil 168\n", + "3 pandas six 168\n", + "4 pandas tzdata 56" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "pandas_deps = deps[deps[\"Name\"] == \"pandas\"].groupby([\"Name\", \"DependencyName\"], as_index=False).size()" + "package_deps = deps[deps[\"Name\"] == package_name].groupby([\"Name\", \"DependencyName\"], as_index=False).size()\n", + "package_deps.peek()" ] }, { @@ -205,14 +598,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "pandas_and_deps = bpd.concat(\n", " [\n", - " pandas_deps.drop(columns=[\"Name\", \"size\"]).rename(columns={\"DependencyName\": \"Name\"}),\n", - " bpd.DataFrame({\"Name\": [\"pandas\"]}),\n", + " package_deps.drop(columns=[\"Name\", \"size\"]).rename(columns={\"DependencyName\": \"Name\"}),\n", + " bpd.DataFrame({\"Name\": [package_name]}),\n", " ],\n", "\n", " # To join DataFrames that have a NULL index, set ignore_index = True.\n", @@ -229,7 +622,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -240,18 +633,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Create a time series to visualize by grouping by the date, extracted from the `timestamp` column." + "Create a time series to visualize by grouping by the date, extracted from the `timestamp` column.\n", + "\n", + "**Note:** If you don't `peek()` at your data and only do grouped aggregations, BigQuery DataFrames can eliminate unnecessary ordering from the compilation even without `ordering_mode = \"partial\"`.\n", + "\n", + "When BigQuery DataFrames aggregates over columns, those columns provide a\n", + "unique key post-aggregation that is used for ordering. Any ordering applied before is overridden. By aggregating over\n", + "a time series, the line plots will render in the expected order." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "Query job 88c93524-d74f-4bbd-b6b1-0fb752ebedde is DONE. 28.6 GB processed. Open Job" + "Query job 57037a4c-5b8b-4f30-a5c6-bfeb9731a38f is DONE. 270.4 GB processed. Open Job" ], "text/plain": [ "" @@ -259,14 +658,86 @@ }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Query job a8ea0b8e-2260-4175-b80d-668a2411c6ad is DONE. 2.0 kB processed. Open Job" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "date project \n", + "2024-09-17 numpy 2572982\n", + " pandas 2195692\n", + " python-dateutil 3608119\n", + " pytz 1863133\n", + " six 3064640\n", + " tzdata 991989\n", + "2024-09-18 numpy 13282573\n", + " pandas 10856758\n", + " python-dateutil 17877058\n", + " pytz 9450103\n", + " six 15225000\n", + " tzdata 5230039\n", + "2024-09-19 numpy 13637868\n", + " pandas 11077817\n", + " python-dateutil 18449777\n", + " pytz 9690329\n", + " six 15706263\n", + " tzdata 5473910\n", + "2024-09-20 numpy 12609524\n", + " pandas 10758593\n", + " python-dateutil 17257536\n", + " pytz 9082050\n", + " six 14489456\n", + " tzdata 5206738\n", + "2024-09-21 numpy 8316481\n", + " pandas 7483241\n", + " python-dateutil 11604691\n", + " pytz 5494178\n", + " six 8814983\n", + " tzdata 3141578\n", + "2024-09-22 numpy 7768078\n", + " pandas 6566272\n", + " python-dateutil 10835755\n", + " pytz 5130018\n", + " six 8297507\n", + " tzdata 2811247\n", + "2024-09-23 numpy 12389164\n", + " pandas 10758931\n", + " python-dateutil 17153013\n", + " pytz 9045824\n", + " six 14512209\n", + " tzdata 5214048\n", + "2024-09-24 numpy 10385658\n", + " pandas 8830996\n", + " python-dateutil 14066307\n", + " pytz 7425446\n", + " six 11917222\n", + " tzdata 4550626\n", + "dtype: Int64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "# When BigQuery DataFrames aggregates over columns, those columns provide a\n", - "# unique key post-aggregation that is used for ordering. By aggregating over\n", - "# a time series, the line plots will render in the expexted order.\n", "pandas_pypi = pandas_pypi.assign(date=pandas_pypi[\"timestamp\"].dt.date)\n", - "downloads_per_day = pandas_pypi.groupby([\"date\", \"project\"]).size().unstack()" + "downloads_per_day = pandas_pypi.groupby([\"date\", \"project\"]).size()\n", + "\n", + "# Cache after the aggregation so that the aggregation only runs once.\n", + "downloads_per_day.cache()\n", + "downloads_per_day.to_pandas()" ] }, { @@ -278,13 +749,25 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "Query job 09bcc1a0-def3-474f-acd5-1d55b9653e07 is DONE. 28.6 GB processed. Open Job" + "Query job 319558aa-e092-4fd0-a8aa-447fca216a57 is DONE. 1.6 kB processed. Open Job" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Query job e64eb861-bd12-4748-9c29-d97990aa1241 is DONE. 1.2 kB processed. Open Job" ], "text/plain": [ "" @@ -299,13 +782,13 @@ "" ] }, - "execution_count": 19, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -315,8 +798,15 @@ } ], "source": [ - "downloads_per_day.plot.line(rot=45, ylabel=\"daily downloads\", ylim=(0, 2e7))" + "downloads_per_day.unstack().plot.line(rot=45, ylabel=\"daily downloads\", ylim=(0, 2e7))" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -335,7 +825,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/samples/snippets/linear_regression_tutorial_test.py b/samples/snippets/linear_regression_tutorial_test.py new file mode 100644 index 0000000000..0c861d1120 --- /dev/null +++ b/samples/snippets/linear_regression_tutorial_test.py @@ -0,0 +1,42 @@ +# Copyright 2024 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. + + +def test_linear_regression(random_model_id: str) -> None: + your_model_id = random_model_id + # [START bigquery_dataframes_bqml_linear_regression] + from bigframes.ml.linear_model import LinearRegression + import bigframes.pandas as bpd + + # Load data from BigQuery + bq_df = bpd.read_gbq("bigquery-public-data.ml_datasets.penguins") + + # Drop rows with nulls to get training data + training_data = bq_df.dropna(subset=["body_mass_g"]) + + # Specify your feature (or input) columns and the label (or output) column: + feature_columns = training_data.drop(columns=["body_mass_g"]) + label_columns = training_data[["body_mass_g"]] + + # Create the linear model + model = LinearRegression() + model.fit(feature_columns, label_columns) + model.to_gbq( + your_model_id, # For example: "bqml_tutorial.penguins_model" + replace=True, + ) + # [END bigquery_dataframes_bqml_linear_regression] + assert feature_columns is not None + assert label_columns is not None + assert model is not None diff --git a/tests/system/conftest.py b/tests/system/conftest.py index 5ee2dc6397..d9246eecfb 100644 --- a/tests/system/conftest.py +++ b/tests/system/conftest.py @@ -154,9 +154,9 @@ def session_load() -> Generator[bigframes.Session, None, None]: session.close() # close generated session at cleanup time -@pytest.fixture(scope="session", params=["ordered", "unordered"]) +@pytest.fixture(scope="session", params=["strict", "partial"]) def maybe_ordered_session(request) -> Generator[bigframes.Session, None, None]: - context = bigframes.BigQueryOptions(location="US", ordering_mode="partial") + context = bigframes.BigQueryOptions(location="US", ordering_mode=request.param) session = bigframes.Session(context=context) yield session session.close() # close generated session at cleanup type diff --git a/tests/system/large/ml/test_compose.py b/tests/system/large/ml/test_compose.py index 59c5a1538f..ba963837e5 100644 --- a/tests/system/large/ml/test_compose.py +++ b/tests/system/large/ml/test_compose.py @@ -36,6 +36,32 @@ def test_columntransformer_standalone_fit_and_transform( preprocessing.MinMaxScaler(), ["culmen_length_mm"], ), + ( + "increment", + compose.SQLScalarColumnTransformer("{0}+1"), + ["culmen_length_mm", "flipper_length_mm"], + ), + ( + "length", + compose.SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN -1 ELSE LENGTH({0}) END", + target_column="len_{0}", + ), + "species", + ), + ( + "ohe", + compose.SQLScalarColumnTransformer( + "CASE WHEN {0}='Adelie Penguin (Pygoscelis adeliae)' THEN 1 ELSE 0 END", + target_column="ohe_adelie", + ), + "species", + ), + ( + "identity", + compose.SQLScalarColumnTransformer("{0}", target_column="{0}"), + ["culmen_length_mm", "flipper_length_mm"], + ), ] ) @@ -51,6 +77,12 @@ def test_columntransformer_standalone_fit_and_transform( "standard_scaled_culmen_length_mm", "min_max_scaled_culmen_length_mm", "standard_scaled_flipper_length_mm", + "transformed_culmen_length_mm", + "transformed_flipper_length_mm", + "len_species", + "ohe_adelie", + "culmen_length_mm", + "flipper_length_mm", ], index=[1633, 1672, 1690], col_exact=False, @@ -70,6 +102,19 @@ def test_columntransformer_standalone_fit_transform(new_penguins_df): preprocessing.StandardScaler(), ["culmen_length_mm", "flipper_length_mm"], ), + ( + "length", + compose.SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN -1 ELSE LENGTH({0}) END", + target_column="len_{0}", + ), + "species", + ), + ( + "identity", + compose.SQLScalarColumnTransformer("{0}", target_column="{0}"), + ["culmen_length_mm", "flipper_length_mm"], + ), ] ) @@ -83,6 +128,9 @@ def test_columntransformer_standalone_fit_transform(new_penguins_df): "onehotencoded_species", "standard_scaled_culmen_length_mm", "standard_scaled_flipper_length_mm", + "len_species", + "culmen_length_mm", + "flipper_length_mm", ], index=[1633, 1672, 1690], col_exact=False, @@ -102,6 +150,27 @@ def test_columntransformer_save_load(new_penguins_df, dataset_id): preprocessing.StandardScaler(), ["culmen_length_mm", "flipper_length_mm"], ), + ( + "length", + compose.SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN -1 ELSE LENGTH({0}) END", + target_column="len_{0}", + ), + "species", + ), + ( + "identity", + compose.SQLScalarColumnTransformer("{0}", target_column="{0}"), + ["culmen_length_mm", "flipper_length_mm"], + ), + ( + "flexname", + compose.SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN -1 ELSE LENGTH({0}) END", + target_column="Flex {0} Name", + ), + "species", + ), ] ) transformer.fit( @@ -122,6 +191,36 @@ def test_columntransformer_save_load(new_penguins_df, dataset_id): ), ("standard_scaler", preprocessing.StandardScaler(), "culmen_length_mm"), ("standard_scaler", preprocessing.StandardScaler(), "flipper_length_mm"), + ( + "sql_scalar_column_transformer", + compose.SQLScalarColumnTransformer( + "CASE WHEN species IS NULL THEN -1 ELSE LENGTH(species) END", + target_column="len_species", + ), + "?len_species", + ), + ( + "sql_scalar_column_transformer", + compose.SQLScalarColumnTransformer( + "flipper_length_mm", target_column="flipper_length_mm" + ), + "?flipper_length_mm", + ), + ( + "sql_scalar_column_transformer", + compose.SQLScalarColumnTransformer( + "culmen_length_mm", target_column="culmen_length_mm" + ), + "?culmen_length_mm", + ), + ( + "sql_scalar_column_transformer", + compose.SQLScalarColumnTransformer( + "CASE WHEN species IS NULL THEN -1 ELSE LENGTH(species) END ", + target_column="Flex species Name", + ), + "?Flex species Name", + ), ] assert set(reloaded_transformer.transformers) == set(expected) assert reloaded_transformer._bqml_model is not None @@ -136,6 +235,10 @@ def test_columntransformer_save_load(new_penguins_df, dataset_id): "onehotencoded_species", "standard_scaled_culmen_length_mm", "standard_scaled_flipper_length_mm", + "len_species", + "culmen_length_mm", + "flipper_length_mm", + "Flex species Name", ], index=[1633, 1672, 1690], col_exact=False, diff --git a/tests/system/load/test_llm.py b/tests/system/load/test_llm.py index 1d13300115..51b45485ad 100644 --- a/tests/system/load/test_llm.py +++ b/tests/system/load/test_llm.py @@ -156,3 +156,27 @@ def test_claude3_text_generator_predict_with_params_success( utils.check_pandas_df_schema_and_index( df, columns=utils.ML_GENERATE_TEXT_OUTPUT, index=3, col_exact=False ) + + +@pytest.mark.parametrize( + "model_name", + ("claude-3-sonnet", "claude-3-haiku", "claude-3-5-sonnet", "claude-3-opus"), +) +@pytest.mark.flaky(retries=3, delay=120) +def test_claude3_text_generator_predict_multi_col_success( + llm_text_df, model_name, session, session_us_east5, bq_connection +): + if model_name in ("claude-3-5-sonnet", "claude-3-opus"): + session = session_us_east5 + + llm_text_df["additional_col"] = 1 + claude3_text_generator_model = llm.Claude3TextGenerator( + model_name=model_name, connection_name=bq_connection, session=session + ) + df = claude3_text_generator_model.predict(llm_text_df).to_pandas() + utils.check_pandas_df_schema_and_index( + df, + columns=utils.ML_GENERATE_TEXT_OUTPUT + ["additional_col"], + index=3, + col_exact=False, + ) diff --git a/tests/system/small/bigquery/test_approx_agg.py b/tests/system/small/bigquery/test_approx_agg.py new file mode 100644 index 0000000000..c88f5850f8 --- /dev/null +++ b/tests/system/small/bigquery/test_approx_agg.py @@ -0,0 +1,76 @@ +# Copyright 2024 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 pytest + +import bigframes.bigquery as bbq +import bigframes.pandas as bpd + + +@pytest.mark.parametrize( + ("data", "expected"), + [ + pytest.param( + [1, 2, 3, 3, 2], [{"value": 3, "count": 2}, {"value": 2, "count": 2}] + ), + pytest.param( + ["apple", "apple", "pear", "pear", "pear", "banana"], + [{"value": "pear", "count": 3}, {"value": "apple", "count": 2}], + ), + pytest.param( + [True, False, True, False, True], + [{"value": True, "count": 3}, {"value": False, "count": 2}], + ), + pytest.param( + [], + [], + ), + pytest.param( + [[1, 2], [1], [1, 2]], + [], + marks=pytest.mark.xfail(raises=TypeError), + ), + ], + ids=["int64", "string", "bool", "null", "array"], +) +def test_approx_top_count_w_dtypes(data, expected): + s = bpd.Series(data) + result = bbq.approx_top_count(s, number=2) + assert result == expected + + +@pytest.mark.parametrize( + ("number", "expected"), + [ + pytest.param( + 0, + [], + marks=pytest.mark.xfail(raises=ValueError), + ), + pytest.param(1, [{"value": 3, "count": 2}]), + pytest.param( + 4, + [ + {"value": 3, "count": 2}, + {"value": 2, "count": 2}, + {"value": 1, "count": 1}, + ], + ), + ], + ids=["zero", "one", "full"], +) +def test_approx_top_count_w_numbers(number, expected): + s = bpd.Series([1, 2, 3, 3, 2]) + result = bbq.approx_top_count(s, number=number) + assert result == expected diff --git a/tests/system/small/ml/test_llm.py b/tests/system/small/ml/test_llm.py index 3093a36534..a4a09731a1 100644 --- a/tests/system/small/ml/test_llm.py +++ b/tests/system/small/ml/test_llm.py @@ -15,6 +15,7 @@ import pytest from bigframes.ml import llm +import bigframes.pandas as bpd from tests.system import utils @@ -166,6 +167,20 @@ def test_text_generator_predict_arbitrary_col_label_success( ) +@pytest.mark.flaky(retries=2) +def test_text_generator_predict_multiple_cols_success( + palm2_text_generator_model, llm_text_df: bpd.DataFrame +): + df = llm_text_df.assign(additional_col=1) + pd_df = palm2_text_generator_model.predict(df).to_pandas() + utils.check_pandas_df_schema_and_index( + pd_df, + columns=utils.ML_GENERATE_TEXT_OUTPUT + ["additional_col"], + index=3, + col_exact=False, + ) + + @pytest.mark.flaky(retries=2) def test_text_generator_predict_with_params_success( palm2_text_generator_model, llm_text_df @@ -212,11 +227,33 @@ def test_text_embedding_generator_predict_default_params_success( model_name=model_name, connection_name=bq_connection, session=session ) df = text_embedding_model.predict(llm_text_df).to_pandas() - assert df.shape == (3, 4) - assert "ml_generate_embedding_result" in df.columns - series = df["ml_generate_embedding_result"] - value = series[0] - assert len(value) == 768 + utils.check_pandas_df_schema_and_index( + df, columns=utils.ML_GENERATE_EMBEDDING_OUTPUT, index=3, col_exact=False + ) + assert len(df["ml_generate_embedding_result"][0]) == 768 + + +@pytest.mark.parametrize( + "model_name", + ("text-embedding-004", "text-multilingual-embedding-002"), +) +@pytest.mark.flaky(retries=2) +def test_text_embedding_generator_multi_cols_predict_success( + llm_text_df: bpd.DataFrame, model_name, session, bq_connection +): + df = llm_text_df.assign(additional_col=1) + df = df.rename(columns={"prompt": "content"}) + text_embedding_model = llm.TextEmbeddingGenerator( + model_name=model_name, connection_name=bq_connection, session=session + ) + pd_df = text_embedding_model.predict(df).to_pandas() + utils.check_pandas_df_schema_and_index( + pd_df, + columns=utils.ML_GENERATE_EMBEDDING_OUTPUT + ["additional_col"], + index=3, + col_exact=False, + ) + assert len(pd_df["ml_generate_embedding_result"][0]) == 768 @pytest.mark.parametrize( @@ -295,6 +332,33 @@ def test_gemini_text_generator_predict_with_params_success( ) +@pytest.mark.parametrize( + "model_name", + ( + "gemini-pro", + "gemini-1.5-pro-preview-0514", + "gemini-1.5-flash-preview-0514", + "gemini-1.5-pro-001", + "gemini-1.5-flash-001", + ), +) +@pytest.mark.flaky(retries=2) +def test_gemini_text_generator_multi_cols_predict_success( + llm_text_df: bpd.DataFrame, model_name, session, bq_connection +): + df = llm_text_df.assign(additional_col=1) + gemini_text_generator_model = llm.GeminiTextGenerator( + model_name=model_name, connection_name=bq_connection, session=session + ) + pd_df = gemini_text_generator_model.predict(df).to_pandas() + utils.check_pandas_df_schema_and_index( + pd_df, + columns=utils.ML_GENERATE_TEXT_OUTPUT + ["additional_col"], + index=3, + col_exact=False, + ) + + @pytest.mark.flaky(retries=2) def test_llm_palm_score(llm_fine_tune_df_default_index): model = llm.PaLM2TextGenerator(model_name="text-bison") diff --git a/tests/system/small/test_dataframe.py b/tests/system/small/test_dataframe.py index 0a637e983f..340df93791 100644 --- a/tests/system/small/test_dataframe.py +++ b/tests/system/small/test_dataframe.py @@ -567,6 +567,30 @@ def test_repr_w_all_rows(scalars_dfs): assert actual == expected +def test_join_repr(scalars_dfs_maybe_ordered): + scalars_df, scalars_pandas_df = scalars_dfs_maybe_ordered + + scalars_df = ( + scalars_df[["int64_col"]] + .join(scalars_df.set_index("int64_col")[["int64_too"]]) + .sort_index() + ) + scalars_pandas_df = ( + scalars_pandas_df[["int64_col"]] + .join(scalars_pandas_df.set_index("int64_col")[["int64_too"]]) + .sort_index() + ) + # Pandas join result index name seems to depend on the index values in a way that bigframes can't match exactly + scalars_pandas_df.index.name = None + + actual = repr(scalars_df) + + with display_options.pandas_repr(bigframes.options.display): + expected = repr(scalars_pandas_df) + + assert actual == expected + + def test_repr_html_w_all_rows(scalars_dfs): scalars_df, _ = scalars_dfs # get a pandas df of the expected format diff --git a/tests/system/utils.py b/tests/system/utils.py index 26e3e97e24..83d0e683bc 100644 --- a/tests/system/utils.py +++ b/tests/system/utils.py @@ -50,6 +50,12 @@ "ml_generate_text_status", "prompt", ] +ML_GENERATE_EMBEDDING_OUTPUT = [ + "ml_generate_embedding_result", + "ml_generate_embedding_statistics", + "ml_generate_embedding_status", + "content", +] def skip_legacy_pandas(test): diff --git a/tests/unit/ml/test_compose.py b/tests/unit/ml/test_compose.py index 60dcc75b63..7643f76e56 100644 --- a/tests/unit/ml/test_compose.py +++ b/tests/unit/ml/test_compose.py @@ -11,11 +11,17 @@ # 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. +from unittest import mock +from google.cloud import bigquery +import pytest import sklearn.compose as sklearn_compose # type: ignore import sklearn.preprocessing as sklearn_preprocessing # type: ignore from bigframes.ml import compose, preprocessing +from bigframes.ml.compose import ColumnTransformer, SQLScalarColumnTransformer +from bigframes.ml.core import BqmlModel +import bigframes.pandas as bpd def test_columntransformer_init_expectedtransforms(): @@ -173,3 +179,403 @@ def test_columntransformer_repr_matches_sklearn(): ) assert bf_column_transformer.__repr__() == sk_column_transformer.__repr__() + + +@pytest.fixture(scope="session") +def mock_X(): + mock_df = mock.create_autospec(spec=bpd.DataFrame) + return mock_df + + +def test_columntransformer_init_with_sqltransformers(): + ident_transformer = SQLScalarColumnTransformer("{0}", target_column="ident_{0}") + len1_transformer = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN -2 ELSE LENGTH({0}) END", target_column="len1_{0}" + ) + len2_transformer = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN 99 ELSE LENGTH({0}) END", target_column="len2_{0}" + ) + label_transformer = preprocessing.LabelEncoder() + column_transformer = compose.ColumnTransformer( + [ + ( + "ident_trafo", + ident_transformer, + ["culmen_length_mm", "flipper_length_mm"], + ), + ("len1_trafo", len1_transformer, ["species"]), + ("len2_trafo", len2_transformer, ["species"]), + ("label", label_transformer, "species"), + ] + ) + + assert column_transformer.transformers_ == [ + ("ident_trafo", ident_transformer, "culmen_length_mm"), + ("ident_trafo", ident_transformer, "flipper_length_mm"), + ("len1_trafo", len1_transformer, "species"), + ("len2_trafo", len2_transformer, "species"), + ("label", label_transformer, "species"), + ] + + +def test_columntransformer_repr_sqltransformers(): + ident_transformer = SQLScalarColumnTransformer("{0}", target_column="ident_{0}") + len1_transformer = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN -2 ELSE LENGTH({0}) END", target_column="len1_{0}" + ) + len2_transformer = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN 99 ELSE LENGTH({0}) END", target_column="len2_{0}" + ) + label_transformer = preprocessing.LabelEncoder() + column_transformer = compose.ColumnTransformer( + [ + ( + "ident_trafo", + ident_transformer, + ["culmen_length_mm", "flipper_length_mm"], + ), + ("len1_trafo", len1_transformer, ["species"]), + ("len2_trafo", len2_transformer, ["species"]), + ("label", label_transformer, "species"), + ] + ) + + expected = """ColumnTransformer(transformers=[('ident_trafo', + SQLScalarColumnTransformer(sql='{0}', target_column='ident_{0}'), + ['culmen_length_mm', 'flipper_length_mm']), + ('len1_trafo', + SQLScalarColumnTransformer(sql='CASE WHEN {0} IS NULL THEN -2 ELSE LENGTH({0}) END', target_column='len1_{0}'), + ['species']), + ('len2_trafo', + SQLScalarColumnTransformer(sql='CASE WHEN {0} IS NULL THEN 99 ELSE LENGTH({0}) END', target_column='len2_{0}'), + ['species']), + ('label', LabelEncoder(), 'species')])""" + actual = column_transformer.__repr__() + assert expected == actual + + +def test_customtransformer_compile_sql(mock_X): + ident_trafo = SQLScalarColumnTransformer("{0}", target_column="ident_{0}") + sqls = ident_trafo._compile_to_sql(X=mock_X, columns=["col1", "col2"]) + assert sqls == [ + "col1 AS ident_col1", + "col2 AS ident_col2", + ] + + len1_trafo = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN -5 ELSE LENGTH({0}) END", target_column="len1_{0}" + ) + sqls = len1_trafo._compile_to_sql(X=mock_X, columns=["col1", "col2"]) + assert sqls == [ + "CASE WHEN col1 IS NULL THEN -5 ELSE LENGTH(col1) END AS len1_col1", + "CASE WHEN col2 IS NULL THEN -5 ELSE LENGTH(col2) END AS len1_col2", + ] + + len2_trafo = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN 99 ELSE LENGTH({0}) END", target_column="len2_{0}" + ) + sqls = len2_trafo._compile_to_sql(X=mock_X, columns=["col1", "col2"]) + assert sqls == [ + "CASE WHEN col1 IS NULL THEN 99 ELSE LENGTH(col1) END AS len2_col1", + "CASE WHEN col2 IS NULL THEN 99 ELSE LENGTH(col2) END AS len2_col2", + ] + + +def create_bq_model_mock(mocker, transform_columns, feature_columns=None): + properties = {"transformColumns": transform_columns} + mock_bq_model = bigquery.Model("model_project.model_dataset.model_id") + type(mock_bq_model)._properties = mock.PropertyMock(return_value=properties) + if feature_columns: + result = [ + bigquery.standard_sql.StandardSqlField(col, None) for col in feature_columns + ] + mocker.patch( + "google.cloud.bigquery.model.Model.feature_columns", + new_callable=mock.PropertyMock(return_value=result), + ) + + return mock_bq_model + + +@pytest.fixture +def bq_model_good(mocker): + return create_bq_model_mock( + mocker, + [ + { + "name": "ident_culmen_length_mm", + "type": {"typeKind": "INT64"}, + "transformSql": "culmen_length_mm /*CT.IDENT()*/", + }, + { + "name": "ident_flipper_length_mm", + "type": {"typeKind": "INT64"}, + "transformSql": "flipper_length_mm /*CT.IDENT()*/", + }, + { + "name": "len1_species", + "type": {"typeKind": "INT64"}, + "transformSql": "CASE WHEN species IS NULL THEN -5 ELSE LENGTH(species) END /*CT.LEN1()*/", + }, + { + "name": "len2_species", + "type": {"typeKind": "INT64"}, + "transformSql": "CASE WHEN species IS NULL THEN 99 ELSE LENGTH(species) END /*CT.LEN2([99])*/", + }, + { + "name": "labelencoded_county", + "type": {"typeKind": "INT64"}, + "transformSql": "ML.LABEL_ENCODER(county, 1000000, 0) OVER()", + }, + { + "name": "labelencoded_species", + "type": {"typeKind": "INT64"}, + "transformSql": "ML.LABEL_ENCODER(species, 1000000, 0) OVER()", + }, + ], + ) + + +@pytest.fixture +def bq_model_merge(mocker): + return create_bq_model_mock( + mocker, + [ + { + "name": "labelencoded_county", + "type": {"typeKind": "INT64"}, + "transformSql": "ML.LABEL_ENCODER(county, 1000000, 0) OVER()", + }, + { + "name": "labelencoded_species", + "type": {"typeKind": "INT64"}, + "transformSql": "ML.LABEL_ENCODER(species, 1000000, 0) OVER()", + }, + ], + ["county", "species"], + ) + + +@pytest.fixture +def bq_model_no_merge(mocker): + return create_bq_model_mock( + mocker, + [ + { + "name": "ident_culmen_length_mm", + "type": {"typeKind": "INT64"}, + "transformSql": "culmen_length_mm /*CT.IDENT()*/", + } + ], + ["culmen_length_mm"], + ) + + +@pytest.fixture +def bq_model_unknown_ML(mocker): + return create_bq_model_mock( + mocker, + [ + { + "name": "unknownml_culmen_length_mm", + "type": {"typeKind": "INT64"}, + "transformSql": "ML.UNKNOWN(culmen_length_mm)", + }, + { + "name": "labelencoded_county", + "type": {"typeKind": "INT64"}, + "transformSql": "ML.LABEL_ENCODER(county, 1000000, 0) OVER()", + }, + ], + ) + + +@pytest.fixture +def bq_model_flexnames(mocker): + return create_bq_model_mock( + mocker, + [ + { + "name": "Flex Name culmen_length_mm", + "type": {"typeKind": "INT64"}, + "transformSql": "culmen_length_mm", + }, + { + "name": "transformed_Culmen Length MM", + "type": {"typeKind": "INT64"}, + "transformSql": "`Culmen Length MM`*/", + }, + # test workaround for bug in get_model + { + "name": "Flex Name flipper_length_mm", + "type": {"typeKind": "INT64"}, + "transformSql": "flipper_length_mm AS `Flex Name flipper_length_mm`", + }, + { + "name": "transformed_Flipper Length MM", + "type": {"typeKind": "INT64"}, + "transformSql": "`Flipper Length MM` AS `transformed_Flipper Length MM`*/", + }, + ], + ) + + +def test_columntransformer_extract_from_bq_model_good(bq_model_good): + col_trans = ColumnTransformer._extract_from_bq_model(bq_model_good) + assert len(col_trans.transformers) == 6 + # normalize the representation for string comparing + col_trans.transformers.sort(key=lambda trafo: str(trafo)) + actual = col_trans.__repr__() + expected = """ColumnTransformer(transformers=[('label_encoder', + LabelEncoder(max_categories=1000001, + min_frequency=0), + 'county'), + ('label_encoder', + LabelEncoder(max_categories=1000001, + min_frequency=0), + 'species'), + ('sql_scalar_column_transformer', + SQLScalarColumnTransformer(sql='CASE WHEN species IS NULL THEN -5 ELSE LENGTH(species) END /*CT.LEN1()*/', target_column='len1_species'), + '?len1_species'), + ('sql_scalar_column_transformer', + SQLScalarColumnTransformer(sql='CASE WHEN species IS NULL THEN 99 ELSE LENGTH(species) END /*CT.LEN2([99])*/', target_column='len2_species'), + '?len2_species'), + ('sql_scalar_column_transformer', + SQLScalarColumnTransformer(sql='culmen_length_mm /*CT.IDENT()*/', target_column='ident_culmen_length_mm'), + '?ident_culmen_length_mm'), + ('sql_scalar_column_transformer', + SQLScalarColumnTransformer(sql='flipper_length_mm /*CT.IDENT()*/', target_column='ident_flipper_length_mm'), + '?ident_flipper_length_mm')])""" + assert expected == actual + + +def test_columntransformer_extract_from_bq_model_merge(bq_model_merge): + col_trans = ColumnTransformer._extract_from_bq_model(bq_model_merge) + assert isinstance(col_trans, ColumnTransformer) + merged_col_trans = col_trans._merge(bq_model_merge) + assert isinstance(merged_col_trans, preprocessing.LabelEncoder) + assert ( + merged_col_trans.__repr__() + == """LabelEncoder(max_categories=1000001, min_frequency=0)""" + ) + assert merged_col_trans._output_names == [ + "labelencoded_county", + "labelencoded_species", + ] + + +def test_columntransformer_extract_from_bq_model_no_merge(bq_model_no_merge): + col_trans = ColumnTransformer._extract_from_bq_model(bq_model_no_merge) + merged_col_trans = col_trans._merge(bq_model_no_merge) + assert isinstance(merged_col_trans, ColumnTransformer) + expected = """ColumnTransformer(transformers=[('sql_scalar_column_transformer', + SQLScalarColumnTransformer(sql='culmen_length_mm /*CT.IDENT()*/', target_column='ident_culmen_length_mm'), + '?ident_culmen_length_mm')])""" + actual = merged_col_trans.__repr__() + assert expected == actual + + +def test_columntransformer_extract_from_bq_model_unknown_ML(bq_model_unknown_ML): + try: + _ = ColumnTransformer._extract_from_bq_model(bq_model_unknown_ML) + assert False + except NotImplementedError as e: + assert "Unsupported transformer type" in e.args[0] + + +def test_columntransformer_extract_output_names(bq_model_good): + class BQMLModel(BqmlModel): + def __init__(self, bq_model): + self._model = bq_model + + col_trans = ColumnTransformer._extract_from_bq_model(bq_model_good) + col_trans._bqml_model = BQMLModel(bq_model_good) + col_trans._extract_output_names() + assert col_trans._output_names == [ + "ident_culmen_length_mm", + "ident_flipper_length_mm", + "len1_species", + "len2_species", + "labelencoded_county", + "labelencoded_species", + ] + + +def test_columntransformer_compile_to_sql(mock_X): + ident_transformer = SQLScalarColumnTransformer("{0}", target_column="ident_{0}") + len1_transformer = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN -2 ELSE LENGTH({0}) END", target_column="len1_{0}" + ) + len2_transformer = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN 99 ELSE LENGTH({0}) END", target_column="len2_{0}" + ) + label_transformer = preprocessing.LabelEncoder() + column_transformer = compose.ColumnTransformer( + [ + ( + "ident_trafo", + ident_transformer, + ["culmen_length_mm", "flipper_length_mm"], + ), + ("len1_trafo", len1_transformer, ["species"]), + ("len2_trafo", len2_transformer, ["species"]), + ("label", label_transformer, "species"), + ] + ) + sqls = column_transformer._compile_to_sql(mock_X) + assert sqls == [ + "culmen_length_mm AS ident_culmen_length_mm", + "flipper_length_mm AS ident_flipper_length_mm", + "CASE WHEN species IS NULL THEN -2 ELSE LENGTH(species) END AS len1_species", + "CASE WHEN species IS NULL THEN 99 ELSE LENGTH(species) END AS len2_species", + "ML.LABEL_ENCODER(species, 1000000, 0) OVER() AS labelencoded_species", + ] + + +def test_columntransformer_flexible_column_names(mock_X): + ident_transformer = SQLScalarColumnTransformer("{0}", target_column="ident {0}") + len1_transformer = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN -2 ELSE LENGTH({0}) END", target_column="len1_{0}" + ) + len2_transformer = SQLScalarColumnTransformer( + "CASE WHEN {0} IS NULL THEN 99 ELSE LENGTH({0}) END", target_column="len2_{0}" + ) + column_transformer = compose.ColumnTransformer( + [ + ( + "ident_trafo", + ident_transformer, + ["culmen_length_mm", "flipper_length_mm"], + ), + ("len1_trafo", len1_transformer, ["species shortname"]), + ("len2_trafo", len2_transformer, ["`species longname`"]), + ] + ) + sqls = column_transformer._compile_to_sql(mock_X) + assert sqls == [ + "culmen_length_mm AS `ident culmen_length_mm`", + "flipper_length_mm AS `ident flipper_length_mm`", + "CASE WHEN `species shortname` IS NULL THEN -2 ELSE LENGTH(`species shortname`) END AS `len1_species shortname`", + "CASE WHEN `species longname` IS NULL THEN 99 ELSE LENGTH(`species longname`) END AS `len2_species longname`", + ] + + +def test_columntransformer_extract_from_bq_model_flexnames(bq_model_flexnames): + col_trans = ColumnTransformer._extract_from_bq_model(bq_model_flexnames) + assert len(col_trans.transformers) == 4 + # normalize the representation for string comparing + col_trans.transformers.sort(key=lambda trafo: str(trafo)) + actual = col_trans.__repr__() + expected = """ColumnTransformer(transformers=[('sql_scalar_column_transformer', + SQLScalarColumnTransformer(sql='`Culmen Length MM`*/', target_column='transformed_Culmen Length MM'), + '?transformed_Culmen Length MM'), + ('sql_scalar_column_transformer', + SQLScalarColumnTransformer(sql='`Flipper Length MM` AS `transformed_Flipper Length MM`*/', target_column='transformed_Flipper Length MM'), + '?transformed_Flipper Length MM'), + ('sql_scalar_column_transformer', + SQLScalarColumnTransformer(sql='culmen_length_mm', target_column='Flex Name culmen_length_mm'), + '?Flex Name culmen_length_mm'), + ('sql_scalar_column_transformer', + SQLScalarColumnTransformer(sql='flipper_length_mm ', target_column='Flex Name flipper_length_mm'), + '?Flex Name flipper_length_mm')])""" + assert expected == actual diff --git a/third_party/bigframes_vendored/version.py b/third_party/bigframes_vendored/version.py index 5dda345fcb..60f4942175 100644 --- a/third_party/bigframes_vendored/version.py +++ b/third_party/bigframes_vendored/version.py @@ -12,4 +12,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "1.19.0" +__version__ = "1.20.0" pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy