2Vh=ddlmZddlmZddlmZddlmZddlmZddlmZddl m Z ddl m Z dd l m Z dd lmZed  dd Z ddZddZ ddZy ))backend)tree)utils) keras_export)Input) InputLayer) Functional)functional_like_constructor) Sequential)serialization_libzkeras.models.clone_modelNc |jdd}|r%tdt|jt |t rDt ||||}|%td|jjd|t|||St |trAt ||||}tj|js|s|rt||||S|s|r(td |jjd |d ||%td |jjd|tj |}tj"||jj|ji S)aClone a Functional or Sequential `Model` instance. Model cloning is similar to calling a model on new inputs, except that it creates new layers (and thus new weights) instead of sharing the weights of the existing layers. Note that `clone_model` will not preserve the uniqueness of shared objects within the model (e.g. a single variable attached to two distinct layers will be restored as two separate variables). Args: model: Instance of `Model` (could be a Functional model or a Sequential model). input_tensors: optional list of input tensors or InputLayer objects to build the model upon. If not provided, new `Input` objects will be created. clone_function: Callable with signature `fn(layer)` to be used to clone each layer in the target model (except `Input` instances). It takes as argument the layer instance to be cloned, and returns the corresponding layer instance to be used in the model copy. If unspecified, this callable defaults to the following serialization/deserialization function: `lambda layer: layer.__class__.from_config(layer.get_config())`. By passing a custom callable, you can customize your copy of the model, e.g. by wrapping certain layers of interest (you might want to replace all `LSTM` instances with equivalent `Bidirectional(LSTM(...))` instances, for example). Defaults to `None`. call_function: Callable with signature `fn(layer, *args, **kwargs)` to be used to call each cloned layer and a set of inputs. It takes the layer instance, the call arguments and keyword arguments, and returns the call outputs. If unspecified, this callable defaults to the regular `__call__()` method: `def fn(layer, *args, **kwargs): return layer(*args, **kwargs)`. By passing a custom callable, you can insert new layers before or after a given layer. Note: this argument can only be used with Functional models. recursive: Boolean. Whether to recursively clone any Sequential or Functional models encountered in the original Sequential/Functional model. If `False`, then inner models are cloned by calling `clone_function()`. If `True`, then inner models are cloned by calling `clone_model()` with the same `clone_function`, `call_function`, and `recursive` arguments. Note that in this case, `call_function` will not be propagated to any Sequential model (since it is not applicable to Sequential models). Returns: An instance of `Model` reproducing the behavior of the original model, on top of new inputs tensors, using newly instantiated weights. The cloned model may behave differently from the original model if a custom `clone_function` or `call_function` modifies a layer or layer call. Example: ```python # Create a test Sequential model. model = keras.Sequential([ keras.layers.Input(shape=(728,)), keras.layers.Dense(32, activation='relu'), keras.layers.Dense(1, activation='sigmoid'), ]) # Create a copy of the test model (with freshly initialized weights). new_model = clone_model(model) ``` Using a `clone_function` to make a model deterministic by setting the random seed everywhere: ```python def clone_function(layer): config = layer.get_config() if "seed" in config: config["seed"] = 1337 return layer.__class__.from_config(config) new_model = clone_model(model, clone_function=clone_function) ``` Using a `call_function` to add a `Dropout` layer after each `Dense` layer (without recreating new layers): ```python def call_function(layer, *args, **kwargs): out = layer(*args, **kwargs) if isinstance(layer, keras.layers.Dense): out = keras.layers.Dropout(0.5)(out) return out new_model = clone_model( model, clone_function=lambda x: x, # Reuse the same layers. call_function=call_function, ) ``` Note that subclassed models cannot be cloned by default, since their internal layer structure is not known. To achieve equivalent functionality as `clone_model` in the case of a subclassed model, simply make sure that the model class implements `get_config()` (and optionally `from_config()`), and call: ```python new_model = model.__class__.from_config(model.get_config()) ``` In the case of a subclassed model, you cannot using a custom `clone_function`. cacheNz Unexpected keyword argument(s): ) call_function recursiverz`call_function` argument is not supported with Sequential models. In a Sequential model, layers aren't called at model-construction time (they're merely listed). Use `call_function` with Functional models only. Received model of type 'z', with call_function=)clone_function input_tensors)rrrzArguments `clone_function` and `input_tensors` are only supported for Sequential models or Functional models. Received model of type 'z', with clone_function=z and input_tensors=zZArgument `call_function` is only supported for Functional models. Received model of type ')custom_objects)pop ValueErrortuplekeys isinstancer _wrap_clone_function __class____name___clone_sequential_modelr r is_default get_config_clone_functional_modelr serialize_keras_objectdeserialize_keras_object)modelrrrrkwargsrconfigs H/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/models/cloning.py clone_modelr& st JJw %E .uV[[]/C.D E  %$- '    $ 1123!!/ 0 2 ' )'  %$- '     E,, - m*-++   __--./,-.*O  -    __--./+, .   5 5e ._clone_layers ??..u/?/?/AB Br'c(t|vrt|Sr]t|trt|}|t|<|St|trt|}|t|<|S|}|t|<|S)N)rr)rrr)idrr r&r )r,clonerrrrs r%wrapped_clone_functionz4_wrap_clone_function..wrapped_clone_functions e9 E# # %,##1 $)bi  E:.##1"/  $)bi  u% bi r')rrrrr-r1s```` r%rrs/ C& }4 "!r'ct|tstd|t|std||jDcgc] }|| }}t|j dt r4|j d}|j}|j}|j}nd}d}d}|pt|ttfrt|dk7r td|d}t|tjstd|t||} | g|z}n|t||| } | g|z}t||j|j } |j"r!|j%} | j'| | Scc}w) aClone a `Sequential` model instance. Model cloning is similar to calling a model on new inputs, except that it creates new layers (and thus new weights) instead of sharing the weights of the existing layers. Args: model: Instance of `Sequential`. input_tensors: optional list of input tensors to build the model upon. If not provided, placeholders will be created. clone_function: callable to be applied on non-input layers in the model. By default, it clones the layer (without copying the weights). Returns: An instance of `Sequential` reproducing the behavior of the original model, on top of new inputs tensors, using newly instantiated weights. zOExpected `model` argument to be a `Sequential` model instance. Received: model=NExpected `clone_function` argument to be a callable. Received: clone_function=rNz6Argument `input_tensors` must contain a single tensor.zVArgument `input_tensors` must be a KerasTensor. Received invalid value: input_tensors=)tensorname batch_shapedtyper7)r7 trainable)rr rcallablelayers_layersrr7r9_dtypelistrlenr KerasTensorrr;compiledget_compile_configcompile_from_config) r"rrr, new_layersref_input_layer input_nameinput_batch_shape input_dtypeinputs cloned_modelcompiled_configs r%rrs* eZ ( $g '  N # ((6'7 9  6;\\BE.'BJB%--"J/--*$)) +77%,,     mdE] 3=!Q& L*!,M-)<)<=99FI   X *  (-!F !J.JuL  ~~224((9 [CsFctstdt|tstd||Ut dt j |Dstd| t j||jn!t jd|j}fd }|j||| }t|jr|j|||j }nt|||j }|jr!|j}|j!||S#t$r!}td|jd||d}~wwxYw) aClone a `Functional` model instance. Model cloning is similar to calling a model on new inputs, except that it creates new layers (and thus new weights) instead of sharing the weights of the existing layers. Input layers are always cloned. Args: model: Instance of `Functional`. input_tensors: optional list of input tensors to build the model upon. If not provided, placeholders will be created. clone_function: callable to be applied on non-input layers in the model. By default, it clones the layer (without copying the weights). Returns: An instance of `Functional` reproducing the behavior of the original model, on top of new inputs tensors, using newly instantiated weights. r4zMExpected `model` argument to be a Functional Model instance. Received: model=Nc3PK|]}t|tj ywr*)rrrB).0xs r% z*_clone_functional_model..ws%  q'-- . s$&z]All entries in `input_tensors` must be KerasTensors. Received invalid values: inputs_tensors=zQ`input_tensors` must have the same structure as model.input Reference structure: z Received structure: cZt|j|j|jS)Nr8)rshaper:r7)rQs r%z)_clone_functional_model..seqwwQVVLr'c|}|Sr*r2)r, new_layerrs r% operation_fnz-_clone_functional_model..operation_fns"5) r')rXcall_fn)r7)r<rrr allrflattenassert_same_structureinput map_structure_run_through_graphr rr7rCrDrE) r"rrrerXoutput_tensors new_modelrMs ` r%rrQs2 N # ((6'7 9  eZ ( BBG J    \\-0  ;;H/K    & &}ekk B** L KK --!.N #5??3OO > $ }n5::N  ~~224%%o6 E **/++(9   s/ E E/E**E/)NNNF)NFNr*)NN) keras.srcrrrkeras.src.api_exportrkeras.src.layersrrkeras.src.models.functionalr r keras.src.models.sequentialr keras.src.savingr r&rrrr2r'r%risn-"'2C2.() C*CN@D("VOf>BRr'