o 2hD@sjddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl m Z ddl mZdd l mZdd l mZzddlZdd lmZdd lmZdd lmZddlmZWn'eydZGdddZGdddZGdddZGdddZYnwGdddeZedGdddeeZedGdddeeZedGd d!d!eeZdS)"N) keras_export) clone_model)Model)_routing_enabled)_validate_data)type_of_target)TargetReshaper) _check_model)assert_sklearn_installed) BaseEstimator)ClassifierMixin)RegressorMixin)TransformerMixinc@ eZdZdS)r N__name__ __module__ __qualname__rr]/var/www/html/chatgem/venv/lib/python3.10/site-packages/keras/src/wrappers/sklearn_wrapper.pyr r c@r)r Nrrrrrr rr c@r)r Nrrrrrr rr c@r)rNrrrrrr!rrcs~eZdZdZ   dddZddZfdd Zd d Zed d Z ddZ ddZ ddZ ddZ dddZddZZS)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`. FNcCs(t|jj||_||_||_||_dSN)r __class__rmodel warm_start model_kwargs fit_kwargs)selfrrrrrrr__init__Js  zSKLBase.__init__cCddiS)Nnon_deterministicTrrrrr _more_tagsWszSKLBase._more_tagscst}d|_|SNT)super__sklearn_tags__r!rtagsrrrr&Zs zSKLBase.__sklearn_tags__cCs2t|jr|jnt|j}t|||j|jdS)zeReturn a deep copy of the model. This is used by the `sklearn.base.clone` function. )rrr)callablercopydeepcopytyperr)rrrrr__sklearn_clone___szSKLBase.__sklearn_clone__cCst|diddS)zThe current training epoch.history_epochr)getattrgetr"rrrepoch_mszSKLBase.epoch_cKsLtstdtjjj|jjd|_| D] \}}|jj j ||dq|S)aSet requested parameters by the fit method. Please see [scikit-learn's metadata routing]( https://scikit-learn.org/stable/metadata_routing.html) for more details. Arguments: kwargs : dict Arguments should be of the form `param_name=alias`, and `alias` can be one of `{True, False, None, str}`. Returns: self zThis method is only available when metadata routing is enabled. You can enable it using sklearn.set_config(enable_metadata_routing=True).)owner)paramalias) r RuntimeErrorsklearnutilsmetadata_routingMetadataRequestrr_metadata_requestitemsscore add_request)rkwargsr5r6rrrset_fit_requestrszSKLBase.set_fit_requestcCs6t|jtr t|jS|jpi}|jd||d|S)N)Xyr) isinstancerrrr)rrBrCargsrrr _get_models   zSKLBase._get_modelcKsft|||\}}|j|dd}|||}t||jpi}|||j||fi||_||_|S)a%Fit the model. Args: X: array-like, shape=(n_samples, n_features) The input samples. y: array-like, shape=(n_samples,) or (n_samples, n_outputs) The targets. **kwargs: keyword arguments passed to `model.fit` Treset) r_process_targetrFr rupdatefitr/model_)rrBrCr@rrrrrrKs    z SKLBase.fitcCs8ddlm}||t||dd}|j|}||S)zPredict using the model.rcheck_is_fittedFrG)sklearn.utils.validationrNrrLpredict_reverse_process_target)rrBrN raw_outputrrrrPs   zSKLBase.predictcCs*t|dd|rt||_|j|S)z-Regressors are NOOP here, classifiers do OHE.T raise_unknown)rrrK_target_encoder transform)rrCrHrrrrIs  zSKLBase._process_targetcCs |j|S)z2Regressors are NOOP here, classifiers reverse OHE.)rUinverse_transform)rrCrrrrQs zSKLBase._reverse_process_target)FNNF)rrr__doc__rr#r&r.propertyr3rArFrKrPrIrQ __classcell__rrr)rr%s"'    rz keras.wrappers.SKLearnClassifiercs2eZdZdZd ddZddZfddZZS) 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.layers import Dense, Input from keras.models import 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) est = SKLearnClassifier( model=dynamic_model, model_kwargs={ "loss": "categorical_crossentropy", "layers": [20, 20, 20], }, ) est.fit(X, y, epochs=5) ``` FcCsvt|dd}|dvrtd||r5tjttjjdd||_ t ||_ t |j dkr5td|j |S) zClassifiers do OHE.TrS)binary multiclasszDOnly binary and multiclass target types are supported. Target type: F) sparse_outputz6Classifier can't train when only one class is present.)r ValueErrorr8pipeline make_pipeliner preprocessing OneHotEncoderrKrUnpuniqueclasses_lenrV)rrCrH target_typerrrrIs(    z!SKLearnClassifier._process_targetcCr N poor_scoreTrr"rrrr#-zSKLearnClassifier._more_tagsct}d|j_|Sr$)r%r&classifier_tagsrlr'r)rrr&1 z"SKLearnClassifier.__sklearn_tags__rX)rrrrYrIr#r&r[rrr)rr\s  Tr\zkeras.wrappers.SKLearnRegressorcs(eZdZdZddZfddZZS)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.layers import Dense, Input from keras.models import 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)(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) ``` cCr rkrr"rrrr#rmzSKLearnRegressor._more_tagscrnr$)r%r&regressor_tagsrlr'r)rrr&rpz!SKLearnRegressor.__sklearn_tags__)rrrrYr#r&r[rrr)rrq7sPrqz!keras.wrappers.SKLearnTransformercs0eZdZdZddZddZfddZZS)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. cCs.ddlm}||t||dd}|j|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. rrMFrG)rOrNrrLrP)rrBrNrrrrVs  zSKLearnTransformer.transformcCsdgiS)Npreserves_dtyperr"rrrr#szSKLearnTransformer._more_tagscst}g|j_|Sr)r%r&transformer_tagsrtr'r)rrr&rpz#SKLearnTransformer.__sklearn_tags__)rrrrYrVr#r&r[rrr)rrss ?rs)r+numpyrfkeras.src.api_exportrkeras.src.models.cloningrkeras.src.models.modelrkeras.src.wrappers.fixesrrrkeras.src.wrappers.utilsrr r r8 sklearn.baser r r r ImportErrorrr\rqrsrrrrs@             s[