Revert "feat: Add BigQuery ML CREATE MODEL support"

This reverts commit b809f81.

Author: tswast

bigframes/bigquery/__init__.py

@@ -18,7 +18,7 @@
 
 import sys
 
-from bigframes.bigquery import ai
+from bigframes.bigquery import ai, ml
 from bigframes.bigquery._operations.approx_agg import approx_top_count
 from bigframes.bigquery._operations.array import (
     array_agg,
@@ -157,4 +157,5 @@
     "struct",
     # Modules / SQL namespaces
     "ai",
+    "ml",
 ]

bigframes/bigquery/_operations/ml.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import typing
 from typing import Mapping, Optional, TYPE_CHECKING, Union
 
 import bigframes.core.log_adapter as log_adapter
@@ -52,34 +51,6 @@ def create_model(
 ) -> bigframes.ml.base.BaseEstimator:
     """
     Creates a BigQuery ML model.
-
-    Args:
-        model_name (str):
-            The name of the model in BigQuery.
-        replace (bool, default False):
-            Whether to replace the model if it already exists.
-        if_not_exists (bool, default False):
-            Whether to ignore the error if the model already exists.
-        transform (list[str], optional):
-            The TRANSFORM clause, which specifies the preprocessing steps to apply to the input data.
-        input_schema (Mapping[str, str], optional):
-            The INPUT clause, which specifies the schema of the input data.
-        output_schema (Mapping[str, str], optional):
-            The OUTPUT clause, which specifies the schema of the output data.
-        connection_name (str, optional):
-            The connection to use for the model.
-        options (Mapping[str, Union[str, int, float, bool, list]], optional):
-            The OPTIONS clause, which specifies the model options.
-        training_data (Union[dataframe.DataFrame, str], optional):
-            The query or DataFrame to use for training the model.
-        custom_holiday (Union[dataframe.DataFrame, str], optional):
-            The query or DataFrame to use for custom holiday data.
-        session (bigframes.session.Session, optional):
-            The BigFrames session to use. If not provided, the default session is used.
-
-    Returns:
-        bigframes.ml.base.BaseEstimator:
-            The created BigFrames model.
     """
     import bigframes.pandas as bpd
 

bigframes/bigquery/ml.py

@@ -12,7 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""This module integrates BigQuery ML functions."""
+"""This module exposes `BigQuery ML
+<https://docs.cloud.google.com/bigquery/docs/bqml-introduction>`_ functions
+by directly mapping to the equivalent function names in SQL syntax.
+
+For an interface more familiar to Scikit-Learn users, see :mod:`bigframes.ml`.
+"""
 
 from bigframes.bigquery._operations.ml import create_model
 

bigframes/core/compile/sqlglot/expressions/generic_ops.py

@@ -107,6 +107,7 @@ def _(expr: TypedExpr, op: ops.MapOp) -> sge.Expression:
             sge.If(this=sge.convert(key), true=sge.convert(value))
             for key, value in op.mappings
         ],
+        default=expr.expr,
     )
 
 

bigframes/core/compile/sqlglot/expressions/string_ops.py

@@ -18,6 +18,7 @@
 
 import sqlglot.expressions as sge
 
+from bigframes import dtypes
 from bigframes import operations as ops
 from bigframes.core.compile.sqlglot.expressions.typed_expr import TypedExpr
 import bigframes.core.compile.sqlglot.scalar_compiler as scalar_compiler
@@ -195,6 +196,9 @@ def _(expr: TypedExpr) -> sge.Expression:
 
 @register_unary_op(ops.len_op)
 def _(expr: TypedExpr) -> sge.Expression:
+    if dtypes.is_array_like(expr.dtype):
+        return sge.func("ARRAY_LENGTH", expr.expr)
+
     return sge.Length(this=expr.expr)
 
 
@@ -239,7 +243,7 @@ def to_startswith(pat: str) -> sge.Expression:
 
 @register_unary_op(ops.StrStripOp, pass_op=True)
 def _(expr: TypedExpr, op: ops.StrStripOp) -> sge.Expression:
-    return sge.Trim(this=sge.convert(op.to_strip), expression=expr.expr)
+    return sge.Trim(this=expr.expr, expression=sge.convert(op.to_strip))
 
 
 @register_unary_op(ops.StringSplitOp, pass_op=True)
@@ -284,27 +288,29 @@ def _(left: TypedExpr, right: TypedExpr) -> sge.Expression:
 
 @register_unary_op(ops.ZfillOp, pass_op=True)
 def _(expr: TypedExpr, op: ops.ZfillOp) -> sge.Expression:
+    length_expr = sge.Greatest(
+        expressions=[sge.Length(this=expr.expr), sge.convert(op.width)]
+    )
     return sge.Case(
         ifs=[
             sge.If(
-                this=sge.EQ(
-                    this=sge.Substring(
-                        this=expr.expr, start=sge.convert(1), length=sge.convert(1)
-                    ),
-                    expression=sge.convert("-"),
+                this=sge.func(
+                    "STARTS_WITH",
+                    expr.expr,
+                    sge.convert("-"),
                 ),
                 true=sge.Concat(
                     expressions=[
                         sge.convert("-"),
                         sge.func(
                             "LPAD",
-                            sge.Substring(this=expr.expr, start=sge.convert(1)),
-                            sge.convert(op.width - 1),
+                            sge.Substring(this=expr.expr, start=sge.convert(2)),
+                            length_expr - 1,
                             sge.convert("0"),
                         ),
                     ]
                 ),
             )
         ],
-        default=sge.func("LPAD", expr.expr, sge.convert(op.width), sge.convert("0")),
+        default=sge.func("LPAD", expr.expr, length_expr, sge.convert("0")),
     )

bigframes/core/sql/ml.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import typing
 from typing import Mapping, Optional, Union
 
 import bigframes.core.compile.googlesql as googlesql

bigframes/ml/__init__.py

@@ -12,19 +12,82 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""BigQuery DataFrames ML provides a SKLearn-like API on the BigQuery engine."""
+"""BigQuery DataFrames ML provides a SKLearn-like API on the BigQuery engine.
+
+.. code:: python
+
+    from bigframes.ml.linear_model import LinearRegression
+    model = LinearRegression()
+    model.fit(feature_columns, label_columns)
+    model.predict(feature_columns_from_test_data)
+
+You can also save your fit parameters to BigQuery for later use.
+
+.. code:: python
+
+    import bigframes.pandas as bpd
+    model.to_gbq(
+        your_model_id,  # For example: "bqml_tutorial.penguins_model"
+        replace=True,
+    )
+    saved_model = bpd.read_gbq_model(your_model_id)
+    saved_model.predict(feature_columns_from_test_data)
+
+See the `BigQuery ML linear regression tutorial
+<https://docs.cloud.google.com/bigquery/docs/linear-regression-tutorial>`_ for a
+detailed example.
+
+See all, the references for ``bigframes.ml`` sub-modules:
+
+* :mod:`bigframes.ml.cluster`
+* :mod:`bigframes.ml.compose`
+* :mod:`bigframes.ml.decomposition`
+* :mod:`bigframes.ml.ensemble`
+* :mod:`bigframes.ml.forecasting`
+* :mod:`bigframes.ml.imported`
+* :mod:`bigframes.ml.impute`
+* :mod:`bigframes.ml.linear_model`
+* :mod:`bigframes.ml.llm`
+* :mod:`bigframes.ml.metrics`
+* :mod:`bigframes.ml.model_selection`
+* :mod:`bigframes.ml.pipeline`
+* :mod:`bigframes.ml.preprocessing`
+* :mod:`bigframes.ml.remote`
+
+Alternatively, check out mod:`bigframes.bigquery.ml` for an interface that is
+more similar to the BigQuery ML SQL syntax.
+"""
+
+from bigframes.ml import (
+    cluster,
+    compose,
+    decomposition,
+    ensemble,
+    forecasting,
+    imported,
+    impute,
+    linear_model,
+    llm,
+    metrics,
+    model_selection,
+    pipeline,
+    preprocessing,
+    remote,
+)
 
 __all__ = [
     "cluster",
     "compose",
     "decomposition",
+    "ensemble",
+    "forecasting",
+    "imported",
+    "impute",
     "linear_model",
+    "llm",
     "metrics",
     "model_selection",
     "pipeline",
     "preprocessing",
-    "llm",
-    "forecasting",
-    "imported",
     "remote",
 ]

docs/reference/index.rst

@@ -10,6 +10,7 @@ packages.
     bigframes._config
     bigframes.bigquery
     bigframes.bigquery.ai
+    bigframes.bigquery.ml
     bigframes.enums
     bigframes.exceptions
     bigframes.geopandas
@@ -26,6 +27,8 @@ scikit-learn.
 .. autosummary::
     :toctree: api
 
+    bigframes.ml
+    bigframes.ml.base
     bigframes.ml.cluster
     bigframes.ml.compose
     bigframes.ml.decomposition
@@ -35,6 +38,7 @@ scikit-learn.
     bigframes.ml.impute
     bigframes.ml.linear_model
     bigframes.ml.llm
+    bigframes.ml.metrics
     bigframes.ml.model_selection
     bigframes.ml.pipeline
     bigframes.ml.preprocessing

tests/system/large/functions/test_remote_function.py

@@ -1651,13 +1651,12 @@ def square(x):
             return x * x
 
 
-# Note: Zero represents default, which is 100 instances actually, which is why the remote function still works
-# in the df.apply() call here
+# The default value of 100 is used if the maximum instances value is not set.
 @pytest.mark.parametrize(
     ("max_instances_args", "expected_max_instances"),
     [
-        pytest.param({}, 0, id="no-set"),
-        pytest.param({"cloud_function_max_instances": None}, 0, id="set-None"),
+        pytest.param({}, 100, id="no-set"),
+        pytest.param({"cloud_function_max_instances": None}, 100, id="set-None"),
         pytest.param({"cloud_function_max_instances": 1000}, 1000, id="set-explicit"),
     ],
 )

tests/unit/core/compile/sqlglot/expressions/snapshots/test_generic_ops/test_map/out.sql

@@ -5,7 +5,7 @@ WITH `bfcte_0` AS (
 ), `bfcte_1` AS (
   SELECT
     *,
-    CASE `string_col` WHEN 'value1' THEN 'mapped1' END AS `bfcol_1`
+    CASE `string_col` WHEN 'value1' THEN 'mapped1' ELSE `string_col` END AS `bfcol_1`
   FROM `bfcte_0`
 )
 SELECT