2Vh@DddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl m Z ddl mZdd l mZdd l mZ ddlZdd lmZdd lmZdd lmZddlmZGddeZedGddeeZedGddeeZedGd d!eeZy#e$r-dZGddZGddZGddZGddZYwxYw)"N) keras_export) clone_model)Model)_routing_enabled)_validate_data)type_of_target)TargetReshaper) _check_model)assert_sklearn_installed) BaseEstimator)ClassifierMixin)RegressorMixin)TransformerMixinc eZdZy)r N__name__ __module__ __qualname__R/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/wrappers/sklearn_wrapper.pyr r  rr c eZdZy)r Nrrrrr r rrr c eZdZy)rNrrrrrrrrrc eZdZy)rNrrrrrr!rrrcreZdZdZ d dZdZfdZdZedZ dZ dZ d Z d Z dd Zd ZxZS)SKLBaseaTBase class for scikit-learn wrappers. Note that there are sources of randomness in model initialization and training. Refer to [Reproducibility in Keras Models]( https://keras.io/examples/keras_recipes/reproducibility_recipes/) on how to control randomness. Args: model: `Model`. An instance of `Model`, or a callable returning such an object. Note that if input is a `Model`, it will be cloned using `keras.models.clone_model` before being fitted, unless `warm_start=True`. The `Model` instance needs to be passed as already compiled. If callable, it must accept at least `X` and `y` as keyword arguments. Other arguments must be accepted if passed as `model_kwargs` by the user. warm_start: bool, defaults to `False`. Whether to reuse the model weights from the previous fit. If `True`, the given model won't be cloned and the weights from the previous fit will be reused. model_kwargs: dict, defaults to `None`. Keyword arguments passed to `model`, if `model` is callable. fit_kwargs: dict, defaults to `None`. Keyword arguments passed to `model.fit`. These can also be passed directly to the `fit` method of the scikit-learn wrapper. The values passed directly to the `fit` method take precedence over these. Attributes: model_ : `Model` The fitted model. history_ : dict The history of the fit, returned by `model.fit`. czt|jj||_||_||_||_yN)r __class__rmodel warm_start model_kwargs fit_kwargs)selfr!r"r#r$s r__init__zSKLBase.__init__Js3 !!8!89 $($rc ddiS)Nnon_deterministicTrr%s r _more_tagszSKLBase._more_tagsWs #T**rc2t|}d|_|SNT)super__sklearn_tags__r(r%tagsr s rr.zSKLBase.__sklearn_tags__Zsw')!% rct|jr |jntj|j}t |||j |j S)zeReturn a deep copy of the model. This is used by the `sklearn.base.clone` function. )r!r"r#)callabler!copydeepcopytyper"r#)r%r!s r__sklearn_clone__zSKLBase.__sklearn_clone___sR #4::.DJJDMM$**4M tDz**  rc<t|dijddS)zThe current training epoch.history_epochr)getattrgetr)s repoch_zSKLBase.epoch_ms tZ,00!< q- #1#3#7#7#:D ##--a00rc8|jj|S)z2Regressors are NOOP here, classifiers reverse OHE.)rbinverse_transform)r%rNs rr]zSKLBase._reverse_process_targets##55a88r)FNNF)rrr__doc__r&r*r.r6propertyr<rKrQrWr\rUr] __classcell__r s@rrr%sZ"N %+  ==<0,819rrz keras.wrappers.SKLearnClassifierc0eZdZdZddZdZfdZxZS)SKLearnClassifiera scikit-learn compatible classifier wrapper for Keras models. Note that there are sources of randomness in model initialization and training. Refer to [Reproducibility in Keras Models]( https://keras.io/examples/keras_recipes/reproducibility_recipes/) on how to control randomness. Args: model: `Model`. An instance of `Model`, or a callable returning such an object. Note that if input is a `Model`, it will be cloned using `keras.models.clone_model` before being fitted, unless `warm_start=True`. The `Model` instance needs to be passed as already compiled. If callable, it must accept at least `X` and `y` as keyword arguments. Other arguments must be accepted if passed as `model_kwargs` by the user. warm_start: bool, defaults to `False`. Whether to reuse the model weights from the previous fit. If `True`, the given model won't be cloned and the weights from the previous fit will be reused. model_kwargs: dict, defaults to `None`. Keyword arguments passed to `model`, if `model` is callable. fit_kwargs: dict, defaults to `None`. Keyword arguments passed to `model.fit`. These can also be passed directly to the `fit` method of the scikit-learn wrapper. The values passed directly to the `fit` method take precedence over these. Attributes: model_ : `Model` The fitted model. history_ : dict The history of the fit, returned by `model.fit`. classes_ : array-like, shape=(n_classes,) The classes labels. Example: Here we use a function which creates a basic MLP model dynamically choosing the input and output shapes. We will use this to create our scikit-learn model. ``` python from keras.src.layers import Dense, Input, Model def dynamic_model(X, y, loss, layers=[10]): # Creates a basic MLP model dynamically choosing the input and # output shapes. n_features_in = X.shape[1] inp = Input(shape=(n_features_in,)) hidden = inp for layer_size in layers: hidden = Dense(layer_size, activation="relu")(hidden) n_outputs = y.shape[1] if len(y.shape) > 1 else 1 out = [Dense(n_outputs, activation="softmax")(hidden)] model = Model(inp, out) model.compile(loss=loss, optimizer="rmsprop") return model ``` You can then use this function to create a scikit-learn compatible model and fit it on some data. ``` python from sklearn.datasets import make_classification from keras.wrappers import SKLearnClassifier X, y = make_classification(n_samples=1000, n_features=10, n_classes=3) est = SKLearnClassifier( model=dynamic_model, model_kwargs={ "loss": "categorical_crossentropy", "layers": [20, 20, 20], }, ) est.fit(X, y, epochs=5) ``` ct|d}|dvrtd||rtjj t tj jdj||_ tj||_ t|jdk(r td|jj|S) zClassifiers do OHE.Tr`)binary multiclasszDOnly binary and multiclass target types are supported. Target type: F) sparse_outputz6Classifier can't train when only one class is present.)r ValueErrorrBpipeline make_pipeliner preprocessing OneHotEncoderrWrbnpuniqueclasses_lenrc)r%rNrT target_types rrUz!SKLearnClassifier._process_targets$Qd; 6 6!!, /  #*#3#3#A#A %%33%3H$c!f  IIaLDM4==!Q& L##--a00rc ddiSN poor_scoreTrr)s rr*zSKLearnClassifier._more_tags* d##rcFt|}d|j_|Sr,)r-r.classifier_tagsr~r/s rr.z"SKLearnClassifier.__sklearn_tags__.s#w')*.' rrf)rrrrgrUr*r.rirjs@rrlrlsQf1($rrlzkeras.wrappers.SKLearnRegressorc(eZdZdZdZfdZxZS)SKLearnRegressora4 scikit-learn compatible regressor wrapper for Keras models. Note that there are sources of randomness in model initialization and training. Refer to [Reproducibility in Keras Models]( https://keras.io/examples/keras_recipes/reproducibility_recipes/) on how to control randomness. Args: model: `Model`. An instance of `Model`, or a callable returning such an object. Note that if input is a `Model`, it will be cloned using `keras.models.clone_model` before being fitted, unless `warm_start=True`. The `Model` instance needs to be passed as already compiled. If callable, it must accept at least `X` and `y` as keyword arguments. Other arguments must be accepted if passed as `model_kwargs` by the user. warm_start: bool, defaults to `False`. Whether to reuse the model weights from the previous fit. If `True`, the given model won't be cloned and the weights from the previous fit will be reused. model_kwargs: dict, defaults to `None`. Keyword arguments passed to `model`, if `model` is callable. fit_kwargs: dict, defaults to `None`. Keyword arguments passed to `model.fit`. These can also be passed directly to the `fit` method of the scikit-learn wrapper. The values passed directly to the `fit` method take precedence over these. Attributes: model_ : `Model` The fitted model. Example: Here we use a function which creates a basic MLP model dynamically choosing the input and output shapes. We will use this to create our scikit-learn model. ``` python from keras.src.layers import Dense, Input, Model def dynamic_model(X, y, loss, layers=[10]): # Creates a basic MLP model dynamically choosing the input and # output shapes. n_features_in = X.shape[1] inp = Input(shape=(n_features_in,)) hidden = inp for layer_size in layers: hidden = Dense(layer_size, activation="relu")(hidden) n_outputs = y.shape[1] if len(y.shape) > 1 else 1 out = [Dense(n_outputs, activation="softmax")(hidden)] model = Model(inp, out) model.compile(loss=loss, optimizer="rmsprop") return model ``` You can then use this function to create a scikit-learn compatible model and fit it on some data. ``` python from sklearn.datasets import make_regression from keras.wrappers import SKLearnRegressor X, y = make_regression(n_samples=1000, n_features=10) est = SKLearnRegressor( model=dynamic_model, model_kwargs={ "loss": "mse", "layers": [20, 20, 20], }, ) est.fit(X, y, epochs=5) ``` c ddiSr}rr)s rr*zSKLearnRegressor._more_tagsrrcFt|}d|j_|Sr,)r-r.regressor_tagsr~r/s rr.z!SKLearnRegressor.__sklearn_tags__s#w'))-& r)rrrrgr*r.rirjs@rrr4sM^$rrz!keras.wrappers.SKLearnTransformerc.eZdZdZdZdZfdZxZS)SKLearnTransformera scikit-learn compatible transformer wrapper for Keras models. Note that this is a scikit-learn compatible transformer, and not a transformer in the deep learning sense. Also note that there are sources of randomness in model initialization and training. Refer to [Reproducibility in Keras Models]( https://keras.io/examples/keras_recipes/reproducibility_recipes/) on how to control randomness. Args: model: `Model`. An instance of `Model`, or a callable returning such an object. Note that if input is a `Model`, it will be cloned using `keras.models.clone_model` before being fitted, unless `warm_start=True`. The `Model` instance needs to be passed as already compiled. If callable, it must accept at least `X` and `y` as keyword arguments. Other arguments must be accepted if passed as `model_kwargs` by the user. warm_start: bool, defaults to `False`. Whether to reuse the model weights from the previous fit. If `True`, the given model won't be cloned and the weights from the previous fit will be reused. model_kwargs: dict, defaults to `None`. Keyword arguments passed to `model`, if `model` is callable. fit_kwargs: dict, defaults to `None`. Keyword arguments passed to `model.fit`. These can also be passed directly to the `fit` method of the scikit-learn wrapper. The values passed directly to the `fit` method take precedence over these. Attributes: model_ : `Model` The fitted model. history_ : dict The history of the fit, returned by `model.fit`. Example: A common use case for a scikit-learn transformer, is to have a step which gives you the embedding of your data. Here we assume `my_package.my_model` is a Keras model which takes the input and gives embeddings of the data, and `my_package.my_data` is your dataset loader. ``` python from my_package import my_model, my_data from keras.wrappers import SKLearnTransformer from sklearn.frozen import FrozenEstimator # requires scikit-learn>=1.6 from sklearn.pipeline import make_pipeline from sklearn.ensemble import HistGradientBoostingClassifier X, y = my_data() trs = FrozenEstimator(SKLearnTransformer(model=my_model)) pipe = make_pipeline(trs, HistGradientBoostingClassifier()) pipe.fit(X, y) ``` Note that in the above example, `FrozenEstimator` prevents any further training of the transformer step in the pipeline, which can be the case if you don't want to change the embedding model at hand. ctjj|t||d}|jj |S)aTransform the data. Args: X: array-like, shape=(n_samples, n_features) The input samples. Returns: X_transformed: array-like, shape=(n_samples, n_features) The transformed data. FrS)rBrZr[rrXr\)r%rMs rrczSKLearnTransformer.transforms9  $$T* 4% 0{{""1%%rc dgiS)Npreserves_dtyperr)s rr*zSKLearnTransformer._more_tagss r  rcFt|}g|j_|Sr)r-r.transformer_tagsrr/s rr.z#SKLearnTransformer.__sklearn_tags__s#w')02- r)rrrrgrcr*r.rirjs@rrrs=~ & rr)r3numpyrwkeras.src.api_exportrkeras.src.models.cloningrkeras.src.models.modelrkeras.src.wrappers.fixesrrrkeras.src.wrappers.utilsr r r rB sklearn.baser r rr ImportErrorrrlrrrrrrs -0(53331= *,+-"Y9mY9x01oo2od/0W~wW1Wt12X)7X3Xw   G          sB--/CC