def GRU(dim, x): # Learnable weights in the cell Wzx = layers.Dense(dim) Wzh = layers.Dense(dim, use_bias=False) Wrx = layers.Dense(dim) Wrh = layers.Dense(dim, use_bias=False) Wx = layers.Dense(dim) Wh = layers.Dense(dim, use_bias=False) # unstacking the time axis x = tf.unstack(x, axis=1) H = [] h = tf.zeros_like(Wx(x[0])) for i in range(len(x)): # -- missing code -- z = sigmoid(Wzx(x[i]) + Wzh(h)) r = sigmoid(Wrx(x[i]) + Wrh(h)) ht = tanh(Wx(x[i]) + Wh(h) * r) h = (1 - z) * h + z * ht H.append(h) H = tf.stack(H, axis=1) return h, H
def call(self, inputs, **kwargs): """ run a vector through the implementation :param inputs: :return: """ tensors_to_concat = [] # go through all the anchor boxes for i in range(constants.anchor_boxes): # compute the base of this anchor box anchor_base = i * self.output_channels start = sigmoid(inputs[:, :, :, anchor_base:anchor_base + 3]) middle = inputs[:, :, :, anchor_base + 3:anchor_base + 5] end = sigmoid(inputs[:, :, :, anchor_base + 5:anchor_base + self.output_channels]) # apply sigmoid activation to all but the width and height (items 3 and 4) tensors_to_concat.append(start) tensors_to_concat.append(middle) tensors_to_concat.append(end) # concatenate the three return concat(tensors_to_concat, axis=-1)
def call(self, x): raw_m, raw_l = x sig_m = activations.sigmoid(raw_m) sig_l = activations.sigmoid(raw_l) # Dim(batch, grid, grid, 5 + num_classes) sig_m = tf.split(sig_m, 3, axis=-1) raw_m = tf.split(raw_m, 3, axis=-1) sig_l = tf.split(sig_l, 3, axis=-1) raw_l = tf.split(raw_l, 3, axis=-1) for i in range(3): txty_m, _, conf_prob_m = tf.split(sig_m[i], (2, 2, -1), axis=-1) _, twth_m, _ = tf.split(raw_m[i], (2, 2, -1), axis=-1) txty_m = (txty_m - 0.5) * self.scales[0] + 0.5 bxby_m = (txty_m + self.grid_coord[0]) / self.grid_size[0] bwbh_m = (self.anchors[0][i] / self.image_size) * backend.exp(twth_m) sig_m[i] = tf.concat([bxby_m, bwbh_m, conf_prob_m], axis=-1) txty_l, _, conf_prob_l = tf.split(sig_l[i], (2, 2, -1), axis=-1) _, twth_l, _ = tf.split(raw_l[i], (2, 2, -1), axis=-1) txty_l = (txty_l - 0.5) * self.scales[1] + 0.5 bxby_l = (txty_l + self.grid_coord[1]) / self.grid_size[1] bwbh_l = (self.anchors[1][i] / self.image_size) * backend.exp(twth_l) sig_l[i] = tf.concat([bxby_l, bwbh_l, conf_prob_l], axis=-1) # Dim(batch, grid, grid, 3 * (5 + num_classes)) pred_m = tf.concat(sig_m, axis=-1) pred_l = tf.concat(sig_l, axis=-1) return pred_m, pred_l
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]
def call(self, y): yTime = self.time(y[:, 0:1]) yPlaceA = self.placeA(y[:, 1:3]) * y[:, 3:4] yPlaceB = self.placeB(y[:, 1:3]) * y[:, 4:5] yPlaceC = self.placeC(y[:, 1:3]) * y[:, 5:6] yPlace = activations.sigmoid( (yPlaceA + yPlaceB + yPlaceC - 0.5) * 10) # OR yHeadGear = self.headGear(y[:, 6:8]) return activations.sigmoid( (yTime + yPlace + yHeadGear - 2.5) * 10) # AND
def call(self, x, states): # states: [BATCH, 3 (left, top, diagonal)] left_state = states[0] #(BATCH, RECURRENT_DIM) top_state = states[1] #(BATCH, RECURRENT_DIM) diagonal_state = states[2] #(BATCH, RECURRENT_DIM) q_vec = tf.concat([left_state, top_state, diagonal_state, x], axis=1) # [BATCH, 3*RECURRENT_DIM + INPUT_DIM] # [BATCH, RECURRENT_DIM] [1, RECURRENT_DIM] reset_left = K.bias_add(K.dot(q_vec, self.w_rl), self.b_rl) reset_left = sigmoid(reset_left) # [BATCH, RECURRENT_DIM] reset_top = K.bias_add(K.dot(q_vec, self.w_rt), self.b_rt) reset_top = sigmoid(reset_top) # [BATCH, RECURRENT_DIM] reset_diagonal = K.bias_add(K.dot(q_vec, self.w_rd), self.b_rd) reset_diagonal = sigmoid(reset_diagonal) # [BATCH, RECURRENT_DIM] reset = tf.concat([reset_left, reset_top, reset_diagonal], axis=1) # [BATCH, 3*RECURRENT_DIM] _z_input = K.bias_add(K.dot(q_vec, self.w_zi), self.b_zi) # [BATCH, RECURRENT_DIM] _z_left = K.bias_add(K.dot(q_vec, self.w_zl), self.b_zl) # [BATCH, RECURRENT_DIM] _z_top = K.bias_add(K.dot(q_vec, self.w_zt), self.b_zt) # [BATCH, RECURRENT_DIM] _z_diagonal = K.bias_add(K.dot(q_vec, self.w_zd), self.b_zd) # [BATCH, RECURRENT_DIM] _z_input = tf.expand_dims(_z_input, axis=-1) _z_left = tf.expand_dims(_z_left, axis=-1) _z_top = tf.expand_dims(_z_top, axis=-1) _z_diagonal = tf.expand_dims(_z_diagonal, axis=-1) _z = tf.concat([_z_input, _z_left, _z_top, _z_diagonal], axis=-1) _z = K.softmax(_z, axis=-1) # each will have dims # [BATCH, RECURRENT_DIM] z = tf.split(_z, num_or_size_splits=4, axis=-1) z_input = K.squeeze(z[0], axis=-1) z_left = K.squeeze(z[1], axis=-1) z_top = K.squeeze(z[2], axis=-1) z_diagonal = K.squeeze(z[3], axis=-1) # compute candite hidden space _states = tf.concat([left_state, top_state, diagonal_state], axis=1) # [BATCH, 3*RECURRENT_DIM] reset_states = reset * _states # reset the hidden states # [BATCH, 3*RECURRENT_DIM] _h_reset_states = K.dot(reset_states, self.u) # [BATCH, RECURRENT_DIM] _h = K.bias_add(K.dot(x, self.w_i), self.b_i) # [BATCH, RECURRENT_DIM] _h = _h + _h_reset_states _h = self.activation(_h) h = z_left * left_state + z_top * top_state + z_diagonal * diagonal_state + z_input * _h # OUTPUT [BATCH, Features] return h#tf.random.normal((K.shape(x)[0], self.state_size))
def call(self, c1, c2, c3, x): # x channels:256 aspp output fourth_feature = self.first_conv(c1) # 1/4 eighth_feature = self.second_conv(c2) # 1/8 sixteenth_feature = self.third_conv(c3) # 1/16 x = self.conv(layers.concatenate((x, sixteenth_feature), axis=1)) x = layers.UpSampling2D(eighth_feature.size()[2:], interpolation='bilinear')(x) # upsample to 1/8 x = self.gamma * activations.sigmoid(self.att(x)) * x x = self.conv(layers.concatenate((x, eighth_feature), axis=1)) x = layers.UpSampling2D(fourth_feature.size()[2:], interpolation='bilinear')(x) # upsample to 1/4 x = self.gamma * activations.sigmoid(self.att(x)) * x x = self.last_conv(layers.concatenate((x, fourth_feature), axis=1)) # default channel last, may change return x
def forward_pass(self): self.list_activations = [] self.z = [] self.z.append(np.dot(self.weights[0], self.X) + self.biases[0]) print(self.z[0].shape) self.list_activations.append(sigmoid(self.z[0])) for i in range(1, len(self.weights)): z_out = np.dot(self.weights[i], self.list_activations[-1]) + self.biases[i] self.z.append(z_out) a_out = sigmoid(z_out) self.list_activations.append(a_out) return [n.shape for n in self.z], [n.shape for n in self.list_activations]
def call(self, inputs, training=False): """ Implements the feed forward part of the network """ x = inputs for layer in self.layers_[:-1]: x = layer(x) x = sigmoid(x) x = self.layers_[-1](x) if self.decoder: x = tanh(x) else: x = sigmoid(x) return x
def call(self, inputs, training=False): x, a, i = inputs glob_avg = tf.math.segment_mean(x, i) glob_var = abs( tf.math.subtract(tf.math.segment_mean(multiply([x, x]), i), multiply([glob_avg, glob_avg]))) glob_max = tf.math.segment_max(x, i) glob_min = tf.math.segment_min(x, i) xglob = tf.concat([glob_avg, glob_var, glob_max, glob_min], axis=1) a, e = self.generate_edge_features(x, a) for MP in self.MPs: x = MP([x, a, e]) for conv in self.GCNs: x = conv([x, a]) x1 = self.Pool1([x, i]) x2 = self.Pool2([x, i]) x3 = self.Pool3([x, i]) x = tf.concat([x1, x2, x3], axis=1) x = tf.concat([x, xglob], axis=1) for decode_layer, dropout_layer, norm_layer in zip( self.decode, self.dropout_layers, self.norm_layers): x = dropout_layer(x, training=training) x = self.decode_activation(decode_layer(x)) x = norm_layer(x, training=training) x_loge = self.loge[0](x) x_loge = self.loge[1](x_loge) x_loge = self.loge_out(x_loge) x_zeni = self.zeni[0](x) x_zeni = self.zeni[1](x_zeni) x_zeni = self.zeni_out(x_zeni) zeni = sigmoid(self.zeni_scale(x_zeni)) x_azi = self.azi[0](x) x_azi = self.azi[1](x_azi) x_azi = self.azi_out(x_azi) azi = sigmoid(self.azi_scale(x_azi)) x_sigz = self.sigz[0](x) x_sigz = self.sigz[1](x_sigz) x_sigz = tf.math.add(tf.math.abs(self.sigz_out(x_sigz)), eps) x_sigaz = self.sigaz[0](x) x_sigaz = self.sigaz[1](x_sigaz) x_sigaz = tf.math.add(tf.math.abs(self.sigaz_out(x_sigaz)), eps) #could add correlation here xs = tf.stack([x_loge, zeni * np.pi, azi * 2 * np.pi, x_sigz, x_sigaz], axis=1) return xs[:, :, 0]
def call(self, inputs, training=False): x, a, i = inputs if self.edgeconv: a, e = self.generate_edge_features(x, a) x = self.ECC1([x, a, e]) for GCN_layer in self.GCNs: x = GCN_layer([x, a]) x1 = self.Pool1([x, i]) x2 = self.Pool2([x, i]) x3 = self.Pool3([x, i]) # tf.print(x1,x2,x3, x1.shape, x2.shape, x3) x = tf.concat([x1, x2, x3], axis=1) for decode_layer, dropout_layer, norm_layer in zip( self.decode, self.dropout_layers, self.norm_layers): x = dropout_layer(x, training=training) x = self.decode_activation(decode_layer(x)) x = norm_layer(x, training=training) x = self.final(x) zeniazi = x[:, 1:3] zeniazi = sigmoid(self.angle_scale(zeniazi)) # tf.print(x) x1 = tf.stack( [x[:, 0], zeniazi[:, 0] * np.pi, zeniazi[:, 1] * 2 * np.pi], axis=1) x = tf.concat([x1, x[:, 3:]], axis=1) return x
def ACM(x, blockname, groups=32): b, w, h, c = K.int_shape(x) mu = tf.reduce_mean(x, axis=[1, 2], name=blockname + '_mu') mu = tf.expand_dims(mu, axis=1) mu = tf.expand_dims(mu, axis=1) P = Conv2D(c // 2, 1, padding='same', groups=groups, name=blockname + '_P1')(mu) P = relu(P) P = Conv2D(c, 1, padding='same', groups=groups, name=blockname + '_P2')(P) P = sigmoid(P) x_mu = x - mu k = Conv2D(c, 1, padding='same', groups=groups, name=blockname + '_K')(x_mu) q = Conv2D(c, 1, padding='same', groups=groups, name=blockname + '_Q')(x_mu) k = softmax(k) q = softmax(q) k = x_mu * k q = x_mu * q k = K.sum(k, axis=[1, 2]) q = K.sum(q, axis=[1, 2]) k_q = k - q y = x + k_q y = y * P return y
def plt_layer(X, Y, W1, b1, norm_l): Y = Y.reshape(-1, ) fig, ax = plt.subplots(1, W1.shape[1], figsize=(16, 4)) for i in range(W1.shape[1]): layerf = lambda x: sigmoid(np.dot(norm_l(x), W1[:, i]) + b1[i]) plt_prob(ax[i], layerf) ax[i].scatter(X[Y == 1, 0], X[Y == 1, 1], s=70, marker='x', c='red', label="Good Roast") ax[i].scatter(X[Y == 0, 0], X[Y == 0, 1], s=100, marker='o', facecolors='none', edgecolors=dlc["dldarkblue"], linewidth=1, label="Bad Roast") tr = np.linspace(175, 260, 50) ax[i].plot(tr, (-3 / 85) * tr + 21, color=dlc["dlpurple"], linewidth=2) ax[i].axhline(y=12, color=dlc["dlpurple"], linewidth=2) ax[i].axvline(x=175, color=dlc["dlpurple"], linewidth=2) ax[i].set_title(f"Layer 1, unit {i}") ax[i].set_xlabel("Temperature \n(Celsius)", size=12) ax[0].set_ylabel("Duration \n(minutes)", size=12) plt.show()
def predict(model, input_model): log_reg_weights = model.get_layer("output").get_weights()[0] log_reg_bias = model.get_layer("output").get_weights()[1][0] outputs = [] shapes = [] weights = [] layers_names = [layer.name for layer in model.layers] consumed = 0 for name in ["input_bool", "reshape_num_output", "reshape_cat_output"]: if name not in layers_names: continue layer = model.get_layer(name) outputs.append(layer.output) input_shape = layer.input_shape if isinstance(input_shape, list): input_shape = input_shape[0] nb_channel = input_shape[-1] if len(input_shape) > 2 else 1 nb_features = input_shape[-2] if len(input_shape) > 2 else input_shape[-1] nb_weights = nb_channel * nb_features weights.append( log_reg_weights[consumed : consumed + nb_weights].reshape( nb_features, nb_channel ) ) shapes.append((nb_features, nb_channel)) consumed += nb_weights explainable_model = Model(inputs=[model.input], outputs=[model.output, *outputs],) predictions = explainable_model.predict(input_model) probas = predictions[0] aggregated_explanation = [] for weight_slice, shape_feat, raw_explanation in zip( weights, shapes, predictions[1:] ): reshaped_expl = raw_explanation.reshape(-1, shape_feat[0], shape_feat[1]) reshaped_weights = weight_slice.reshape(1, *weight_slice.shape) feature_explanation = ( (reshaped_expl * reshaped_weights).sum(axis=-1).reshape(-1, shape_feat[0]) ) aggregated_explanation.append(feature_explanation) aggregated_explanation = np.hstack(aggregated_explanation) results = np.zeros(aggregated_explanation.shape) for idx in range(aggregated_explanation.shape[1]): expla_cpy = np.copy(aggregated_explanation) expla_cpy[:, idx] = 0 results[:, idx] = probas.reshape(-1) - sigmoid( expla_cpy.sum(axis=-1) + log_reg_bias ).numpy().reshape(-1) return probas, results
def __call__(self, tf_X): h1 = LeakyReLU(alpha=self.leakiness)(self.Bnorm1(self.conv1(tf_X))) print(h1.shape) h2 = LeakyReLU(alpha=self.leakiness)(self.Bnorm2(self.conv2(h1))) print(h2.shape) h3 = LeakyReLU(alpha=self.leakiness)(self.Bnorm3(self.conv3(h2))) print(h3.shape) h4 = LeakyReLU(alpha=self.leakiness)(self.Bnorm4(self.conv4(h3))) print(h4.shape) h5 = LeakyReLU(alpha=self.leakiness)(self.Bnorm5(self.conv5(h4))) print(h5.shape) h6 = LeakyReLU(alpha=self.leakiness)(self.Bnorm6(self.conv6(h5))) print(h6.shape) dh1 = ReLU()(self.Dropout1(self.deBnorm1(self.deconv1(h6)))) print(dh1.shape) dh2 = ReLU()(self.Dropout2( self.deBnorm2(self.deconv2(concatenate([dh1, h5]))))) print(dh2.shape) dh3 = ReLU()(self.Dropout3( self.deBnorm3(self.deconv3(concatenate([dh2, h4]))))) print(dh3.shape) dh4 = ReLU()(self.deBnorm4(self.deconv4(concatenate([dh3, h3])))) print(dh4.shape) dh5 = ReLU()(self.deBnorm5(self.deconv5(concatenate([dh4, h2])))) print(dh5.shape) dh6 = sigmoid(self.deconv6(concatenate([dh5, h1]))) print(dh6.shape) return dh6
def call(self, y): y = tf.expand_dims(y, axis=1) y = tf.exp(-tf.reduce_sum(tf.square(self.refPoints - y), axis=2) / self.twiceSigmaSquare) y = self.dense(y) y = activations.sigmoid(y) return y
def channel_attention(inputs): """Channel Attention Map calculation The function aims to implement a simple version of a Channel Attention, whose output is a tensor that will weight each channel of the input. Args: inputs: Input tensor, above which the channel map will be calculated Returns: Channel Attention map """ max_features = GlobalMaxPool2D()(inputs) avg_features = GlobalAvgPool2D()(inputs) extracted_max = extraction_network(max_features) extracted_avg = extraction_network(avg_features) merge = Add()[extracted_avg, extracted_max] return reshape(sigmoid(merge), (-1, 1, 1, inputs.shape[3]))
def __call__(self, tf_X, tf_mr1_X, tf_mr2_X): mask_list = [] h1 = LeakyReLU(alpha = self.leakiness)(self.Bnorm1(self.conv1(tf_X))) mr1_h1 = LeakyReLU(alpha=self.leakiness)(self.mr1_Bnorm1(self.mr1_conv1(tf_mr1_X))) mr2_h1 = LeakyReLU(alpha=self.leakiness)(self.mr2_Bnorm1(self.mr2_conv1(tf_mr2_X))) h2 = LeakyReLU(alpha=self.leakiness)(self.Bnorm2(self.conv2(concatenate([h1, mr1_h1])))) h3 = self.to_input_shape(concatenate([h2, mr2_h1])) print("h3:", h3.shape) for batch_num in range(h3.shape[0]): h4 = self.dense1(h3[batch_num, :, :]) h5 = self.dense2(h4) h6 = self.dense3(h5) h7 = self.dense4(h6) h8 = self.zero_pad(h7) mask_list.append(h8) h9 = tf.convert_to_tensor(mask_list, dtype=tf.float32) h10 = tf.expand_dims(h9, -1) dh1 = sigmoid(self.deconv1(h10)) print("dh1:", dh1.shape) return dh1
def call(self, x, training=True): if self.embedding_to_occur: x = self.incorporate_embeddings(x) x = self.process_hidden_layers(x, training) out = self.process_output_layers(x) if self.y_range: out = self.y_range[0] + ( self.y_range[1] - self.y_range[0]) * activations.sigmoid(out) return out
def __call__(self, inputs): y = self.contrast(inputs) + self.avg_pool(inputs) y = self.conv1(y) y = self.bn1(y) y = self.relu1(y) y = self.conv2(y) y = sigmoid(y) return inputs * y
def Squeeze_excitation_layer_simple(input_x, out_dim, ratio, layer_name): squeeze = GlobalAveragePooling2D()(input_x) excitation = sigmoid(squeeze) excitation = tf.reshape(excitation, [-1, 1, 1, out_dim]) scale = input_x * excitation return scale
def CA(self, X): c = list(X.shape)[-1] gap = GlobalAveragePooling2D()(X) d = tf.reshape(gap, shape=(-1,1,1,c)) d1 = ReLU()(Conv2D(filters=c//8, kernel_size=(1,1))(d)) d_bid = sigmoid(Conv2D(filters=c, kernel_size=(1,1))(d1)) return X*d_bid
def call(self, inputs, training=False): """ Implements the feed forward part of the network """ x = inputs for layer in self.layers_[:-1]: x = layer(x) x = relu(x, alpha=self.leaky_alpha) x = self.dropout(x, training) x = self.layers_[-1](x) return sigmoid(x)
def call(self, inputs, training=False): x, a, i = inputs ##global params, move to default non-option if self.glob: glob_avg = tf.math.segment_mean(x, i) glob_var = abs( tf.math.subtract(tf.math.segment_mean(multiply([x, x]), i), multiply([glob_avg, glob_avg]))) glob_max = tf.math.segment_max(x, i) glob_min = tf.math.segment_min(x, i) xglob = tf.concat([glob_avg, glob_var, glob_max, glob_min], axis=1) a, e = self.generate_edge_features(x, a) ##this norm should maybe be further down ahead of edgeconv if self.edgenorm: e = self.norm_edge(e) x = self.MP([x, a, e]) if self.edgeconv: a, e = self.generate_edge_features(x, a) x = self.ECC1([x, a, e]) for conv in self.GCNs: x = conv([x, a]) x1 = self.Pool1([x, i]) x2 = self.Pool2([x, i]) x3 = self.Pool3([x, i]) xpool = tf.concat([x1, x2, x3], axis=1) if self.glob: x = tf.concat([xpool, xglob], axis=1) else: x = xpool for decode_layer, dropout_layer, norm_layer in zip( self.decode, self.dropout_layers, self.norm_layers): x = dropout_layer(x, training=training) x = self.decode_activation(decode_layer(x)) x = norm_layer(x, training=training) x_loge = self.loge[0](x) x_loge = self.loge[1](x_loge) x_loge = self.loge_out(x_loge) x_angles = self.angles[0](x) x_angles = self.angles[1](x_angles) x_angles = self.angles_out(x_angles) zeniazi = sigmoid(self.angle_scale(x_angles)) if self.n_sigs > 0: x_sigs = self.sigs[0](x) x_sigs = self.sigs[1](x_sigs) x_sigs = tf.abs(self.sigs_out(x_sigs)) + eps #could add correlation here xs = tf.stack( [x_loge[:, 0], zeniazi[:, 0] * np.pi, zeniazi[:, 1] * 2 * np.pi], axis=1) if self.n_sigs > 0: return tf.concat([xs, x_sigs], axis=1) else: return xs
def __call__(self, inputs): temp1 = self.contrast(inputs) temp2 = self.avg_pool(inputs) y = temp1 + temp2 y = self.conv1(y) y = self.bn1(y) y = self.relu1(y) y = self.conv2(y) y = sigmoid(y) return inputs * y
def call(self, x, training=True): """Forward pass for the network. Note that it expects input data in the form (batch, seq length, features)""" if self.embedding_to_occur: x = self.incorporate_embeddings(x) training = training or training is None x, restricted_to_final_seq = self.process_hidden_layers(x, training) out = self.process_output_layers(x, restricted_to_final_seq) if self.y_range: out = self.y_range[0] + ( self.y_range[1] - self.y_range[0]) * activations.sigmoid(out) return out
def Squeeze_excitation_layer(input_x, out_dim, ratio): squeeze = GlobalAveragePooling2D()(input_x) excitation = Dense(units=out_dim / ratio)(squeeze) excitation = ReLU()(excitation) excitation = Dense(units=out_dim)(excitation) excitation = sigmoid(excitation) excitation = tf.reshape(excitation, [-1, 1, 1, out_dim]) scale = input_x * excitation return scale
def call(self, inputs): for i in np.arange(len(self.Dens)): if i == 0: x = self.Dens[i](inputs) else: x = self.Dens[i](x) x = self.BN[i](x) x = self.Drop[i](x) x = self.dens_last(x) # x = self.BN_last(x) return activations.sigmoid(x)
def call(self, y): yTimeLow = tf.cast(y[:, 0] > self.fromTime, dtype=tf.float32) yTimeHigh = tf.cast(y[:, 0] <= self.toTime, dtype=tf.float32) yPlaceA = tf.cast(tf.logical_and(self.atGate(0, y[:, 1], y[:, 2]), y[:, 3] == 1), dtype=tf.float32) yPlaceB = tf.cast(tf.logical_and(self.atGate(1, y[:, 1], y[:, 2]), y[:, 4] == 1), dtype=tf.float32) yPlaceC = tf.cast(tf.logical_and(self.atGate(2, y[:, 1], y[:, 2]), y[:, 5] == 1), dtype=tf.float32) yPlace = activations.sigmoid( (yPlaceA + yPlaceB + yPlaceC - 0.5) * 10) # OR yHeadGear = tf.cast(tf.logical_and(y[:, 6] == 1, y[:, 7] == 0), dtype=tf.float32) return activations.sigmoid( (yTimeLow + yTimeHigh + yPlace + yHeadGear - 3.5) * 10) # AND
def call(self, x): #. 3 heads concatenated in x : small, large, medium raw_s, raw_m, raw_l = x raw_s = self.reshape0(raw_s) raw_m = self.reshape1(raw_m) raw_l = self.reshape2(raw_l) ## extract txty_s, twth_s, conf_s, prob_s = tf.split( raw_s, (2, 2, 1, self.num_classes), axis=-1 ) txty_m, twth_m, conf_m, prob_m = tf.split( raw_m, (2, 2, 1, self.num_classes), axis=-1 ) txty_l, twth_l, conf_l, prob_l = tf.split( raw_l, (2, 2, 1, self.num_classes), axis=-1 ) txty_s = activations.sigmoid(txty_s) txty_s = (txty_s - self.a_half[0]) * self.scales[0] + self.a_half[0] bxby_s = (txty_s + self.grid_coord[0]) / self.grid_size[0] txty_m = activations.sigmoid(txty_m) txty_m = (txty_m - self.a_half[1]) * self.scales[1] + self.a_half[1] bxby_m = (txty_m + self.grid_coord[1]) / self.grid_size[1] txty_l = activations.sigmoid(txty_l) txty_l = (txty_l - self.a_half[2]) * self.scales[2] + self.a_half[2] bxby_l = (txty_l + self.grid_coord[2]) / self.grid_size[2] conf_s = activations.sigmoid(conf_s) conf_m = activations.sigmoid(conf_m) conf_l = activations.sigmoid(conf_l) prob_s = activations.sigmoid(prob_s) prob_m = activations.sigmoid(prob_m) prob_l = activations.sigmoid(prob_l) bwbh_s = (self.anchors[0] / self.image_width) * backend.exp(twth_s) bwbh_m = (self.anchors[1] / self.image_width) * backend.exp(twth_m) bwbh_l = (self.anchors[2] / self.image_width) * backend.exp(twth_l) pred_s = self.concat0([bxby_s, bwbh_s, conf_s, prob_s]) pred_m = self.concat1([bxby_m, bwbh_m, conf_m, prob_m]) pred_l = self.concat2([bxby_l, bwbh_l, conf_l, prob_l]) return pred_s, pred_m, pred_l