ENH: Add default losses to KerasClassifier and KerasRegressor

scikeras/_types.py

@@ -0,0 +1,18 @@
+from typing import Callable, List, Type, Union
+
+import numpy as np
+import tensorflow as tf
+import tensorflow.keras as keras
+
+from tensorflow.keras.callbacks import Callback as TF_Callback
+from tensorflow.keras.losses import Loss as TF_Loss
+from tensorflow.keras.metrics import Metric as TF_Metric
+from tensorflow.keras.optimizers import Optimizer as TF_Optimizer
+
+
+Model = Union[Callable[..., keras.Model], keras.Model]
+RandomState = Union[int, np.random.RandomState]
+Optimizer = Union[str, TF_Optimizer, Type[TF_Optimizer]]
+Loss = Union[str, TF_Loss, Type[TF_Loss], Callable]
+Metrics = Union[List[Union[str, TF_Metric, Type[TF_Metric], Callable]]]
+Callbacks = Union[List[Union[TF_Callback, Type[TF_Callback]]]]

scikeras/wrappers.py

@@ -4,7 +4,7 @@
 import warnings
 
 from collections import defaultdict
-from typing import Any, Callable, Dict, Iterable, List, Tuple, Type, Union
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Type, Union
 
 import numpy as np
 import tensorflow as tf
@@ -23,6 +23,7 @@
 from tensorflow.keras.models import Model
 from tensorflow.keras.utils import register_keras_serializable
 
+from scikeras import _types as T
 from scikeras._utils import (
     TFRandomState,
     _class_from_strings,
@@ -192,37 +193,18 @@ class BaseWrapper(BaseEstimator):
 
     def __init__(
         self,
-        model: Union[None, Callable[..., tf.keras.Model], tf.keras.Model] = None,
+        model: T.Model,
         *,
-        build_fn: Union[
-            None, Callable[..., tf.keras.Model], tf.keras.Model
-        ] = None,  # for backwards compatibility
+        build_fn: Optional[T.Model] = None,  # for backwards compatibility
         warm_start: bool = False,
-        random_state: Union[int, np.random.RandomState, None] = None,
-        optimizer: Union[
-            str, tf.keras.optimizers.Optimizer, Type[tf.keras.optimizers.Optimizer]
-        ] = "rmsprop",
-        loss: Union[
-            Union[str, tf.keras.losses.Loss, Type[tf.keras.losses.Loss], Callable], None
-        ] = None,
-        metrics: Union[
-            List[
-                Union[
-                    str,
-                    tf.keras.metrics.Metric,
-                    Type[tf.keras.metrics.Metric],
-                    Callable,
-                ]
-            ],
-            None,
-        ] = None,
-        batch_size: Union[int, None] = None,
-        validation_batch_size: Union[int, None] = None,
+        random_state: Optional[T.RandomState] = None,
+        optimizer: T.Optimizer = "rmsprop",
+        loss: Optional[T.Loss] = None,
+        metrics: Optional[T.Metrics] = None,
+        batch_size: Optional[int] = None,
+        validation_batch_size: Optional[int] = None,
         verbose: int = 1,
-        callbacks: Union[
-            List[Union[tf.keras.callbacks.Callback, Type[tf.keras.callbacks.Callback]]],
-            None,
-        ] = None,
+        callbacks: Optional[T.Callbacks] = None,
         validation_split: float = 0.0,
         shuffle: bool = True,
         run_eagerly: bool = False,
@@ -1142,12 +1124,18 @@ class KerasClassifier(BaseWrapper):
         an instance of tf.keras.optimizers.Optimizer
         or a class inheriting from tf.keras.optimizers.Optimizer.
         Only strings and classes support parameter routing.
-    loss : Union[Union[str, tf.keras.losses.Loss, Type[tf.keras.losses.Loss], Callable], None], default None
+    loss : Union[Union[str, tf.keras.losses.Loss, Type[tf.keras.losses.Loss], Callable], None], default "categorical_crossentropy"
         The loss function to use for training.
         This can be a string for Keras' built in losses,
         an instance of tf.keras.losses.Loss
         or a class inheriting from tf.keras.losses.Loss .
         Only strings and classes support parameter routing.
+
+        For convience, the loss defaults to
+        `"categorical_crossentropy"`. This assumes that the model has
+        ``N`` outputs if the dataset has ``N`` classes. It assumes that
+        the input
+
     random_state : Union[int, np.random.RandomState, None], default None
         Set the Tensorflow random number generators to a
         reproducible deterministic state using this seed.
@@ -1245,42 +1233,23 @@ class KerasClassifier(BaseWrapper):
 
     def __init__(
         self,
-        model: Union[None, Callable[..., tf.keras.Model], tf.keras.Model] = None,
+        model: T.Model,
         *,
-        build_fn: Union[
-            None, Callable[..., tf.keras.Model], tf.keras.Model
-        ] = None,  # for backwards compatibility
+        build_fn: Optional[T.Model] = None,  # for backwards compatibility
         warm_start: bool = False,
-        random_state: Union[int, np.random.RandomState, None] = None,
-        optimizer: Union[
-            str, tf.keras.optimizers.Optimizer, Type[tf.keras.optimizers.Optimizer]
-        ] = "rmsprop",
-        loss: Union[
-            Union[str, tf.keras.losses.Loss, Type[tf.keras.losses.Loss], Callable], None
-        ] = None,
-        metrics: Union[
-            List[
-                Union[
-                    str,
-                    tf.keras.metrics.Metric,
-                    Type[tf.keras.metrics.Metric],
-                    Callable,
-                ]
-            ],
-            None,
-        ] = None,
-        batch_size: Union[int, None] = None,
-        validation_batch_size: Union[int, None] = None,
+        random_state: Optional[T.RandomState] = None,
+        optimizer: T.Optimizer = "rmsprop",
+        loss: Optional[T.Loss] = None,
+        metrics: Optional[T.Metrics] = None,
+        batch_size: Optional[int] = None,
+        validation_batch_size: Optional[int] = None,
         verbose: int = 1,
-        callbacks: Union[
-            List[Union[tf.keras.callbacks.Callback, Type[tf.keras.callbacks.Callback]]],
-            None,
-        ] = None,
+        callbacks: Optional[T.Callbacks] = None,
         validation_split: float = 0.0,
         shuffle: bool = True,
         run_eagerly: bool = False,
         epochs: int = 1,
-        class_weight: Union[Dict[Any, float], str, None] = None,
+        class_weight: Optional[Union[Dict[Any, float], str]] = None,
         **kwargs,
     ):
         super().__init__(
@@ -1308,8 +1277,34 @@ def _type_of_target(self, y: np.ndarray) -> str:
         if target_type == "binary" and self.classes_ is not None:
             # check that this is not a multiclass problem missing categories
             target_type = type_of_target(self.classes_)
+        if target_type == "binary" and self.loss == "categorical_crossentropy":
+            raise ValueError(
+                "A binary target with two targets is specified; "
+                "however loss='categorical_crossentropy' is specified. "
+                "Keras will not learn in this use case. "
+                "Any one of the following will resolve this error:\n\n"
+                "    * Set loss='binary_crossentropy' or loss='bce'\n"
+            )
         return target_type
 
+    def _fit_keras_model(self, *args, **kwargs):
+        try:
+            super()._fit_keras_model(*args, **kwargs)
+        except ValueError as e:
+            if (
+                self.loss == "categorical_crossentropy"
+                and hasattr(self, "model_")
+                and 1 in {o.shape[1] for o in getattr(self.model_, "outputs", [])}
+            ):
+                raise ValueError(
+                    "The model is configured to have one output, but the "
+                    f"loss='{self.loss}' is expecting multiple outputs "
+                    "(which is often used with one-hot encoded targets). "
+                    "More detail on Keras losses: https://keras.io/api/losses/"
+                ) from e
+            else:
+                raise e
+
     @staticmethod
     def scorer(y_true, y_pred, **kwargs) -> float:
         """Scoring function for KerasClassifier.
@@ -1611,6 +1606,46 @@ class KerasRegressor(BaseWrapper):
         **BaseWrapper._tags,
     }
 
+    def __init__(
+        self,
+        model: T.Model,
+        *,
+        build_fn: Optional[T.Model] = None,  # for backwards compatibility
+        warm_start: bool = False,
+        random_state: Optional[T.RandomState] = None,
+        optimizer: T.Optimizer = "rmsprop",
+        loss: Optional[T.Loss] = "mse",
+        metrics: Optional[T.Metrics] = None,
+        batch_size: Optional[int] = None,
+        validation_batch_size: Optional[int] = None,
+        verbose: int = 1,
+        callbacks: Optional[T.Callbacks] = None,
+        validation_split: float = 0.0,
+        shuffle: bool = True,
+        run_eagerly: bool = False,
+        epochs: int = 1,
+        class_weight: Optional[Union[Dict[Any, float], str]] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            model=model,
+            build_fn=build_fn,
+            warm_start=warm_start,
+            random_state=random_state,
+            optimizer=optimizer,
+            loss=loss,
+            metrics=metrics,
+            batch_size=batch_size,
+            validation_batch_size=validation_batch_size,
+            verbose=verbose,
+            callbacks=callbacks,
+            validation_split=validation_split,
+            shuffle=shuffle,
+            run_eagerly=run_eagerly,
+            epochs=epochs,
+            **kwargs,
+        )
+
     @staticmethod
     def scorer(y_true, y_pred, **kwargs) -> float:
         """Scoring function for KerasRegressor.

tests/test_simple_usage.py

@@ -0,0 +1,103 @@
+import numpy as np
+import pytest
+import tensorflow as tf
+
+from sklearn.datasets import make_classification
+from sklearn.preprocessing import OneHotEncoder
+
+from scikeras.wrappers import KerasClassifier, KerasRegressor
+
+
+N_CLASSES = 4
+FEATURES = 8
+n_eg = 100
+X = np.random.uniform(size=(n_eg, FEATURES)).astype("float32")
+
+
+def shallow_net(single_output=False, in_dim=FEATURES):
+    model = tf.keras.Sequential()
+    model.add(tf.keras.layers.Input(shape=(in_dim,)))
+    model.add(tf.keras.layers.Dense(in_dim, activation="sigmoid"))
+
+    if single_output:
+        model.add(tf.keras.layers.Dense(1))
+    else:
+        model.add(tf.keras.layers.Dense(N_CLASSES))
+
+    return model
+
+
+@pytest.mark.parametrize(
+    "use_case",
+    [
+        "binary_classification",
+        "binary_classification_w_one_class",
+        "classification_w_1d_targets",
+        "classification_w_onehot_targets",
+    ],
+)
+def test_classifier_only_model_specified(use_case):
+    """
+    Test uses cases where KerasClassifier works with the default loss.
+    """
+
+    model__single_output = True if "binary" in use_case else False
+    if use_case == "binary_classification":
+        y = np.random.choice(2, size=len(X)).astype(int)
+    elif use_case == "binary_classification_w_one_class":
+        y = np.zeros(len(X))
+    elif use_case == "classification_w_1d_targets":
+        y = np.random.choice(N_CLASSES, size=len(X)).astype(int)
+    elif use_case == "classification_w_onehot_targets":
+        y = np.random.choice(N_CLASSES, size=len(X)).astype(int)
+        y = OneHotEncoder(sparse=False).fit_transform(y.reshape(-1, 1))
+    else:
+        raise ValueError("use_case={use_case} not recognized")
+
+    est = KerasClassifier(model=shallow_net, model__single_output=model__single_output)
+    if "binary" in use_case:
+        with pytest.raises(ValueError, match="Set loss='binary_crossentropy'"):
+            est.partial_fit(X, y)
+        est.set_params(loss="binary_crossentropy")
+
+    est.partial_fit(X, y=y)
+    assert est.current_epoch == 1
+
+
+def test_classifier_raises_for_single_output_with_multiple_classes():
+    """
+    KerasClassifier does not work with one output and multiple classes
+    in the target (duh).
+    """
+    est = KerasClassifier(model=shallow_net, model__single_output=True)
+    y = np.random.choice(N_CLASSES, size=len(X))
+    msg = (
+        "The model is configured to have one output, but the "
+        "loss='categorical_crossentropy' is expecting multiple outputs "
+    )
+    with pytest.raises(ValueError, match=msg):
+        est.partial_fit(X, y)
+    assert est.current_epoch == 0
+
+
+def test_classifier_raises_loss_binary_multi_misspecified():
+    est = KerasClassifier(
+        model=shallow_net,
+        model__single_output=True,
+        model__in_dim=1,
+        loss="bce",
+        epochs=100,
+        random_state=42,
+    )
+    X = np.random.choice(2, size=(20000, 1))
+    y = X.copy()
+    est.partial_fit(X, y)
+    assert est.score(X, y) >= 0.9
+
+
+def test_regressor_default_loss():
+    y = np.random.uniform(size=len(X))
+    est = KerasRegressor(model=shallow_net, model__single_output=True)
+    assert est.loss == "mse"
+    est.partial_fit(X, y)
+    assert est.model_.loss.__name__ == "mean_squared_error"