6bi<SrSSKJs Jr SSKJr SSKJr SSK J r SSK J r SSK Jr SSK Jr SS K Jr SS KJr \"S 5"S S \ 55rg)z8Wrapper layer to apply every temporal slice of an input.N)backend)Layer) InputSpec)Wrapper) generic_utils) layer_utils)tf_utils) keras_exportzkeras.layers.TimeDistributedc^^\rSrSrSrU4SjrSrSrU4SjrSr S Sjr S S jr S r U=r $) TimeDistributed a"This wrapper allows to apply a layer to every temporal slice of an input. Every input should be at least 3D, and the dimension of index one of the first input will be considered to be the temporal dimension. Consider a batch of 32 video samples, where each sample is a 128x128 RGB image with `channels_last` data format, across 10 timesteps. The batch input shape is `(32, 10, 128, 128, 3)`. You can then use `TimeDistributed` to apply the same `Conv2D` layer to each of the 10 timesteps, independently: >>> inputs = tf.keras.Input(shape=(10, 128, 128, 3)) >>> conv_2d_layer = tf.keras.layers.Conv2D(64, (3, 3)) >>> outputs = tf.keras.layers.TimeDistributed(conv_2d_layer)(inputs) >>> outputs.shape TensorShape([None, 10, 126, 126, 64]) Because `TimeDistributed` applies the same instance of `Conv2D` to each of the timestamps, the same set of weights are used at each timestamp. Args: layer: a `tf.keras.layers.Layer` instance. Call arguments: inputs: Input tensor of shape (batch, time, ...) or nested tensors, and each of which has shape (batch, time, ...). training: Python boolean indicating whether the layer should behave in training mode or in inference mode. This argument is passed to the wrapped layer (only if the layer supports this argument). mask: Binary tensor of shape `(samples, timesteps)` indicating whether a given timestep should be masked. This argument is passed to the wrapped layer (only if the layer supports this argument). Raises: ValueError: If not initialized with a `tf.keras.layers.Layer` instance. c >[U[5(d[SU35e[TU]"U40UD6 SUl[ R"U5=(a [USS5(+Ul g)Nz]Please initialize `TimeDistributed` layer with a `tf.keras.layers.Layer` instance. Received: TstatefulF) isinstancer ValueErrorsuper__init__supports_maskingris_builtin_layergetattr_always_use_reshape)selflayerkwargs __class__s b/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/layers/rnn/time_distributed.pyrTimeDistributed.__init__Hsx%''??DgG  )&) $$/#?#? $ $4%U33  c [R"U5USn[SU55(dX-$[R"U5n[ U5n[ U5HupgUbM XSU-XF'M U[ U5-$)abFinds non-specific dimensions in the static shapes. The static shapes are replaced with the corresponding dynamic shapes of the tensor. Args: init_tuple: a tuple, the first part of the output shape tensor: the tensor from which to get the (static and dynamic) shapes as the last part of the output shape start_idx: int, which indicate the first dimension to take from the static shape of the tensor Returns: The new shape with the first part from `init_tuple` and the last part from or `tensor.shape`, where every `None` is replaced by the corresponding dimension from `tf.shape(tensor)`. Nc3(# UHoSLv M g7fN).0ss r 3TimeDistributed._get_shape_tuple..is0i9is)r int_shapeanyshapelist enumeratetuple)r init_tupletensor start_idxr'r)ir$s r_get_shape_tuple TimeDistributed._get_shape_tupleWs"%%f-ij9 0i000) ) f%O i(DAy$]3 )E),,,rcbUR5n[R"US/USS-5$)Nras_listtf TensorShape)rdimss r_remove_timesteps!TimeDistributed._remove_timestepsrs-||~~~tAwi$qr(233rc>[R"USS9n[RR [RR SU55n[ SU55(a[SU35e[RR SU5Ul[RR URU5n[R"U5n[TU]-[U55 SUl g)NF to_tuplescUR$r!)ndimsxs r'TimeDistributed.build..ysAGGrc3*# UH oS:v M g7f)Nr")r#dims rr%(TimeDistributed.build..{s-*3Qw*sza`TimeDistributed` Layer should be passed an `input_shape ` with at least 3 dimensions, received: c@[SS/UR5SS-S9$)Nr4)r))rr6rAs rrCrDsitTlQYY[_&DErT)r convert_shapesr7nestflatten map_structurer(r input_specr:rbuildr,built)r input_shape input_dimschild_input_shapers rrOTimeDistributed.buildvs--kUK WW__ GG ! !"3[ A  -*- - -99D G  ''// E  GG11  " "K %334EF  e-./ rc^[R"USS9n[RR UR U5nUR RU5n[R"USS9n[R"U5m[RRT5SmU4Sjn[RR XC5$)NFr=cf>UR5n[R"UST/USS-5$)NrrVr5)r9 timestepss rinsert_timesteps>TimeDistributed.compute_output_shape..insert_timestepss1<<>D>>47I"6ab"AB Br) r rJr7rKrMr:rcompute_output_shaperL)rrQrSchild_output_shaperYrXs @rr[$TimeDistributed.compute_output_shapes--kUK GG11  " "K "ZZ<<=NO%44 % ++K8 GGOOI.q1  Cww$$%5JJrc P^^^^^^0m[R"TRRS5(aUTS'[R R SU5n[R"U5n[R RU5SnU(aTR(d[R"U5unmTSLm[R"U5m[R RT5SmUU4Sjn[R"UU/T(aTSOTUSS9upxn[R R UU4SjU5n U $[R R S U5m[R RT5m[T5(a[R R S U5n [R R S U5n TR"U 40TD6n [R R [RR X5n U $[#T5(a[%S U35e[R"U5m[R RT5SmT(dW[R R S U5m[R&"[R RT55Sm[R R U4SjU5n [R(R R+U[R,X5n[R"TRRS5(a/Ub,TR/SUS5n [R,"X=5TS'TR"U40TD6n U(aUOSm[R R UUU4SjU 5n[R(R R+U [R,X5n U $)NtrainingcV[R"[R"U55$r!r7r8rr'rAs rrC&TimeDistributed.call..bnnW%6%6q%9:rrrVc2>TR"U40TD6nU/4$r!)r)rB_outputrrs rstep"TimeDistributed.call..steps A00rz!rF)initial_states input_lengthmaskunrollc4>[R"TUT5$r!)rmaybe_convert_to_ragged)rfis_ragged_input row_lengthss rrCrbsw>>#V[ rc6[U[R5$r!rr7 RaggedTensorrAs rrCrbs*Q8rcUR$r!)valuesrAs rrCrbsqxxrc(UR5S$)Nr)nested_row_lengthsrAs rrCrbsa224Q7rzDAll inputs has to be either ragged or not, but not mixed. Received: c4[R"U5S$NrV)r7r)rAs rrCrbs"((1+a.rc*>TRSUS5$Nr4r1)rBrs rrCrbsd33E1a@rrkr|r4r}c.>TRTT4US5$ryr~)r.rjreshape_batch_sizers rrCrbs4#8#8+\:FA$r)rhas_argrcallr7rKrMr rJrLrrconvert_inputs_if_raggedrnnallrsfrom_row_lengthsr(rto_list __internal__map_structure_up_toreshaper1)rinputsr_rkrQ batch_sizergreoutputsy input_valuesinput_row_lenghtsinner_input_shapeinner_mask_shape output_shaperjrorrrps` @@@@@rrTimeDistributed.calls\  * = =!)F: gg++ :F ,,[9 WW__Z03 d66")"B"B6"J FK)5O#22;?L77??<8;L "$KK!")^! MA%% AP}!gg338&O!ggooo>O?##!ww445GP $&GG$9$97%!JJ|6v6GG))OO44ahc_%% 006x9 (66{C !ww|Z2"!ww44   OO((<<rzz1rc:^[RRSU5n[R"USS9n[R"U5n[RR U5Sn[RRSU5n[ R"[RR U55nU(aTR(a[U5(aU$UnUb)TRSUS5n[R"Xg5n[RRU4S jU5n[RRRU[RX5n TRR!X5n U cMUcgUn [#S[%[R&"U555Hn [R"U S S 9n M U $[R"U5n [RR U 5S n U (dC[RRS U5n [RR U 5Sn U(aUOS n TRX4U S 5n[R"X5n U $)a6Computes an output mask tensor for Embedding layer. This is based on the inputs, mask, and the inner layer. If batch size is specified: Simply return the input `mask`. (An rnn-based implementation with more than one rnn inputs is required but not supported in tf.keras yet.) Otherwise we call `compute_mask` of the inner layer at each time step. If the output mask at each time step is not `None`: (E.g., inner layer is Masking or RNN) Concatenate all of them and return the concatenation. If the output mask at each time step is `None` and the input mask is not `None`:(E.g., inner layer is Dense) Reduce the input_mask to 2 dimensions and return it. Otherwise (both the output mask and the input mask are `None`): (E.g., `mask` is not used at all) Return `None`. Args: inputs: Tensor with shape [batch size, timesteps, ...] indicating the input to TimeDistributed. If static shape information is available for "batch size", `mask` is returned unmodified. mask: Either None (indicating no masking) or a Tensor indicating the input mask for TimeDistributed. The shape can be static or dynamic. Returns: Either None (no masking), or a [batch size, timesteps, ...] Tensor with an output mask for the TimeDistributed layer with the shape beyond the second dimension being the value of the input mask shape(if the computed output mask is none), an output mask with the shape beyond the first dimension being the value of the mask shape(if mask is not None) or output mask with the shape beyond the first dimension being the value of the computed output shape. cV[R"[R"U55$r!rarAs rrC.TimeDistributed.compute_mask../rcrFr=rc6[U[R5$r!rrrAs rrCr5sjBOO4rNr|r4c*>TRSUS5$r{r~)r.rs rrCrDs400Brr})axisrVc4[R"U5S$ry)rr)rAs rrCrXsgmmA.q1r)r7rKrMr rJrLrrrr(r1rrrrr compute_maskrangelenr')rrrkrQrro inner_maskrr inner_inputs output_maskrerjroutput_mask_shapes` rrTimeDistributed.compute_mask sJgg++ :F --kUK ,,[9 WW__Z03 ''// 4f (// GGOOO ,  d66#o:N:NK  !#44UD!D  FJGG11 BF ++?? BJJ jj--lG  |K1c'"3"3D"9:;%kk+B? < $22;?L77??<8;L!ww4416   "ww|rsP?"! 048,*':,-g.r