def distance_layer(x1, x2):
"""Distance and angle of two inputs.
Compute the concatenation of element-wise subtraction and
multiplication of two inputs.
"""
def _distance(args):
x1 = args[0]
x2 = args[1]
x = K.abs(x1 - x2)
return x
def _multiply(args):
x1 = args[0]
x2 = args[1]
return x1 * x2
distance = Lambda(_distance, output_shape=(K.int_shape(x1)[-1],))([x1, x2])
multiply = Lambda(_multiply, output_shape=(K.int_shape(x1)[-1],))([x1, x2])
return concatenate([distance, multiply])
python类concatenate()的实例源码
def get_unet0(num_start_filters=32):
inputs = Input((img_rows, img_cols, num_channels))
conv1 = ConvBN2(inputs, num_start_filters)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = ConvBN2(pool1, 2 * num_start_filters)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = ConvBN2(pool2, 4 * num_start_filters)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = ConvBN2(pool3, 8 * num_start_filters)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = ConvBN2(pool4, 16 * num_start_filters)
up6 = concatenate([UpSampling2D(size=(2, 2))(conv5), conv4])
conv6 = ConvBN2(up6, 8 * num_start_filters)
up7 = concatenate([UpSampling2D(size=(2, 2))(conv6), conv3])
conv7 = ConvBN2(up7, 4 * num_start_filters)
up8 = concatenate([UpSampling2D(size=(2, 2))(conv7), conv2])
conv8 = ConvBN2(up8, 2 * num_start_filters)
up9 = concatenate([UpSampling2D(size=(2, 2))(conv8), conv1])
conv9 = Conv2D(num_start_filters, (3, 3), padding="same", kernel_initializer="he_uniform")(up9)
conv9 = BatchNormalization()(conv9)
conv9 = Activation('selu')(conv9)
conv9 = Conv2D(num_start_filters, (3, 3), padding="same", kernel_initializer="he_uniform")(conv9)
crop9 = Cropping2D(cropping=((16, 16), (16, 16)))(conv9)
conv9 = BatchNormalization()(crop9)
conv9 = Activation('selu')(conv9)
conv10 = Conv2D(num_mask_channels, (1, 1))(conv9)
model = Model(inputs=inputs, outputs=conv10)
return model
def __call__(self, x1, x2):
def _sub_ops(args):
x1 = args[0]
x2 = args[1]
x = K.abs(x1 - x2)
return x
def _mult_ops(args):
x1 = args[0]
x2 = args[1]
return x1 * x2
output_shape = (self.sequence_length, self.input_dim,)
sub = Lambda(_sub_ops, output_shape=output_shape)([x1, x2])
mult = Lambda(_mult_ops, output_shape=output_shape)([x1, x2])
sub = self.model(sub)
mult = self.model(mult)
return concatenate([sub, mult])
def create_model(img_height,img_width,img_channel):
ip = Input(shape=(img_height, img_width,img_channel))
L1 = Conv2D(32, (11, 11), padding='same', activation='relu', kernel_initializer='glorot_uniform')(ip)
L2 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L1)
L3 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L2)
L4 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L3)
L4=concatenate([L4,L1],axis=-1)#Attention!.maybe this connection will influence the result,which means it can be moved.
L5 = Conv2D(64, (1, 1), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L4)
L6 = Conv2D(64, (5, 5), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L5)
L6=concatenate([L6,L1],axis=-1)#Attention!.maybe this connection will influence the result,which means it can be moved.
L7 = Conv2D(128, (1, 1), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L6)
L8 = Conv2D(img_channel, (5, 5), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L7)
deblocking =Model(inputs=ip,outputs= L8)
optimizer = optimizers.Adam(lr=1e-4)
deblocking.compile(optimizer=optimizer,loss='mean_squared_error', metrics=[psnr,ssim])
return deblocking
def create_model(img_height,img_width,img_channel):
ip = Input(shape=(img_height, img_width,img_channel))
L1 = Conv2D(32, (11, 11), padding='same', activation='relu', kernel_initializer='glorot_uniform')(ip)
L2 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L1)
L3 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L2)
L4 = Conv2D(64, (3, 3), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L3)
L4=concatenate([L4,L1],axis=-1)
L5 = Conv2D(64, (1, 1), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L4)
L6 = Conv2D(64, (5, 5), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L5)
L6=concatenate([L6,L1],axis=-1)
L7 = Conv2D(128, (1, 1), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L6)
L8 = Conv2D(img_channel, (5, 5), padding='same', activation='relu', kernel_initializer='glorot_uniform')(L7)
deblocking =Model(inputs=ip,outputs= L8)
optimizer = optimizers.Adam(lr=1e-4)
deblocking.compile(optimizer=optimizer,loss='mean_squared_error', metrics=[psnr,ssim])
return deblocking
def block_inception_a(input):
if K.image_data_format() == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
branch_0 = conv2d_bn(input, 96, 1, 1)
branch_1 = conv2d_bn(input, 64, 1, 1)
branch_1 = conv2d_bn(branch_1, 96, 3, 3)
branch_2 = conv2d_bn(input, 64, 1, 1)
branch_2 = conv2d_bn(branch_2, 96, 3, 3)
branch_2 = conv2d_bn(branch_2, 96, 3, 3)
branch_3 = AveragePooling2D((3,3), strides=(1,1), padding='same')(input)
branch_3 = conv2d_bn(branch_3, 96, 1, 1)
x = concatenate([branch_0, branch_1, branch_2, branch_3], axis=channel_axis)
return x
def block_reduction_a(input):
if K.image_data_format() == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
branch_0 = conv2d_bn(input, 384, 3, 3, strides=(2,2), padding='valid')
branch_1 = conv2d_bn(input, 192, 1, 1)
branch_1 = conv2d_bn(branch_1, 224, 3, 3)
branch_1 = conv2d_bn(branch_1, 256, 3, 3, strides=(2,2), padding='valid')
branch_2 = MaxPooling2D((3,3), strides=(2,2), padding='valid')(input)
x = concatenate([branch_0, branch_1, branch_2], axis=channel_axis)
return x
def block_inception_b(input):
if K.image_data_format() == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
branch_0 = conv2d_bn(input, 384, 1, 1)
branch_1 = conv2d_bn(input, 192, 1, 1)
branch_1 = conv2d_bn(branch_1, 224, 1, 7)
branch_1 = conv2d_bn(branch_1, 256, 7, 1)
branch_2 = conv2d_bn(input, 192, 1, 1)
branch_2 = conv2d_bn(branch_2, 192, 7, 1)
branch_2 = conv2d_bn(branch_2, 224, 1, 7)
branch_2 = conv2d_bn(branch_2, 224, 7, 1)
branch_2 = conv2d_bn(branch_2, 256, 1, 7)
branch_3 = AveragePooling2D((3,3), strides=(1,1), padding='same')(input)
branch_3 = conv2d_bn(branch_3, 128, 1, 1)
x = concatenate([branch_0, branch_1, branch_2, branch_3], axis=channel_axis)
return x
def block_reduction_b(input):
if K.image_data_format() == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
branch_0 = conv2d_bn(input, 192, 1, 1)
branch_0 = conv2d_bn(branch_0, 192, 3, 3, strides=(2, 2), padding='valid')
branch_1 = conv2d_bn(input, 256, 1, 1)
branch_1 = conv2d_bn(branch_1, 256, 1, 7)
branch_1 = conv2d_bn(branch_1, 320, 7, 1)
branch_1 = conv2d_bn(branch_1, 320, 3, 3, strides=(2,2), padding='valid')
branch_2 = MaxPooling2D((3, 3), strides=(2, 2), padding='valid')(input)
x = concatenate([branch_0, branch_1, branch_2], axis=channel_axis)
return x
def yolo_body(inputs, num_anchors, num_classes):
"""Create YOLO_V2 model CNN body in Keras."""
darknet = Model(inputs, darknet_body()(inputs))
conv20 = compose(
DarknetConv2D_BN_Leaky(1024, (3, 3)),
DarknetConv2D_BN_Leaky(1024, (3, 3)))(darknet.output)
conv13 = darknet.layers[43].output
conv21 = DarknetConv2D_BN_Leaky(64, (1, 1))(conv13)
# TODO: Allow Keras Lambda to use func arguments for output_shape?
conv21_reshaped = Lambda(
space_to_depth_x2,
output_shape=space_to_depth_x2_output_shape,
name='space_to_depth')(conv21)
x = concatenate([conv21_reshaped, conv20])
x = DarknetConv2D_BN_Leaky(1024, (3, 3))(x)
x = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1))(x)
return Model(inputs, x)
def inception_model(input, filters_1x1, filters_3x3_reduce, filters_3x3, filters_5x5_reduce, filters_5x5, filters_pool_proj):
conv_1x1 = Conv2D(filters=filters_1x1, kernel_size=(1, 1), padding='same', activation='relu', kernel_regularizer=l2(0.01))(input)
conv_3x3_reduce = Conv2D(filters=filters_3x3_reduce, kernel_size=(1, 1), padding='same', activation='relu', kernel_regularizer=l2(0.01))(input)
conv_3x3 = Conv2D(filters=filters_3x3, kernel_size=(3, 3), padding='same', activation='relu', kernel_regularizer=l2(0.01))(conv_3x3_reduce)
conv_5x5_reduce = Conv2D(filters=filters_5x5_reduce, kernel_size=(1, 1), padding='same', activation='relu', kernel_regularizer=l2(0.01))(input)
conv_5x5 = Conv2D(filters=filters_5x5, kernel_size=(5, 5), padding='same', activation='relu', kernel_regularizer=l2(0.01))(conv_5x5_reduce)
maxpool = MaxPooling2D(pool_size=(3, 3), strides=(1, 1), padding='same')(input)
maxpool_proj = Conv2D(filters=filters_pool_proj, kernel_size=(1, 1), strides=(1, 1), padding='same', activation='relu', kernel_regularizer=l2(0.01))(maxpool)
inception_output = concatenate([conv_1x1, conv_3x3, conv_5x5, maxpool_proj], axis=3) # use tf as backend
return inception_output
def base_model(input_shapes):
from keras.layers import Input
from keras.layers.core import Masking
x_global = Input(shape=input_shapes[0])
x_charged = Input(shape=input_shapes[1])
x_neutral = Input(shape=input_shapes[2])
x_ptreco = Input(shape=input_shapes[3])
lstm_c = Masking()(x_charged)
lstm_c = LSTM(100,go_backwards=True,implementation=2)(lstm_c)
lstm_n = Masking()(x_neutral)
lstm_n = LSTM(100,go_backwards=True,implementation=2)(lstm_n)
x = concatenate( [lstm_c, lstm_n, x_global] )
x = Dense(200, activation='relu',kernel_initializer='lecun_uniform')(x)
x = Dense(100, activation='relu',kernel_initializer='lecun_uniform')(x)
x = Dense(100, activation='relu',kernel_initializer='lecun_uniform')(x)
x = Dense(100, activation='relu',kernel_initializer='lecun_uniform')(x)
x = Dense(100, activation='relu',kernel_initializer='lecun_uniform')(x)
x = Dense(100, activation='relu',kernel_initializer='lecun_uniform')(x)
x = concatenate([x, x_ptreco])
return [x_global, x_charged, x_neutral, x_ptreco], x
def get_unet0(num_start_filters=32):
inputs = Input((img_rows, img_cols, num_channels))
conv1 = ConvBN2(inputs, num_start_filters)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = ConvBN2(pool1, 2 * num_start_filters)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = ConvBN2(pool2, 4 * num_start_filters)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = ConvBN2(pool3, 8 * num_start_filters)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = ConvBN2(pool4, 16 * num_start_filters)
up6 = concatenate([UpSampling2D(size=(2, 2))(conv5), conv4])
conv6 = ConvBN2(up6, 8 * num_start_filters)
up7 = concatenate([UpSampling2D(size=(2, 2))(conv6), conv3])
conv7 = ConvBN2(up7, 4 * num_start_filters)
up8 = concatenate([UpSampling2D(size=(2, 2))(conv7), conv2])
conv8 = ConvBN2(up8, 2 * num_start_filters)
up9 = concatenate([UpSampling2D(size=(2, 2))(conv8), conv1])
conv9 = Conv2D(num_start_filters, (3, 3), padding="same", kernel_initializer="he_uniform")(up9)
conv9 = BatchNormalization()(conv9)
conv9 = Activation('selu')(conv9)
conv9 = Conv2D(num_start_filters, (3, 3), padding="same", kernel_initializer="he_uniform")(conv9)
crop9 = Cropping2D(cropping=((16, 16), (16, 16)))(conv9)
conv9 = BatchNormalization()(crop9)
conv9 = Activation('selu')(conv9)
conv10 = Conv2D(num_mask_channels, (1, 1))(conv9)
model = Model(inputs=inputs, outputs=conv10)
return model
def initial_block(inp, nb_filter=13, nb_row=3, nb_col=3, strides=(2, 2)):
conv = Conv2D(nb_filter, (nb_row, nb_col), padding='same', strides=strides)(inp)
max_pool = MaxPooling2D()(inp)
merged = concatenate([conv, max_pool], axis=3)
return merged
def initial_block(inp, nb_filter=13, nb_row=3, nb_col=3, strides=(2, 2)):
conv = Conv2D(nb_filter, (nb_row, nb_col), padding='same', strides=strides)(inp)
max_pool, indices = MaxPoolingWithArgmax2D()(inp)
merged = concatenate([conv, max_pool], axis=3)
return merged, indices
def build_model(self, x):
pooled_tensors = []
for filter_size in self.filter_sizes:
x_i = Conv1D(self.num_filters, filter_size, activation='elu', **self.conv_kwargs)(x)
x_i = GlobalMaxPooling1D()(x_i)
pooled_tensors.append(x_i)
x = pooled_tensors[0] if len(self.filter_sizes) == 1 else concatenate(pooled_tensors, axis=-1)
return x
def __call__(self, inputs):
x = self.model(inputs)
avg_x = GlobalAveragePooling1D()(x)
max_x = GlobalMaxPooling1D()(x)
x = concatenate([avg_x, max_x])
x = BatchNormalization()(x)
return x
def simple_critic(env):
"""Build a simple critic network"""
observation = env.state
action = env.action
# Concatenate the inputs for the critic
inputs = concatenate([observation, action])
x = Dense(1)(inputs)
x = Activation('linear')(x)
# Final model
return Model(inputs=[observation, action], outputs=[x])
def configure(self, observation_space_shape, nb_actions):
# Next, we build a simple model.
# actor network
actor = Sequential()
actor.add(Flatten(input_shape=(1,) + observation_space_shape))
actor.add(Dense(16))
actor.add(Activation('relu'))
actor.add(Dense(16))
actor.add(Activation('relu'))
actor.add(Dense(16))
actor.add(Activation('relu'))
actor.add(Dense(nb_actions))
actor.add(Activation('linear'))
print(actor.summary())
# critic network
action_input = Input(shape=(nb_actions,), name='action_input')
observation_input = Input(shape=(1,) + observation_space_shape, name='observation_input')
flattened_observation = Flatten()(observation_input)
x = concatenate([action_input, flattened_observation])
x = Dense(32)(x)
x = Activation('relu')(x)
x = Dense(32)(x)
x = Activation('relu')(x)
x = Dense(32)(x)
x = Activation('relu')(x)
x = Dense(1)(x)
x = Activation('linear')(x)
critic = Model(input=[action_input, observation_input], output=x)
print(critic.summary())
# Finally, we configure and compile our agent. You can use every built-in Keras optimizer and
# even the metrics!
memory = SequentialMemory(limit=100000, window_length=1)
random_process = OrnsteinUhlenbeckProcess(size=nb_actions, theta=.15, mu=0., sigma=.3)
self.agent = DDPGAgent(nb_actions=nb_actions, actor=actor, critic=critic, critic_action_input=action_input,
memory=memory, nb_steps_warmup_critic=100, nb_steps_warmup_actor=100,
random_process=random_process, gamma=.99, target_model_update=1e-3)
self.agent.compile(Adam(lr=.001, clipnorm=1.), metrics=['mae'])
def get_model():
embedding_layer = Embedding(nb_words,
EMBEDDING_DIM,
weights=[embedding_matrix],
input_length=MAX_SEQUENCE_LENGTH,
trainable=False)
lstm_layer = LSTM(num_lstm, dropout=rate_drop_lstm, recurrent_dropout=rate_drop_lstm)
sequence_1_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')
embedded_sequences_1 = embedding_layer(sequence_1_input)
x1 = lstm_layer(embedded_sequences_1)
sequence_2_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')
embedded_sequences_2 = embedding_layer(sequence_2_input)
y1 = lstm_layer(embedded_sequences_2)
merged = concatenate([x1, y1])
merged = Dropout(rate_drop_dense)(merged)
merged = BatchNormalization()(merged)
merged = Dense(num_dense, activation=act)(merged)
merged = Dropout(rate_drop_dense)(merged)
merged = BatchNormalization()(merged)
preds = Dense(1, activation='sigmoid')(merged)
model = Model(inputs=[sequence_1_input, sequence_2_input], \
outputs=preds)
model.compile(loss='binary_crossentropy',
optimizer='nadam',
metrics=['acc'])
model.summary()
return model
#######################################
# train the model
########################################
def Encoder(hidden_size, activation=None, return_sequences=True, bidirectional=False, use_gru=True):
if activation is None:
activation = ELU()
if use_gru:
def _encoder(x):
if bidirectional:
branch_1 = GRU(int(hidden_size/2), activation='linear',
return_sequences=return_sequences, go_backwards=False)(x)
branch_2 = GRU(int(hidden_size/2), activation='linear',
return_sequences=return_sequences, go_backwards=True)(x)
x = concatenate([branch_1, branch_2])
x = activation(x)
return x
else:
x = GRU(hidden_size, activation='linear',
return_sequences=return_sequences)(x)
x = activation(x)
return x
else:
def _encoder(x):
if bidirectional:
branch_1 = LSTM(int(hidden_size/2), activation='linear',
return_sequences=return_sequences, go_backwards=False)(x)
branch_2 = LSTM(int(hidden_size/2), activation='linear',
return_sequences=return_sequences, go_backwards=True)(x)
x = concatenate([branch_1, branch_2])
x = activation(x)
return x
else:
x = LSTM(hidden_size, activation='linear',
return_sequences=return_sequences)(x)
x = activation(x)
return x
return _encoder
def AttentionDecoder(hidden_size, activation=None, return_sequences=True, bidirectional=False, use_gru=True):
if activation is None:
activation = ELU()
if use_gru:
def _decoder(x, attention):
if bidirectional:
branch_1 = AttentionWrapper(GRU(int(hidden_size/2), activation='linear', return_sequences=return_sequences,
go_backwards=False), attention, single_attention_param=True)(x)
branch_2 = AttentionWrapper(GRU(int(hidden_size/2), activation='linear', return_sequences=return_sequences,
go_backwards=True), attention, single_attention_param=True)(x)
x = concatenate([branch_1, branch_2])
return activation(x)
else:
x = AttentionWrapper(GRU(hidden_size, activation='linear',
return_sequences=return_sequences), attention, single_attention_param=True)(x)
x = activation(x)
return x
else:
def _decoder(x, attention):
if bidirectional:
branch_1 = AttentionWrapper(LSTM(int(hidden_size/2), activation='linear', return_sequences=return_sequences,
go_backwards=False), attention, single_attention_param=True)(x)
branch_2 = AttentionWrapper(LSTM(hidden_size, activation='linear', return_sequences=return_sequences,
go_backwards=True), attention, single_attention_param=True)(x)
x = concatenate([branch_1, branch_2])
x = activation(x)
return x
else:
x = AttentionWrapper(LSTM(hidden_size, activation='linear', return_sequences=return_sequences),
attention, single_attention_param=True)(x)
x = activation(x)
return x
return _decoder
def build_model(self):
initializer = initializers.random_normal(stddev=0.02)
input_img = Input(shape=(self.layers, 22, 80))
input_2 = Lambda(lambda x: x[:, 1:, :, :], output_shape=lambda x: (None, self.layers - 1, 22, 80))(input_img) # no map channel
# whole map
tower_1 = Conv2D(64, (3, 3), data_format="channels_first", strides=(1, 1), kernel_initializer=initializer, padding="same")(input_img)
tower_1 = Conv2D(32, (3, 3), data_format="channels_first", strides=(1, 1), kernel_initializer=initializer, padding="same")(tower_1)
tower_1 = MaxPooling2D(pool_size=(22, 80), data_format="channels_first")(tower_1)
#tower2
tower_2 = MaxPooling2D(pool_size=(2, 2), data_format="channels_first")(input_2)
for _ in range(self.depth):
tower_2 = Conv2D(32, (3, 3), data_format="channels_first", strides=(1, 1), kernel_initializer=initializer, padding="same", activation='relu')(tower_2)
tower_2 = MaxPooling2D(pool_size=(11, 40), data_format="channels_first")(tower_2)
#tower3
tower_3 = MaxPooling2D(pool_size=(3, 6), data_format="channels_first", padding='same')(input_2)
for _ in range(self.depth):
tower_3 = Conv2D(32, (3, 3), data_format="channels_first", strides=(1, 1), kernel_initializer=initializer, padding="same", activation='relu')(tower_3)
tower_3 = MaxPooling2D(pool_size=(8, 14), data_format="channels_first", padding='same')(tower_3)
merged_layers = concatenate([tower_1, tower_2, tower_3], axis=1)
flat_layer = Flatten()(merged_layers)
predictions = Dense(5, kernel_initializer=initializer)(flat_layer)
model = Model(inputs=input_img, outputs=predictions)
rmsprop = RMSprop(lr=0.00025)
model.compile(loss='mse', optimizer=rmsprop)
return model
def build_model(self):
initializer = initializers.random_normal(stddev=0.02)
input_img = Input(shape=(self.layers, 22, 80))
input_2 = Lambda(lambda x: x[:, :2, :, :], output_shape=lambda x: (None, 2, 22, 80))(input_img) # no map channel
# whole map 10x1
tower_1 = ZeroPadding2D(padding=(1, 0), data_format="channels_first")(input_2)
tower_1 = Conv2D(32, (10, 1), data_format="channels_first", strides=(7, 1), kernel_initializer=initializer, padding="valid")(tower_1)
tower_1 = Flatten()(tower_1)
# whole map 1x10
tower_2 = Conv2D(32, (1, 10), data_format="channels_first", strides=(1, 7), kernel_initializer=initializer, padding="valid")(input_2)
tower_2 = Flatten()(tower_2)
# whole map 3x3 then maxpool 22x80
tower_3 = Conv2D(32, (3, 3), data_format="channels_first", strides=(1, 1), kernel_initializer=initializer, padding="same")(input_2)
tower_3 = MaxPooling2D(pool_size=(22, 80), data_format="channels_first")(tower_3)
tower_3 = Flatten()(tower_3)
merged_layers = concatenate([tower_1, tower_2, tower_3], axis=1)
predictions = Dense(4, kernel_initializer=initializer)(merged_layers)
model = Model(inputs=input_img, outputs=predictions)
adam = Adam(lr=1e-6)
model.compile(loss='mse', optimizer=adam)
return model
def default_imu(num_outputs, num_imu_inputs):
'''
Notes: this model depends on concatenate which failed on keras < 2.0.8
'''
from keras.layers import Input, Dense
from keras.models import Model
from keras.layers import Convolution2D, MaxPooling2D, Reshape, BatchNormalization
from keras.layers import Activation, Dropout, Flatten, Cropping2D, Lambda
from keras.layers.merge import concatenate
img_in = Input(shape=(120,160,3), name='img_in')
imu_in = Input(shape=(num_imu_inputs,), name="imu_in")
x = img_in
x = Cropping2D(cropping=((60,0), (0,0)))(x) #trim 60 pixels off top
#x = Lambda(lambda x: x/127.5 - 1.)(x) # normalize and re-center
x = Convolution2D(24, (5,5), strides=(2,2), activation='relu')(x)
x = Convolution2D(32, (5,5), strides=(2,2), activation='relu')(x)
x = Convolution2D(64, (3,3), strides=(2,2), activation='relu')(x)
x = Convolution2D(64, (3,3), strides=(1,1), activation='relu')(x)
x = Convolution2D(64, (3,3), strides=(1,1), activation='relu')(x)
x = Flatten(name='flattened')(x)
x = Dense(100, activation='relu')(x)
x = Dropout(.1)(x)
y = imu_in
y = Dense(14, activation='relu')(y)
y = Dense(14, activation='relu')(y)
y = Dense(14, activation='relu')(y)
z = concatenate([x, y])
z = Dense(50, activation='relu')(z)
z = Dropout(.1)(z)
z = Dense(50, activation='relu')(z)
z = Dropout(.1)(z)
outputs = []
for i in range(num_outputs):
outputs.append(Dense(1, activation='linear', name='out_' + str(i))(z))
model = Model(inputs=[img_in, imu_in], outputs=outputs)
model.compile(optimizer='adam',
loss='mse')
return model
def _build(self, models, layers=[]):
for layer in layers:
layer.name = '%s/%s' % (self.scope, layer.name)
inputs, outputs = self._get_inputs_outputs(models)
x = concatenate(outputs)
for layer in layers:
x = layer(x)
model = km.Model(inputs, x, name=self.name)
return model
def _merge_inputs(self, inputs):
return concatenate(inputs, axis=2)
def test_multi_directory_iterator_race_condition(sample_dataset_dir):
n_models = 2
batch_size = 4
train_path = os.path.join(sample_dataset_dir, 'Training')
val_path = os.path.join(sample_dataset_dir, 'Validation')
# set up training and validation generators
train_gen = MultiDirectoryIterator([make_dir_iterator(train_path, batch_size) for _ in range(n_models)])
val_gen = MultiDirectoryIterator([make_dir_iterator(val_path, batch_size) for _ in range(n_models)])
# join some MobileNets
base_models = []
for i in range(n_models):
model = MobileNet(weights=None)
for layer in model.layers:
layer.name += str(i)
base_models.append(model)
x = concatenate([m.output for m in base_models])
x = Dense(create_class_histogram(train_path).shape[0], name='dense')(x)
x = Activation('softmax', name='act_softmax')(x)
joined_model = Model([m.input for m in base_models], x)
# run a few epochs
joined_model.compile(optimizer=optimizers.SGD(), loss='categorical_crossentropy')
joined_model.fit_generator(train_gen, validation_data=val_gen, epochs=4, workers=16,
steps_per_epoch=int(np.ceil(train_gen.samples / batch_size)),
validation_steps=int(np.ceil(val_gen.samples / batch_size)))
# intentionally no assert, test passes if nothing throws
def denseblock(x, nb_layers, nb_filter, growth_rate):
for i in range(nb_layers):
if i<=2:
kernel_size=3
elif i==3 or i==5:
kernel_size=1
else:
kernel_size=5
merge_tensor = conv_factory(x, growth_rate,kernel_size)
#x = merge([merge_tensor, x], mode='concat', concat_axis=-1)
x=concatenate([merge_tensor, x],axis=-1)
return x
def __dense_block(x, nb_layers, nb_filter, growth_rate, bottleneck=False, dropout_rate=None, weight_decay=1e-4,
grow_nb_filters=True, return_concat_list=False):
''' Build a dense_block where the output of each conv_block is fed to subsequent ones
Args:
x: keras tensor
nb_layers: the number of layers of conv_block to append to the model.
nb_filter: number of filters
growth_rate: growth rate
bottleneck: bottleneck block
dropout_rate: dropout rate
weight_decay: weight decay factor
grow_nb_filters: flag to decide to allow number of filters to grow
return_concat_list: return the list of feature maps along with the actual output
Returns: keras tensor with nb_layers of conv_block appended
'''
concat_axis = 1 if K.image_data_format() == 'channels_first' else -1
x_list = [x]
for i in range(nb_layers):
cb = __conv_block(x, growth_rate, bottleneck, dropout_rate, weight_decay)
x_list.append(cb)
x = concatenate([x, cb], axis=concat_axis)
if grow_nb_filters:
nb_filter += growth_rate
if return_concat_list:
return x, nb_filter, x_list
else:
return x, nb_filter
