REF/ENH: add parameter routing

.gitignore

@@ -108,3 +108,6 @@ ENV/
 
 # Poetry lock file
 poetry.lock
+
+# MacOS files
+.DS_Store

README.md

@@ -66,13 +66,13 @@ The signature of the model building function will be used to dynamically determi
 from scikeras.wrappers import KerasRegressor
 
 
-def model_building_function(X, n_outputs_, hidden_layer_sizes):
+def model_building_function(meta, hidden_layer_sizes):
     """Dynamically build regressor."""
     model = Sequential()
-    model.add(Dense(X.shape[1], activation="relu", input_shape=X.shape[1:]))
+    model.add(Dense(meta["X_shape_"][1], activation="relu", input_shape=meta["X_shape_"][1:]))
     for size in hidden_layer_sizes:
         model.add(Dense(size, activation="relu"))
-    model.add(Dense(n_outputs_))
+    model.add(Dense(meta["n_outputs_"]))
     model.compile("adam", loss="mean_squared_error")
     return model
 
@@ -103,15 +103,15 @@ class MLPRegressor(KerasRegressor):
     def __init__(self, hidden_layer_sizes=None):
         self.hidden_layer_sizes = hidden_layer_sizes
 
-    def _keras_build_fn(self, X, n_outputs_, hidden_layer_sizes):
+    def _keras_build_fn(self, meta, hidden_layer_sizes):
         """Dynamically build regressor."""
         if hidden_layer_sizes is None:
             hidden_layer_sizes = (100, )
         model = Sequential()
-        model.add(Dense(X.shape[1], activation="relu", input_shape=X.shape[1:]))
+        model.add(Dense(meta["X_shape_"][1], activation="relu", input_shape=meta["X_shape_"][1:]))
         for size in hidden_layer_sizes:
             model.add(Dense(size, activation="relu"))
-        model.add(Dense(n_outputs_))
+        model.add(Dense(meta["n_outputs_"]))
         model.compile("adam", loss=KerasRegressor.r_squared)
         return model
 ```
@@ -132,7 +132,7 @@ class MLPRegressor(KerasRegressor):
         self.hidden_layer_sizes = hidden_layer_sizes
         super().__init__(**kwargs)   # this is very important!
 
-    def _keras_build_fn(self, X, n_outputs_, hidden_layer_sizes):
+    def _keras_build_fn(self, meta, hidden_layer_sizes):
         ...
 
 estimator = MLPRegressor(hidden_layer_sizes=[200], a_kwarg="saveme")
@@ -152,7 +152,7 @@ class ChildMLPRegressor(MLPRegressor):
         self.child_argument = child_argument
         super().__init__(**kwargs)   # this is very important!
 
-    def _keras_build_fn(self, X, n_outputs_, hidden_layer_sizes):
+    def _keras_build_fn(self, meta, hidden_layer_sizes):
         ...
 
 estimator = ChildMLPRegressor(child_argument="hello", a_kwarg="saveme")
@@ -218,13 +218,13 @@ class FunctionalAPIMultiOutputClassifier(KerasClassifier):
     """Functional API Classifier with 2 outputs of different type.
     """
 
-    def _keras_build_fn(self, X, n_classes_):
+    def _keras_build_fn(self, meta):
         inp = Input((4,))
 
         x1 = Dense(100)(inp)
 
         binary_out = Dense(1, activation="sigmoid")(x1)
-        cat_out = Dense(n_classes_[1], activation="softmax")(x1)
+        cat_out = Dense(meta["n_classes_"][1], activation="softmax")(x1)
 
         model = Model([inp], [binary_out, cat_out])
         losses = ["binary_crossentropy", "categorical_crossentropy"]
@@ -272,7 +272,7 @@ class FunctionalAPIMultiInputClassifier(KerasClassifier):
     """Functional API Classifier with 2 inputs.
     """
 
-    def _keras_build_fn(self, n_classes_):
+    def _keras_build_fn(self, meta):
         inp1 = Input((1,))
         inp2 = Input((3,))
 
@@ -281,7 +281,7 @@ class FunctionalAPIMultiInputClassifier(KerasClassifier):
 
         x3 = Concatenate(axis=-1)([x1, x2])
 
-        cat_out = Dense(n_classes_, activation="softmax")(x3)
+        cat_out = Dense(meta["n_classes_"], activation="softmax")(x3)
 
         model = Model([inp1, inp2], [cat_out])
         losses = ["categorical_crossentropy"]
@@ -331,9 +331,10 @@ class ClassifierWithCallback(KerasClassifier):
     """
 
     def __init__(self, tolerance, hidden_dim=None):
+        super().__init__()
         self.callbacks = [SentinalCallback(tolerance)]
         self.hidden_dim = hidden_dim
-        super().__init__()
+
 
     def _keras_build_fn(self, hidden_dim):
         return build_fn_clf(hidden_dim)

pyproject.toml

@@ -48,7 +48,6 @@ docs = ["sphinx", "sphinx_rtd_theme"]
 
 [tool.isort]
 line_length = 79
-force_single_line = true
 atomic = true
 include_trailing_comma = true
 lines_after_imports = 2

scikeras/_utils.py

@@ -3,11 +3,12 @@
 import random
 import warnings
 
+from typing import Any, Callable, Dict, Iterable, List, Union
+
 import numpy as np
 import tensorflow as tf
 
-from sklearn.base import BaseEstimator
-from sklearn.base import TransformerMixin
+from sklearn.base import BaseEstimator, TransformerMixin
 from tensorflow.keras.layers import deserialize as deserialize_layer
 from tensorflow.keras.layers import serialize as serialize_layer
 from tensorflow.keras.metrics import deserialize as deserialize_metric
@@ -155,19 +156,83 @@ def get_metric_full_name(name: str) -> str:
     # deserialize returns the actual function, then get it's name
     # to keep a single consistent name for the metric
     if name == "loss":
-        # may be passed "loss" from thre training history
+        # may be passed "loss" from training history
         return name
     return getattr(deserialize_metric(name), "__name__")
 
 
-def _get_default_args(func):
-    signature = inspect.signature(func)
-    return {
-        k: v.default
-        for k, v in signature.parameters.items()
-        if v.default is not inspect.Parameter.empty
-    }
+def _windows_upcast_ints(
+    arr: Union[List[np.ndarray], np.ndarray]
+) -> Union[List[np.ndarray], np.ndarray]:
+    # see tensorflow/probability#886
+    def _upcast(x):
+        return x.astype("int64") if x.dtype == np.int32 else x
+
+    if isinstance(arr, np.ndarray):
+        return _upcast(arr)
+    else:
+        return [_upcast(x_) for x_ in arr]
+
 
+def route_params(
+    params: Dict[str, Any], destination: str, pass_filter: Iterable[str],
+) -> Dict[str, Any]:
+    """Route and trim parameter names.
+
+    Parameters
+    ----------
+    params : Dict[str, Any]
+        Parameters to route/filter.
+    destination : str
+        Destination to route to, ex: `build` or `compile`.
+    pass_filter: Iterable[str]
+        Only keys from `params` that are in the iterable are passed.
+        This does not affect routed parameters.
 
-def _windows_upcast_ints(x: np.ndarray) -> np.ndarray:
-    return x.astype("int64") if x.dtype == np.int32 else x
+    Returns
+    -------
+    Dict[str, Any]
+        Filtered parameters, with any routing prefixes removed.
+    """
+    res = dict()
+    for key, val in params.items():
+        if "__" in key:
+            # routed param
+            if key.startswith(destination):
+                new_key = key[len(destination + "__") :]
+                res[new_key] = val
+        else:
+            # non routed
+            if pass_filter is None or key in pass_filter:
+                res[key] = val
+    return res
+
+
+def has_param(func: Callable, param: str) -> bool:
+    """[summary]
+
+    Parameters
+    ----------
+    func : Callable
+        [description]
+    param : str
+        [description]
+
+    Returns
+    -------
+    bool
+        [description]
+    """
+    return any(
+        p.name == param
+        for p in inspect.signature(func).parameters.values()
+        if p.kind in (p.POSITIONAL_OR_KEYWORD, p.KEYWORD_ONLY)
+    )
+
+
+def accepts_kwargs(func: Callable) -> bool:
+    return any(
+        True
+        for param in inspect.signature(func).parameters.values()
+        if param.kind == param.VAR_KEYWORD
+    )