Python keras.backend.repeat() Examples
The following are 20 code examples for showing how to use keras.backend.repeat(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.
You may check out the related API usage on the sidebar.
You may also want to check out all available functions/classes of the module
keras.backend
, or try the search function
.
Example 1
Project: keras-utility-layer-collection Author: zimmerrol File: layer_normalization.py License: MIT License | 6 votes |
def call(self, x): mean = K.mean(x, axis=-1) std = K.std(x, axis=-1) if len(x.shape) == 3: mean = K.permute_dimensions( K.repeat(mean, x.shape.as_list()[-1]), [0,2,1] ) std = K.permute_dimensions( K.repeat(std, x.shape.as_list()[-1]), [0,2,1] ) elif len(x.shape) == 2: mean = K.reshape( K.repeat_elements(mean, x.shape.as_list()[-1], 0), (-1, x.shape.as_list()[-1]) ) std = K.reshape( K.repeat_elements(mean, x.shape.as_list()[-1], 0), (-1, x.shape.as_list()[-1]) ) return self._g * (x - mean) / (std + self._epsilon) + self._b
Example 2
Project: pointer-networks-experiments Author: zygmuntz File: PointerLSTM.py License: BSD 2-Clause "Simplified" License | 6 votes |
def call(self, x, mask=None): input_shape = self.input_spec[0].shape en_seq = x x_input = x[:, input_shape[1]-1, :] x_input = K.repeat(x_input, input_shape[1]) initial_states = self.get_initial_states(x_input) constants = super(PointerLSTM, self).get_constants(x_input) constants.append(en_seq) preprocessed_input = self.preprocess_input(x_input) last_output, outputs, states = K.rnn(self.step, preprocessed_input, initial_states, go_backwards=self.go_backwards, constants=constants, input_length=input_shape[1]) return outputs
Example 3
Project: pointer-networks-experiments Author: zygmuntz File: PointerLSTM.py License: BSD 2-Clause "Simplified" License | 6 votes |
def step(self, x_input, states): #print "x_input:", x_input, x_input.shape # <TensorType(float32, matrix)> input_shape = self.input_spec[0].shape en_seq = states[-1] _, [h, c] = super(PointerLSTM, self).step(x_input, states[:-1]) # vt*tanh(W1*e+W2*d) dec_seq = K.repeat(h, input_shape[1]) Eij = time_distributed_dense(en_seq, self.W1, output_dim=1) Dij = time_distributed_dense(dec_seq, self.W2, output_dim=1) U = self.vt * tanh(Eij + Dij) U = K.squeeze(U, 2) # make probability tensor pointer = softmax(U) return pointer, [h, c]
Example 4
Project: StarGAN-Keras Author: hoangthang1607 File: StarGAN.py License: MIT License | 6 votes |
def test(self): G_weights_dir = os.path.join(self.model_save_dir, 'G_weights.hdf5') if not os.path.isfile(G_weights_dir): print("Don't find weight's generator model") else: self.G.load_weights(G_weights_dir) data_iter = get_loader(self.Image_data_class.test_dataset, self.Image_data_class.test_dataset_label, self.Image_data_class.test_dataset_fix_label, image_size=self.image_size, batch_size=self.batch_size, mode=self.mode) n_batches = int(len(self.sample_step) / self.batch_size) total_samples = n_batches * self.batch_size for i in range(n_batches): imgs, orig_labels, target_labels, fix_labels, names = next(data_iter) for j in range(self.batch_size): preds = self.G.predict([np.repeat(np.expand_dims(imgs[j], axis = 0), len(self.selected_attrs), axis = 0), fix_labels[j]]) for k in range(len(self.selected_attrs)): Image.fromarray((preds[k]*127.5 + 127.5).astype(np.uint8)).save(os.path.join(self.result_dir, names[j].split(os.path.sep)[-1].split('.')[0] + f'_{k + 1}.png'))
Example 5
Project: StarGAN-Keras Author: hoangthang1607 File: StarGAN.py License: MIT License | 6 votes |
def custom(self): G_weights_dir = os.path.join(self.model_save_dir, 'G_weights.hdf5') if not os.path.isfile(G_weights_dir): print("Don't find weight's generator model") else: self.G.load_weights(G_weights_dir) path = os.path.join(self.sample_dir, self.custom_image_name) target_list = create_labels([self.custom_image_label], selected_attrs=self.selected_attrs)[0] image = cv2.imread(path) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image = resize_keep_aspect_ratio(image, width = self.image_size, height = self.image_size) image = np.array([image])/127.5 - 1 preds = self.G.predict([np.repeat(image, len(self.selected_attrs), axis = 0), target_list]) for k in range(len(self.selected_attrs)): Image.fromarray((preds[k]*127.5 + 127.5).astype(np.uint8)).save(os.path.join(self.sample_dir, self.custom_image_name.split('.')[0] + f'_{k + 1}.png'))
Example 6
Project: qlearning4k Author: farizrahman4u File: memory.py License: MIT License | 6 votes |
def get_batch(self, model, batch_size, gamma=0.9): if self.fast: return self.get_batch_fast(model, batch_size, gamma) if len(self.memory) < batch_size: batch_size = len(self.memory) nb_actions = model.get_output_shape_at(0)[-1] samples = np.array(sample(self.memory, batch_size)) input_dim = np.prod(self.input_shape) S = samples[:, 0 : input_dim] a = samples[:, input_dim] r = samples[:, input_dim + 1] S_prime = samples[:, input_dim + 2 : 2 * input_dim + 2] game_over = samples[:, 2 * input_dim + 2] r = r.repeat(nb_actions).reshape((batch_size, nb_actions)) game_over = game_over.repeat(nb_actions).reshape((batch_size, nb_actions)) S = S.reshape((batch_size, ) + self.input_shape) S_prime = S_prime.reshape((batch_size, ) + self.input_shape) X = np.concatenate([S, S_prime], axis=0) Y = model.predict(X) Qsa = np.max(Y[batch_size:], axis=1).repeat(nb_actions).reshape((batch_size, nb_actions)) delta = np.zeros((batch_size, nb_actions)) a = np.cast['int'](a) delta[np.arange(batch_size), a] = 1 targets = (1 - delta) * Y[:batch_size] + delta * (r + gamma * (1 - game_over) * Qsa) return S, targets
Example 7
Project: qlearning4k Author: farizrahman4u File: memory.py License: MIT License | 6 votes |
def set_batch_function(self, model, input_shape, batch_size, nb_actions, gamma): input_dim = np.prod(input_shape) samples = K.placeholder(shape=(batch_size, input_dim * 2 + 3)) S = samples[:, 0 : input_dim] a = samples[:, input_dim] r = samples[:, input_dim + 1] S_prime = samples[:, input_dim + 2 : 2 * input_dim + 2] game_over = samples[:, 2 * input_dim + 2 : 2 * input_dim + 3] r = K.reshape(r, (batch_size, 1)) r = K.repeat(r, nb_actions) r = K.reshape(r, (batch_size, nb_actions)) game_over = K.repeat(game_over, nb_actions) game_over = K.reshape(game_over, (batch_size, nb_actions)) S = K.reshape(S, (batch_size, ) + input_shape) S_prime = K.reshape(S_prime, (batch_size, ) + input_shape) X = K.concatenate([S, S_prime], axis=0) Y = model(X) Qsa = K.max(Y[batch_size:], axis=1) Qsa = K.reshape(Qsa, (batch_size, 1)) Qsa = K.repeat(Qsa, nb_actions) Qsa = K.reshape(Qsa, (batch_size, nb_actions)) delta = K.reshape(self.one_hot(a, nb_actions), (batch_size, nb_actions)) targets = (1 - delta) * Y[:batch_size] + delta * (r + gamma * (1 - game_over) * Qsa) self.batch_function = K.function(inputs=[samples], outputs=[S, targets])
Example 8
Project: pointer-networks Author: keon File: PointerLSTM.py License: MIT License | 6 votes |
def call(self, x, mask=None): input_shape = self.input_spec[0].shape en_seq = x x_input = x[:, input_shape[1]-1, :] x_input = K.repeat(x_input, input_shape[1]) initial_states = self.get_initial_states(x_input) constants = super(PointerLSTM, self).get_constants(x_input) constants.append(en_seq) preprocessed_input = self.preprocess_input(x_input) last_output, outputs, states = K.rnn(self.step, preprocessed_input, initial_states, go_backwards=self.go_backwards, constants=constants, input_length=input_shape[1]) return outputs
Example 9
Project: keras-monotonic-attention Author: asmekal File: attention_decoder.py License: GNU Affero General Public License v3.0 | 5 votes |
def _time_distributed_dense(x, w, b=None, dropout=None, input_dim=None, output_dim=None, timesteps=None, training=None): """Apply `y . w + b` for every temporal slice y of x. # Arguments x: input tensor. w: weight matrix. b: optional bias vector. dropout: wether to apply dropout (same dropout mask for every temporal slice of the input). input_dim: integer; optional dimensionality of the input. output_dim: integer; optional dimensionality of the output. timesteps: integer; optional number of timesteps. training: training phase tensor or boolean. # Returns Output tensor. """ if not input_dim: input_dim = K.shape(x)[2] if not timesteps: timesteps = K.shape(x)[1] if not output_dim: output_dim = K.shape(w)[1] if dropout is not None and 0. < dropout < 1.: # apply the same dropout pattern at every timestep ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim))) dropout_matrix = K.dropout(ones, dropout) expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps) x = K.in_train_phase(x * expanded_dropout_matrix, x, training=training) # maybe below is more clear implementation compared to older keras # at least it works the same for tensorflow, but not tested on other backends x = K.dot(x, w) if b is not None: x = K.bias_add(x, b) return x
Example 10
Project: maskrcnn Author: shtamura File: roi_align_layer.py License: MIT License | 5 votes |
def call(self, inputs): features = inputs[0] rois = inputs[1] n_roi_boxes = K.shape(rois)[1] # roisには[0,0,0,0]のRoIも含むが、バッチ毎の要素数を合わせるため、そのまま処理する。 # crop_and_resizeの準備 # roisを0軸目を除き(バッチを示す次元を除き)、フラットにする。 roi_unstack = K.concatenate(tf.unstack(rois), axis=0) # roi_unstackの各roiに対応するバッチを指すindex batch_pos = K.flatten( K.repeat(K.reshape(K.arange(self.batch_size), [-1, 1]), n_roi_boxes)) # RoiAlignの代わりにcrop_and_resizeを利用。 # crop_and_resize内部でbilinear interporlationしてようなので、アルゴリズム的には同じっぽい crop_boxes = tf.image.crop_and_resize(features, roi_unstack, batch_pos, self.out_shape) # (N * n_rois, out_size, out_size, channels) # から # (N, n_rois, out_size, out_size, channels) # へ変換 crop_boxes = K.reshape(crop_boxes, [self.batch_size, n_roi_boxes] + self.out_shape + [-1]) log.tfprint(crop_boxes, "crop_boxes: ") return crop_boxes
Example 11
Project: neural-tweet-search Author: jinfengr File: attention_model.py License: Apache License 2.0 | 5 votes |
def repeat_vector(x, rep, axis): return K.repeat(x, rep, axis)
Example 12
Project: recurrent-attention-for-QA-SQUAD-based-on-keras Author: wentaozhu File: rnnlayer.py License: MIT License | 5 votes |
def time_distributed_dense(x, w, b=None, dropout=None, input_dim=None, units=None, timesteps=None): """Apply `y . w + b` for every temporal slice y of x. # Arguments x: input tensor. w: weight matrix. b: optional bias vector. dropout: wether to apply dropout (same dropout mask for every temporal slice of the input). input_dim: integer; optional dimensionality of the input. units: integer; optional dimensionality of the output. timesteps: integer; optional number of timesteps. # Returns Output tensor. """ if not input_dim: input_dim = K.shape(x)[2] if not timesteps: timesteps = K.shape(x)[1] if not units: units = K.shape(w)[1] if dropout is not None and 0. < dropout < 1.: # apply the same dropout pattern at every timestep ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim))) dropout_matrix = K.dropout(ones, dropout) expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps) x = K.in_train_phase(x * expanded_dropout_matrix, x) # collapse time dimension and batch dimension together x = K.reshape(x, (-1, input_dim)) x = K.dot(x, w) if b: x += b # reshape to 3D tensor if K.backend() == 'tensorflow': x = K.reshape(x, K.stack([-1, timesteps, units])) x.set_shape([None, None, units]) else: x = K.reshape(x, (-1, timesteps, units)) return x
Example 13
Project: deep-koalarization Author: baldassarreFe File: fusion_layer.py License: MIT License | 5 votes |
def call(self, inputs, mask=None): imgs, embs = inputs reshaped_shape = imgs.shape[:3].concatenate(embs.shape[1]) embs = K.repeat(embs, imgs.shape[1] * imgs.shape[2]) embs = K.reshape(embs, reshaped_shape) return K.concatenate([imgs, embs], axis=3)
Example 14
Project: pointer-networks Author: keon File: PointerLSTM.py License: MIT License | 5 votes |
def step(self, x_input, states): input_shape = self.input_spec[0].shape en_seq = states[-1] _, [h, c] = super(PointerLSTM, self).step(x_input, states[:-1]) # vt*tanh(W1*e+W2*d) dec_seq = K.repeat(h, input_shape[1]) Eij = time_distributed_dense(en_seq, self.W1, output_dim=1) Dij = time_distributed_dense(dec_seq, self.W2, output_dim=1) U = self.vt * tanh(Eij + Dij) U = K.squeeze(U, 2) # make probability tensor pointer = softmax(U) return pointer, [h, c]
Example 15
Project: StarGAN-Keras Author: hoangthang1607 File: StarGAN.py License: MIT License | 4 votes |
def build_generator(self): """Generator network.""" # Input tensors inp_c = Input(shape = (self.c_dim, )) inp_img = Input(shape = (self.image_size, self.image_size, 3)) # Replicate spatially and concatenate domain information c = Lambda(lambda x: K.repeat(x, self.image_size**2))(inp_c) c = Reshape((self.image_size, self.image_size, self.c_dim))(c) x = Concatenate()([inp_img, c]) # First Conv2D x = Conv2D(filters = self.g_conv_dim, kernel_size = 7, strides = 1, padding = 'same', use_bias = False)(x) x = InstanceNormalization(axis = -1)(x) x = ReLU()(x) # Down-sampling layers curr_dim = self.g_conv_dim for i in range(2): x = ZeroPadding2D(padding = 1)(x) x = Conv2D(filters = curr_dim*2, kernel_size = 4, strides = 2, padding = 'valid', use_bias = False)(x) x = InstanceNormalization(axis = -1)(x) x = ReLU()(x) curr_dim = curr_dim * 2 # Bottleneck layers. for i in range(self.g_repeat_num): x = self.ResidualBlock(x, curr_dim) # Up-sampling layers for i in range(2): x = UpSampling2D(size = 2)(x) x = Conv2D(filters = curr_dim // 2, kernel_size = 4, strides = 1, padding = 'same', use_bias = False)(x) x = InstanceNormalization(axis = -1)(x) x = ReLU()(x) curr_dim = curr_dim // 2 # Last Conv2D x = ZeroPadding2D(padding = 3)(x) out = Conv2D(filters = 3, kernel_size = 7, strides = 1, padding = 'valid', activation = 'tanh', use_bias = False)(x) return Model(inputs = [inp_img, inp_c], outputs = out)
Example 16
Project: seq2seq Author: farizrahman4u File: cells.py License: GNU General Public License v2.0 | 4 votes |
def build_model(self, input_shape): input_dim = input_shape[-1] output_dim = self.output_dim input_length = input_shape[1] hidden_dim = self.hidden_dim x = Input(batch_shape=input_shape) h_tm1 = Input(batch_shape=(input_shape[0], hidden_dim)) c_tm1 = Input(batch_shape=(input_shape[0], hidden_dim)) W1 = Dense(hidden_dim * 4, kernel_initializer=self.kernel_initializer, kernel_regularizer=self.kernel_regularizer) W2 = Dense(output_dim, kernel_initializer=self.kernel_initializer, kernel_regularizer=self.kernel_regularizer) W3 = Dense(1, kernel_initializer=self.kernel_initializer, kernel_regularizer=self.kernel_regularizer) U = Dense(hidden_dim * 4, kernel_initializer=self.kernel_initializer, kernel_regularizer=self.kernel_regularizer) C = Lambda(lambda x: K.repeat(x, input_length), output_shape=(input_length, input_dim))(c_tm1) _xC = concatenate([x, C]) _xC = Lambda(lambda x: K.reshape(x, (-1, input_dim + hidden_dim)), output_shape=(input_dim + hidden_dim,))(_xC) alpha = W3(_xC) alpha = Lambda(lambda x: K.reshape(x, (-1, input_length)), output_shape=(input_length,))(alpha) alpha = Activation('softmax')(alpha) _x = Lambda(lambda x: K.batch_dot(x[0], x[1], axes=(1, 1)), output_shape=(input_dim,))([alpha, x]) z = add([W1(_x), U(h_tm1)]) z0, z1, z2, z3 = get_slices(z, 4) i = Activation(self.recurrent_activation)(z0) f = Activation(self.recurrent_activation)(z1) c = add([multiply([f, c_tm1]), multiply([i, Activation(self.activation)(z2)])]) o = Activation(self.recurrent_activation)(z3) h = multiply([o, Activation(self.activation)(c)]) y = Activation(self.activation)(W2(h)) return Model([x, h_tm1, c_tm1], [y, h, c])
Example 17
Project: keras-attention Author: datalogue File: custom_recurrents.py License: GNU Affero General Public License v3.0 | 4 votes |
def step(self, x, states): ytm, stm = states # repeat the hidden state to the length of the sequence _stm = K.repeat(stm, self.timesteps) # now multiplty the weight matrix with the repeated hidden state _Wxstm = K.dot(_stm, self.W_a) # calculate the attention probabilities # this relates how much other timesteps contributed to this one. et = K.dot(activations.tanh(_Wxstm + self._uxpb), K.expand_dims(self.V_a)) at = K.exp(et) at_sum = K.sum(at, axis=1) at_sum_repeated = K.repeat(at_sum, self.timesteps) at /= at_sum_repeated # vector of size (batchsize, timesteps, 1) # calculate the context vector context = K.squeeze(K.batch_dot(at, self.x_seq, axes=1), axis=1) # ~~~> calculate new hidden state # first calculate the "r" gate: rt = activations.sigmoid( K.dot(ytm, self.W_r) + K.dot(stm, self.U_r) + K.dot(context, self.C_r) + self.b_r) # now calculate the "z" gate zt = activations.sigmoid( K.dot(ytm, self.W_z) + K.dot(stm, self.U_z) + K.dot(context, self.C_z) + self.b_z) # calculate the proposal hidden state: s_tp = activations.tanh( K.dot(ytm, self.W_p) + K.dot((rt * stm), self.U_p) + K.dot(context, self.C_p) + self.b_p) # new hidden state: st = (1-zt)*stm + zt * s_tp yt = activations.softmax( K.dot(ytm, self.W_o) + K.dot(stm, self.U_o) + K.dot(context, self.C_o) + self.b_o) if self.return_probabilities: return at, [yt, st] else: return yt, [yt, st]
Example 18
Project: keras-attention Author: datalogue File: tdd.py License: GNU Affero General Public License v3.0 | 4 votes |
def _time_distributed_dense(x, w, b=None, dropout=None, input_dim=None, output_dim=None, timesteps=None, training=None): """Apply `y . w + b` for every temporal slice y of x. # Arguments x: input tensor. w: weight matrix. b: optional bias vector. dropout: wether to apply dropout (same dropout mask for every temporal slice of the input). input_dim: integer; optional dimensionality of the input. output_dim: integer; optional dimensionality of the output. timesteps: integer; optional number of timesteps. training: training phase tensor or boolean. # Returns Output tensor. """ if not input_dim: input_dim = K.shape(x)[2] if not timesteps: timesteps = K.shape(x)[1] if not output_dim: output_dim = K.shape(w)[1] if dropout is not None and 0. < dropout < 1.: # apply the same dropout pattern at every timestep ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim))) dropout_matrix = K.dropout(ones, dropout) expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps) x = K.in_train_phase(x * expanded_dropout_matrix, x, training=training) # collapse time dimension and batch dimension together x = K.reshape(x, (-1, input_dim)) x = K.dot(x, w) if b is not None: x = K.bias_add(x, b) # reshape to 3D tensor if K.backend() == 'tensorflow': x = K.reshape(x, K.stack([-1, timesteps, output_dim])) x.set_shape([None, None, output_dim]) else: x = K.reshape(x, (-1, timesteps, output_dim)) return x
Example 19
Project: recurrent-attention-for-QA-SQUAD-based-on-keras Author: wentaozhu File: rnnlayer.py License: MIT License | 4 votes |
def step(self, inputs, states): h_tm1 = states[0] # previous memory #B_U = states[1] # dropout matrices for recurrent units #B_W = states[2] h_tm1a = K.dot(h_tm1, self.Wa) eij = K.dot(K.tanh(K.repeat(h_tm1a, K.shape(self.h)[1]) + self.ha), self.Va) eijs = K.squeeze(eij, -1) alphaij = K.softmax(eijs) # batchsize * lenh h batchsize * lenh * ndim ci = K.permute_dimensions(K.permute_dimensions(self.h, [2,0,1]) * alphaij, [1,2,0]) cisum = K.sum(ci, axis=1) #print(K.shape(cisum), cisum.shape, ci.shape, self.h.shape, alphaij.shape, x.shape) zr = K.sigmoid(K.dot(inputs, self.Wzr) + K.dot(h_tm1, self.Uzr) + K.dot(cisum, self.Czr)) zi = zr[:, :self.units] ri = zr[:, self.units: 2 * self.units] si_ = K.tanh(K.dot(inputs, self.W) + K.dot(ri*h_tm1, self.U) + K.dot(cisum, self.C)) si = (1-zi) * h_tm1 + zi * si_ return si, [si] #h_tm1, [h_tm1] '''if self.consume_less == 'gpu': matrix_x = K.dot(x * B_W[0], self.W) + self.b matrix_inner = K.dot(h_tm1 * B_U[0], self.U[:, :2 * self.units]) x_z = matrix_x[:, :self.units] x_r = matrix_x[:, self.units: 2 * self.units] inner_z = matrix_inner[:, :self.units] inner_r = matrix_inner[:, self.units: 2 * self.units] z = self.inner_activation(x_z + inner_z) r = self.inner_activation(x_r + inner_r) x_h = matrix_x[:, 2 * self.units:] inner_h = K.dot(r * h_tm1 * B_U[0], self.U[:, 2 * self.units:]) hh = self.activation(x_h + inner_h) else: if self.consume_less == 'cpu': x_z = x[:, :self.units] x_r = x[:, self.units: 2 * self.units] x_h = x[:, 2 * self.units:] elif self.consume_less == 'mem': x_z = K.dot(x * B_W[0], self.W_z) + self.b_z x_r = K.dot(x * B_W[1], self.W_r) + self.b_r x_h = K.dot(x * B_W[2], self.W_h) + self.b_h else: raise ValueError('Unknown `consume_less` mode.') z = self.inner_activation(x_z + K.dot(h_tm1 * B_U[0], self.U_z)) r = self.inner_activation(x_r + K.dot(h_tm1 * B_U[1], self.U_r)) hh = self.activation(x_h + K.dot(r * h_tm1 * B_U[2], self.U_h)) h = z * h_tm1 + (1 - z) * hh return h, [h]'''
Example 20
Project: PhasedLSTM-Keras Author: fferroni File: PhasedLSTM.py License: MIT License | 4 votes |
def _time_distributed_dense(x, w, b=None, dropout=None, input_dim=None, output_dim=None, timesteps=None, training=None): """Apply `y . w + b` for every temporal slice y of x. # Arguments x: input tensor. w: weight matrix. b: optional bias vector. dropout: wether to apply dropout (same dropout mask for every temporal slice of the input). input_dim: integer; optional dimensionality of the input. output_dim: integer; optional dimensionality of the output. timesteps: integer; optional number of timesteps. training: training phase tensor or boolean. # Returns Output tensor. """ if not input_dim: input_dim = K.shape(x)[2] if not timesteps: timesteps = K.shape(x)[1] if not output_dim: output_dim = K.shape(w)[1] if dropout is not None and 0. < dropout < 1.: # apply the same dropout pattern at every timestep ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim))) dropout_matrix = K.dropout(ones, dropout) expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps) x = K.in_train_phase(x * expanded_dropout_matrix, x, training=training) # collapse time dimension and batch dimension together x = K.reshape(x, (-1, input_dim)) x = K.dot(x, w) if b is not None: x = K.bias_add(x, b) # reshape to 3D tensor if K.backend() == 'tensorflow': x = K.reshape(x, K.stack([-1, timesteps, output_dim])) x.set_shape([None, None, output_dim]) else: x = K.reshape(x, (-1, timesteps, output_dim)) return x