for line in f:
values = line.split()
word = values[0]
coefs = np.asarray(values[1:], dtype='float32')
embeddings_index[word] = coefs
f.close()
embedding_matrix = np.zeros((len(word_index) + 1, 100))
for word, i in word_index.items():
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None:
# words not found in embedding index will be all-zeros.
embedding_matrix[i] = embedding_vector
print('Found %s word vectors.' % len(embeddings_index))
author_a = Input(shape=(1000, ))
author_b = Input(shape=(1000, ))
input_a=Input(shape=(13,))
input_b=Input(shape=(13,))
base_network=create_base_networkText()
base_networkA=base_network([author_a,input_a])
base_networkB=base_network([author_b,input_b])
distance = Lambda(function=euclidean_distance,
output_shape=(1,))([base_networkA, base_networkB])
# merged_vector = keras.layers.concatenate([base_networkA, base_networkB], axis=-1)
# predictionsDense = Dense(units=512, activation='tanh',kernel_regularizer=l2(0.01))(merged_vector)
# predictionsDrop=Dropout(0.25)(predictionsDense)
# predictions = Dense(units=1, activation='sigmoid',kernel_regularizer=l2(0.01))(predictionsDrop)
model = Model(inputs=[author_a,input_a,author_b,input_b], outputs=distance)
rms = RMSprop()
model.summary()
# 将类型信息进行one-hot编码(10类)
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
# 将图片信息转换数据类型
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
# 归一化
x_train /= 255
x_test /= 255
# -------------------------- 读取数据与数据预处理 -------------------------------
# -------------------------- 4、搭建CNN模型 -------------------------------
imput = Input(shape=(28, 28, 1))
class CNNmodel2(keras.Model):
def __init__(self):
super(CNNmodel2, self).__init__(name='CNN2')
self.conv2d1 = keras.layers.Conv2D(
32,
(3, 3),
padding='same', # 32，(3,3)是卷积核数量和大小
# input_shape=(28, 28, 1),
activation='relu')
self.conv2d2 = keras.layers.Conv2D(32, (3, 3), activation='relu')
self.maxpool1 = keras.layers.MaxPool2D(pool_size=(2, 2))
self.dropout1 = keras.layers.Dropout(0.25)
from keras import Input from keras import layers from keras import Model input_tensor=Input(shape=(64,)) x=layers.Dense(32,activation='relu')(input_tensor) x=layers.Dense(32,activation='relu')(x) output_tensor=layers.Dense(10,activation='softmax')(x) model=Model(input_tensor,output_tensor) model.summary() model.compile(optimizer='rmsprop',loss='sparse_categorical_crossentropy',metrics=['acc']) import numpy as np x_train=np.random.random((1000,64)) y_train=np.random.randint(0,10,1000) model.fit(x_train,y_train,epochs=10,batch_size=128) score=model.evaluate(x_train.y_train)
def FCN_8s(
input_shape=(256, 256, 3),
num_classes=2,
num_conv_filters=4096,
use_bias=True,
weight_decay=0.,
last_activation='sigmoid' # or e.g. 'sorftmax'
):
wd = weight_decay
kr = regularizers.l2
in1 = Input(shape=input_shape)
ki = 'glorot_uniform'
y_pad = input_shape[0] % 32
x_pad = input_shape[1] % 32
assert y_pad == 0 and x_pad == 0
base_model = VGG16(include_top=False, input_tensor=in1, pooling=None)
pool3 = base_model.layers[-9].output
pool4 = base_model.layers[-5].output
pool5 = base_model.layers[-1].output
relu6 = Conv2D(num_conv_filters,
7,
activation='relu',
kernel_regularizer=kr(wd),
kernel_initializer=ki,
use_bias=use_bias,
padding='same',
name='fc6_relu6')(pool5)
drop6 = Dropout(0.5)(relu6)
relu7 = Conv2D(num_conv_filters,
1,
activation='relu',
kernel_regularizer=kr(wd),
kernel_initializer=ki,
use_bias=use_bias,
name='fc7_relu7')(drop6)
drop7 = Dropout(0.5)(relu7)
score_fr = Conv2D(num_classes,
1,
kernel_regularizer=kr(wd),
use_bias=use_bias,
name='conv_fc3')(drop7)
upscore2 = Conv2DTranspose(num_classes,
4,
strides=(2, 2),
padding='same',
kernel_regularizer=kr(wd),
kernel_initializer=ki,
use_bias=False,
name='upscore2')(score_fr)
score_pool4 = Conv2D(num_classes,
1,
kernel_regularizer=kr(wd),
use_bias=use_bias)(pool4)
fuse_pool4 = add([upscore2, score_pool4])
upscore_pool4 = Conv2DTranspose(num_classes,
4,
strides=(2, 2),
padding='same',
kernel_regularizer=kr(wd),
kernel_initializer=ki,
use_bias=False,
name='upscore_pool4')(fuse_pool4)
score_pool3 = Conv2D(num_classes,
1,
kernel_regularizer=kr(wd),
use_bias=use_bias)(pool3)
fuse_pool3 = add([upscore_pool4, score_pool3])
upscore8 = Conv2DTranspose(num_classes,
16,
strides=(8, 8),
padding='same',
kernel_regularizer=kr(wd),
kernel_initializer=ki,
use_bias=False,
name='upscore8')(fuse_pool3)
score = Activation(last_activation)(upscore8)
model = Model(in1, score)
model.summary()
return model
def deeplabv3plus(pretrained_weights=None,
input_shape=(256, 256, 1),
out_stride=16):
img_input = Input(shape=input_shape)
x = Conv2D(32, (3, 3), strides=(2, 2), padding="same",
use_bias=False)(img_input)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = Conv2D(64, (3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = res_xception_downsample_block(x, 128)
res = Conv2D(256, (1, 1), strides=(2, 2), padding="same",
use_bias=False)(x)
res = BatchNormalization()(res)
x = Activation("relu")(x)
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Conv2D(256, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Conv2D(256, (1, 1), padding="same", use_bias=False)(x)
skip = BatchNormalization()(x)
x = Activation("relu")(skip)
x = DepthwiseConv2D((3, 3), strides=(2, 2), padding="same",
use_bias=False)(x)
x = BatchNormalization()(x)
x = Conv2D(256, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = add([x, res])
x = xception_downsample_block(x, 728, top_relu=True)
for i in range(16):
x = res_xception_block(x, 728)
res = Conv2D(1024, (1, 1), padding="same", use_bias=False)(x)
res = BatchNormalization()(res)
x = Activation("relu")(x)
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Conv2D(728, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Conv2D(1024, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Conv2D(1024, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = add([x, res])
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Conv2D(1536, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Conv2D(1536, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Conv2D(2048, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
# aspp
x = aspp(x, input_shape, out_stride)
x = Conv2D(256, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = Dropout(0.9)(x)
##decoder
x = BilinearUpsampling((4, 4))(x)
dec_skip = Conv2D(48, (1, 1), padding="same", use_bias=False)(skip)
dec_skip = BatchNormalization()(dec_skip)
dec_skip = Activation("relu")(dec_skip)
x = Concatenate()([x, dec_skip])
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = Conv2D(256, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = DepthwiseConv2D((3, 3), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = Conv2D(256, (1, 1), padding="same", use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = Conv2D(1, (1, 1), padding="same")(x)
x = BilinearUpsampling((4, 4))(x)
x = Activation('sigmoid')(x)
model = Model(inputs=img_input, outputs=x)
if (pretrained_weights):
model.load_weights(pretrained_weights)
return model
def Conv2DClassifierIn1(x_train, y_train, x_test, y_test):
summary = True
verbose = 1
# setHyperParams------------------------------------------------------------------------------------------------
batch_size = {{choice([32, 64, 128, 256])}}
epoch = {{choice([25, 50, 75, 100, 125, 150, 175, 200])}}
conv_block = {{choice(['two', 'three', 'four'])}}
conv1_num = {{choice([8, 16, 32, 64])}}
conv2_num = {{choice([16, 32, 64, 128])}}
conv3_num = {{choice([32, 64, 128])}}
conv4_num = {{choice([32, 64, 128, 256])}}
dense1_num = {{choice([128, 256, 512])}}
dense2_num = {{choice([64, 128, 256])}}
l1_regular_rate = {{uniform(0.00001, 1)}}
l2_regular_rate = {{uniform(0.000001, 1)}}
drop1_num = {{uniform(0.1, 1)}}
drop2_num = {{uniform(0.0001, 1)}}
activator = {{choice(['elu', 'relu', 'tanh'])}}
optimizer = {{choice(['adam', 'rmsprop', 'SGD'])}}
#---------------------------------------------------------------------------------------------------------------
kernel_size = (3, 3)
pool_size = (2, 2)
initializer = 'random_uniform'
padding_style = 'same'
loss_type = 'binary_crossentropy'
metrics = ['accuracy']
my_callback = None
# early_stopping = EarlyStopping(monitor='val_loss', patience=4)
# checkpointer = ModelCheckpoint(filepath='keras_weights.hdf5',
# verbose=1,
# save_best_only=True)
# my_callback = callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.2,
# patience=5, min_lr=0.0001)
# build --------------------------------------------------------------------------------------------------------
input_layer = Input(shape=x_train.shape[1:])
conv = layers.Conv2D(conv1_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(input_layer)
conv = layers.Conv2D(conv1_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(conv)
if conv_block == 'two':
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
elif conv_block == 'three':
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
conv = layers.Conv2D(conv3_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv3_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
elif conv_block == 'four':
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv2_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
conv = layers.Conv2D(conv3_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv3_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
conv = layers.Conv2D(conv4_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(pool)
conv = layers.Conv2D(conv4_num,
kernel_size,
padding=padding_style,
kernel_initializer=initializer,
activation=activator)(conv)
BatchNorm = layers.BatchNormalization(axis=-1)(conv)
pool = layers.MaxPooling2D(pool_size, padding=padding_style)(BatchNorm)
flat = layers.Flatten()(pool)
drop = layers.Dropout(drop1_num)(flat)
dense = layers.Dense(dense1_num,
activation=activator,
kernel_regularizer=regularizers.l1_l2(
l1=l1_regular_rate, l2=l2_regular_rate))(drop)
BatchNorm = layers.BatchNormalization(axis=-1)(dense)
drop = layers.Dropout(drop2_num)(BatchNorm)
dense = layers.Dense(dense2_num,
activation=activator,
kernel_regularizer=regularizers.l1_l2(
l1=l1_regular_rate, l2=l2_regular_rate))(drop)
output_layer = layers.Dense(len(np.unique(y_train)),
activation='softmax')(dense)
model = models.Model(inputs=input_layer, outputs=output_layer)
if summary:
model.summary()
# train(self):
class_weights = class_weight.compute_class_weight('balanced',
np.unique(y_train),
y_train.reshape(-1))
class_weights_dict = dict(enumerate(class_weights))
model.compile(
optimizer=optimizer,
loss=loss_type,
metrics=metrics # accuracy
)
result = model.fit(x=x_train,
y=y_train,
batch_size=batch_size,
epochs=epoch,
verbose=verbose,
callbacks=my_callback,
validation_data=(x_test, y_test),
shuffle=True,
class_weight=class_weights_dict)
validation_acc = np.amax(result.history['val_acc'])
print('Best validation acc of epoch:', validation_acc)
return {'loss': -validation_acc, 'status': STATUS_OK, 'model': model}
def danet_resnet101(height=256, width=256, channel=1):
input = Input(shape=(height, width, channel))
conv1_1 = Conv2D(64,
7,
strides=(2, 2),
padding='same',
use_bias=False,
kernel_initializer='he_normal')(input)
conv1_1 = BatchNormalization(axis=3)(conv1_1)
conv1_1 = Activation('relu')(conv1_1)
conv1_2 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2),
padding='same')(conv1_1)
# conv2_x 1/4
conv2_1 = bottleneck_Block(conv1_2,
256,
strides=(1, 1),
with_conv_shortcut=True)
conv2_2 = bottleneck_Block(conv2_1, 256)
conv2_3 = bottleneck_Block(conv2_2, 256)
# conv3_x 1/8
conv3_1 = bottleneck_Block(conv2_3,
512,
strides=(2, 2),
with_conv_shortcut=True)
conv3_2 = bottleneck_Block(conv3_1, 512)
conv3_3 = bottleneck_Block(conv3_2, 512)
conv3_4 = bottleneck_Block(conv3_3, 512)
# conv4_x 1/16
conv4_1 = bottleneck_Block(conv3_4,
1024,
strides=(1, 1),
dilation=(2, 2),
with_conv_shortcut=True)
conv4_2 = bottleneck_Block(conv4_1, 1024, dilation=(2, 2))
conv4_3 = bottleneck_Block(conv4_2, 1024, dilation=(2, 2))
conv4_4 = bottleneck_Block(conv4_3, 1024, dilation=(2, 2))
conv4_5 = bottleneck_Block(conv4_4, 1024, dilation=(2, 2))
conv4_6 = bottleneck_Block(conv4_5, 1024, dilation=(2, 2))
conv4_7 = bottleneck_Block(conv4_6, 1024, dilation=(2, 2))
conv4_8 = bottleneck_Block(conv4_7, 1024, dilation=(2, 2))
conv4_9 = bottleneck_Block(conv4_8, 1024, dilation=(2, 2))
conv4_10 = bottleneck_Block(conv4_9, 1024, dilation=(2, 2))
conv4_11 = bottleneck_Block(conv4_10, 1024, dilation=(2, 2))
conv4_12 = bottleneck_Block(conv4_11, 1024, dilation=(2, 2))
conv4_13 = bottleneck_Block(conv4_12, 1024, dilation=(2, 2))
conv4_14 = bottleneck_Block(conv4_13, 1024, dilation=(2, 2))
conv4_15 = bottleneck_Block(conv4_14, 1024, dilation=(2, 2))
conv4_16 = bottleneck_Block(conv4_15, 1024, dilation=(2, 2))
conv4_17 = bottleneck_Block(conv4_16, 1024, dilation=(2, 2))
conv4_18 = bottleneck_Block(conv4_17, 1024, dilation=(2, 2))
conv4_19 = bottleneck_Block(conv4_18, 1024, dilation=(2, 2))
conv4_20 = bottleneck_Block(conv4_19, 1024, dilation=(2, 2))
conv4_21 = bottleneck_Block(conv4_20, 1024, dilation=(2, 2))
conv4_22 = bottleneck_Block(conv4_21, 1024, dilation=(2, 2))
conv4_23 = bottleneck_Block(conv4_22, 1024, dilation=(2, 2))
# conv5_x 1/32
conv5_1 = bottleneck_Block(conv4_23,
2048,
strides=(1, 1),
dilation=(4, 4),
with_conv_shortcut=True)
conv5_2 = bottleneck_Block(conv5_1, 2048, dilation=(4, 4))
conv5_3 = bottleneck_Block(conv5_2, 2048, dilation=(4, 4))
# ATTENTION
reduce_conv5_3 = Conv2D(512,
3,
padding='same',
use_bias=False,
kernel_initializer='he_normal')(conv5_3)
reduce_conv5_3 = BatchNormalization(axis=3)(reduce_conv5_3)
reduce_conv5_3 = Activation('relu')(reduce_conv5_3)
pam = PAM()(reduce_conv5_3)
pam = Conv2D(512,
3,
padding='same',
use_bias=False,
kernel_initializer='he_normal')(pam)
pam = BatchNormalization(axis=3)(pam)
pam = Activation('relu')(pam)
pam = Dropout(0.5)(pam)
pam = Conv2D(512,
3,
padding='same',
use_bias=False,
kernel_initializer='he_normal')(pam)
cam = CAM()(reduce_conv5_3)
cam = Conv2D(512,
3,
padding='same',
use_bias=False,
kernel_initializer='he_normal')(cam)
cam = BatchNormalization(axis=3)(cam)
cam = Activation('relu')(cam)
cam = Dropout(0.5)(cam)
cam = Conv2D(512,
3,
padding='same',
use_bias=False,
kernel_initializer='he_normal')(cam)
feature_sum = add([pam, cam])
feature_sum = Dropout(0.5)(feature_sum)
feature_sum = Conv2d_BN(feature_sum, 512, 1)
merge7 = concatenate([conv3_4, feature_sum], axis=3)
conv7 = Conv2d_BN(merge7, 512, 3)
conv7 = Conv2d_BN(conv7, 512, 3)
up8 = Conv2d_BN(UpSampling2D(size=(2, 2))(conv7), 256, 2)
merge8 = concatenate([conv2_3, up8], axis=3)
conv8 = Conv2d_BN(merge8, 256, 3)
conv8 = Conv2d_BN(conv8, 256, 3)
up9 = Conv2d_BN(UpSampling2D(size=(2, 2))(conv8), 64, 2)
merge9 = concatenate([conv1_1, up9], axis=3)
conv9 = Conv2d_BN(merge9, 64, 3)
conv9 = Conv2d_BN(conv9, 64, 3)
up10 = Conv2d_BN(UpSampling2D(size=(2, 2))(conv9), 64, 2)
conv10 = Conv2d_BN(up10, 64, 3)
conv10 = Conv2d_BN(conv10, 64, 3)
conv11 = Conv2d_BN(conv10, 1, 1)
activation = Activation('sigmoid', name='Classification')(conv11)
model = Model(inputs=input, outputs=activation)
return model
from keras import layers
from keras import Input
from keras.models import Model
vocabulary_size = 50000
num_income_groups = 10
posts_input = Input(shape=(None, ), dtype='int32', name='posts')
embedded_posts = layers.Embedding(vocabulary_size, 256)(posts_input)
x = layers.Conv1D(128, 5, activation='relu')(embedded_posts)
x = layers.MaxPooling1D(5)(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.MaxPooling1D(5)(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.GlobalMaxPooling1D()(x)
x = layers.Dense(128, activation='relu')(x)
age_prediction = layers.Dense(1, name='age')(x)
# Note that the output layers are given names.
income_prediction = layers.Dense(num_income_groups,
activation='softmax',
name='income')(x)
gender_prediction = layers.Dense(1, activation='sigmoid', name='gender')(x)
model = Model(posts_input,
[age_prediction, income_prediction, gender_prediction])
model.summary()
model.compile(optimizer='rmsprop',
loss=['mse', 'categorical_crossentropy', 'binary_crossentropy'],
loss_weights=[0.25, 1., 10.])
# Equivalent(possible only if you give names to the output layers)
# model.compile(optimizer='rmsprop',
if (delete_model == 'yes'):
os.remove('../results/model/deep_learning_model.h5')
print('File deleted')
reponse = True
elif (delete_model == 'no'):
print('File no deleted')
reponse = True
else:
reponse = False
if (verify_exit_model != True):
# Create deep learning model.
print("Model of deep learning")
# input layer
inputs_layer = Input(shape=(14, 32, 32, 32))
# convolutional layers
conv_layer1 = Convolution3D(filters=64,
kernel_size=(5, 5, 5),
padding='valid',
activation="relu",
data_format='channels_first')(inputs_layer)
conv_layer2 = Convolution3D(filters=64,
padding='valid',
kernel_size=(3, 3, 3),
activation="relu",
data_format='channels_first')(conv_layer1)
# Dropout = 0.2
def VGG16(include_top=True, weights='imagenet',
input_tensor=None, input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the VGG16 architecture.
Optionally loads weights pre-trained
on ImageNet. Note that when using TensorFlow,
for best performance you should set
`image_data_format='channels_last'` in your Keras config
at ~/.keras/keras.json.
The model and the weights are compatible with both
TensorFlow and Theano. The data format
convention used by the model is the one
specified in your Keras config file.
# Arguments
include_top: whether to include the 3 fully-connected
layers at the top of the network.
weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(224, 224, 3)` (with `channels_last` data format)
or `(3, 224, 224)` (with `channels_first` data format).
It should have exactly 3 input channels,
and width and height should be no smaller than 48.
E.g. `(200, 200, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
"""
if not (weights in {'imagenet', None} or os.path.exists(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=48,
data_format=K.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# Block 1
x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(img_input)
x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
# Block 2
x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
# Block 3
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x)
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x)
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
# Block 4
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
# Block 5
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)
if include_top:
# Classification block
x = Flatten(name='flatten')(x)
x = Dense(4096, activation='relu', name='fc1')(x)
x = Dense(4096, activation='relu', name='fc2')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name='vgg16')
# load weights
if weights == 'imagenet':
if include_top:
weights_path = WEIGHTS_PATH
else:
weights_path = WEIGHTS_PATH_NO_TOP
model.load_weights(weights_path)
if K.backend() == 'theano':
layer_utils.convert_all_kernels_in_model(model)
if K.image_data_format() == 'channels_first':
if include_top:
maxpool = model.get_layer(name='block5_pool')
shape = maxpool.output_shape[1:]
dense = model.get_layer(name='fc1')
layer_utils.convert_dense_weights_data_format(dense, shape, 'channels_first')
if K.backend() == 'tensorflow':
warnings.warn('You are using the TensorFlow backend, yet you '
'are using the Theano '
'image data format convention '
'(`image_data_format="channels_first"`). '
'For best performance, set '
'`image_data_format="channels_last"` in '
'your Keras config '
'at ~/.keras/keras.json.')
elif weights is not None:
model.load_weights(weights)
return model
def first_train(train_generator, validation_generator):
if os.path.exists(first_trained_weights):
model = load_model(first_trained_weights)
else:
# create the base pre-trained model
# input_tensor = Input(shape=(299, 299, 3))
# base_model = Xception(include_top=True, weights='imagenet', input_tensor=None, input_shape=None)
# plot_model(base_model, to_file='xception_model.png')
# base_model.layers.pop()
# base_model.outputs = [base_model.layers[-1].output]
# base_model.layers[-1].outbound_nodes = []
# base_model.output_layers = [base_model.layers[-1]]
base_model1 = get_model_out(Xception, (299, 299))
base_model2 = get_model_out(InceptionV3, (299, 299))
# for i, layer in enumerate(base_model.layers):
# print (i, layer.name)
# feature = base_model
img1 = Input(shape=(299, 299, 3), name='img_1')
img2 = Input(shape=(299, 299, 3), name='img_2')
# feature3 = feature(img1)
feature1 = GlobalAveragePooling2D()(base_model1(img1))
feature2 = GlobalAveragePooling2D()(base_model2(img2))
# feature2 = GlobalAveragePooling2D()(base_model1(img2))
# let's add a fully-connected layer
category_predict1 = add_new_last_layer(feature1,
nb_classes,
name='ctg_out_1')
category_predict2 = add_new_last_layer(feature2,
nb_classes,
name='ctg_out_2')
# category_predict1 = Dense(100, activation='softmax', name='ctg_out_1')(
# Dropout(0.5)(feature1)
# )
# category_predict2 = Dense(100, activation='softmax', name='ctg_out_2')(
# Dropout(0.5)(feature2)
# )
# concatenated = keras.layers.concatenate([feature1, feature2])
dis = Lambda(eucl_dist, name='square')([feature1, feature2])
# concatenated = Dropout(0.5)(concatenated)
# let's add a fully-connected layer
# x = Dense(1024, activation='relu')(concatenated)
x = Dense(256)(dis)
# add BN layer and Dropout
x = BatchNormalization()(x)
x = Activation('relu')(x)
judge = Dense(2, activation='softmax', name='bin_out')(x)
# judge = Dense(1, activation='sigmoid', name='bin_out')(x)
model = Model(inputs=[img1, img2],
outputs=[category_predict1, category_predict2, judge])
for i, layer in enumerate(model.layers):
print(i, layer.name)
# model.save('dog_xception.h5')
plot_model(model,
to_file='model_combined_inv3_xception.png',
show_shapes=True)
# first: train only the top layers (which were randomly initialized)
# i.e. freeze all convolutional layers
for layer in base_model1.layers:
layer.trainable = False
for layer in base_model2.layers:
layer.trainable = False
# compile the model (should be done *after* setting layers to non-trainable)
model.compile(
optimizer='nadam',
loss={
'ctg_out_1': 'categorical_crossentropy',
'ctg_out_2': 'categorical_crossentropy',
'bin_out': 'categorical_crossentropy'
},
# 'bin_out': 'binary_crossentropy'},
loss_weights={
'ctg_out_1': 1.,
'ctg_out_2': 1.,
'bin_out': 0
},
metrics=['accuracy'])
# model = make_parallel(model, 3)
# train the model on the new data for a few epochs
save_model = ModelCheckpoint(
'xcep_incep{epoch:01d}-{ctg_out_1_acc:.4f}-{ctg_out_2_acc:.4f}_top_best.h5',
monitor='loss',
save_best_only=True,
mode='auto',
period=1)
model.fit_generator(
pair_generator(train_generator, batch_size=batch_size),
# steps_per_epoch=train_generator.samples // batch_size, # must divided exactly,
steps_per_epoch=train_generator.samples / batch_size + 1,
epochs=5,
validation_data=pair_generator(validation_generator,
train=False,
batch_size=batch_size),
validation_steps=validation_generator.samples / batch_size + 1,
callbacks=[early_stopping, auto_lr, save_model])
model.save('dog_inceptionv3_xception.h5')
# encoding train set
encoder.fit(action_train)
encoded_Y_train = encoder.transform(action_train)
action_train_encoded = keras.utils.np_utils.to_categorical(encoded_Y_train)
# encoding valid set
encoder.fit(action_valid)
encoded_Y_valid = encoder.transform(action_valid)
action_valid_encoded = keras.utils.np_utils.to_categorical(encoded_Y_valid)
# encoding test set
encoder.fit(action_test)
encoded_Y_test = encoder.transform(action_test)
action_test_encoded = keras.utils.np_utils.to_categorical(encoded_Y_test)
# input layer
image_input = Input(shape=img_train.shape[1:], name="image_input")
# Image processing layer
base_cnn_model = ResNet50(weights="imagenet")
# ResNet50 output from input layer
x = base_cnn_model(image_input)
# We stack dense layers and dropout layers to avoid overfitting after that
x = Dense(1000, activation="relu")(x)
x = Dropout(0.4)(x)
x = Dense(1000, activation="relu")(x)
x = Dropout(0.2)(x)
# Predictions
predictions = Dense(3, activation='softmax')(x)
def independent_avg_modular_deeptrack_L1(# bad name
layer_size,
train_generator,
input_shape=(51,51,1),
output_shape=3,
nbr_nodes_added=1,
sample_sizes=(8, 32, 128, 512, 1024),
iteration_numbers=(401, 301, 201, 101, 51),
verbose=0.01,
save_networks=False,
mp_training=False, # use multiprocessing training
translation_distance=5, # parameters for multiprocessing training
SN_limits=[10,100], # parameters for multiprocessing training
model_path="", # determines the type of layer used for combining the
# predictions. Addition and average only options at the moment
):
"""
First layer in the modular averaging architecture where each layer is
trained independetly of previous ones.
Inputs:
layer_size - size of first layer in model
train_generator - generator for images
output_shape - number of outputs from network, 3 for normal deeptrack
nbr_nodes_added - number of nodes to add at a time
sample_size - same as deeptrack
iteration_numbers - same as deeptrack
save_networks - if networks are to be saved automatically once training is finished
mp_training - use multiprocessing to speed up training. Not available for custom
image generators as supplied by train_generator, uses FBFs own image generator.
translation_distance - parameter for mp_training image generator, determines
the area the particle is allowed to appear in
SN_limits -
Outputs:
TODO - Implement weight decay in later layers and lowering learning rate
"""
import deeptrack
import keras
from keras import Input,models,layers
from keras.models import Model
from feature_by_feature import freeze_all_layers
#import deeptrackelli_mod_mproc as multiprocess_training # Needed for fast parallelized image generator
input_tensor = Input(input_shape)
conv_list = [] # List of convolutional neruons in L1, needed for subsequent layers
flattened_list = [] # List of flattened layers
output_list = [] # List of the output layers
# Loop thorugh the neoruns and add them one by one
for i in range(round(layer_size/nbr_nodes_added)):
next_node = layers.Conv2D(nbr_nodes_added,(3,3),activation='relu')(input_tensor)
next_node = layers.MaxPooling2D((2,2))(next_node)
if(i==0):
# i = 0 special case. No addition needed
next_flattened = layers.Flatten()(next_node)
next_output = layers.Dense(3)(next_flattened)
final_output = next_output
output_list.append(next_output)
flattened_list.append(next_flattened)
else:
# Construct the next output node
next_flattened = layers.Flatten()(next_node)
flattened_list.append(next_flattened)
# Can't concatenate a single layer
if(len(flattened_list)>1):
next_output = layers.Concatenate(axis=-1)(flattened_list)
next_output = layers.Dense(3)(next_output)
output_list.append(next_output)
# Construct and compile network
network = models.Model(input_tensor,next_output)
network.compile(optimizer='rmsprop', loss='mse', metrics=['mse', 'mae'])
network.summary()
# Train and freeze layers in network
if mp_training:
deeptrack.train_deep_learning_network_mp(
network,
sample_sizes = sample_sizes,
iteration_numbers = iteration_numbers,
verbose=verbose,
SN_limits=SN_limits,
translation_distance=translation_distance,
)
else:
deeptrack.train_deep_learning_network(
network,
train_generator,
sample_sizes = sample_sizes,
iteration_numbers = iteration_numbers,
verbose=verbose)
freeze_all_layers(network)
conv_list.append(next_node)
if(save_networks):
network.save(model_path+"L1_"+str((i+1)*nbr_nodes_added)+"F.h5")
# Create final output using all the output layers and averaging them
if(len(output_list)>1):
avg_out = layers.average(output_list)
else:
avg_out = output_list[0]
network = models.Model(input_tensor,avg_out)
network.compile(optimizer='rmsprop', loss='mse', metrics=['mse', 'mae'])
print('final network architecture')
network.summary()
if(save_networks):
network.save(model_path+"final_L"+str(1)+"_F.h5")
return network,conv_list,output_list,flattened_list,input_tensor
def _build_model(
cls,
review_shape,
sentiment_shape,
vocabulary_size,
use_pre_activation_batch_normalization=False,
use_post_activation_batch_normalization=True,
):
reviews_input = Input(shape=review_shape)
reviews_output = reviews_input
lstm = cls._get_lstm_class()
def pre_activation_batch_normalization():
return [BatchNormalization()
] if use_pre_activation_batch_normalization else list()
def post_activation_batch_normalization():
return [BatchNormalization()
] if use_post_activation_batch_normalization else list()
for layer in [
lstm(512, return_sequences=True),
lstm(512, return_sequences=True),
]:
reviews_output = layer(reviews_output)
sentiments_input = Input(shape=sentiment_shape)
sentiments_output = sentiments_input
for layer in [Dense(512), Activation(relu)]:
sentiments_output = layer(sentiments_output)
# output = Concatenate()([reviews_output, sentiments_output]) # TODO: replicate then concatenate
output = Add()([reviews_output, sentiments_output])
for layer in (
[lstm(512, return_sequences=True)] +
[lstm(512, return_sequences=True)] +
[lstm(512, return_sequences=True)] +
[TimeDistributed(Dense(512))] +
pre_activation_batch_normalization() + [Activation(relu)] +
post_activation_batch_normalization() +
[TimeDistributed(Dense(512))] +
pre_activation_batch_normalization() + [Activation(relu)] +
post_activation_batch_normalization() +
[TimeDistributed(Dense(vocabulary_size))] + [Activation(softmax)]):
output = layer(output)
model = Model(inputs=[reviews_input, sentiments_input],
outputs=[output])
model.compile(Adam(),
loss=categorical_crossentropy,
metrics=[categorical_accuracy])
model.summary()
plot_directory_path = 'models/'
os.makedirs(plot_directory_path, exist_ok=True)
plot_file_path = os.path.join(plot_directory_path,
'{}.png'.format(cls.__name__))
if 'Darwin' == platform.system():
plot_model(model,
to_file=plot_file_path,
show_shapes=True,
show_layer_names=True)
return model
def model_study(hidden_depth, hidden_layers, batch_size, hidden_activation, model_name, data_name, y_standard_F):
train_x, train_y, test_x, test_y, test_y_label, test_y_mean, test_y_std, train_y_ori, test_y_ori, _, _, train_easy_info, test_easy_info = load_all_numpy_data(data_name)
train_item = train_easy_info[:,0]
train_shop = train_easy_info[:,1]
# train_item_category = train_info[:,2]
test_item = test_easy_info[:,0]
test_shop = test_easy_info[:,1]
# test_item_category = train_info[:,2]
file_name = data_name + "_" + model_name + "_" + str(hidden_depth)+ "depth_" + str(hidden_layers) + "layers_" + hidden_activation + "-activation"
if y_standard_F:
pass
else:
file_name = file_name + "_y_ori"
series_input = Input(shape=(train_x.shape[1], train_x.shape[2]), dtype='float32', name="series_input")
hidden_series = LSTM(hidden_layers, return_sequences=False)(series_input)
item_input = Input(shape=(1,), dtype="float32", name="item_input")
# item_embedding = Embedding(output_dim=item_dim, input_dim=train_item.shape[0], input_length=None)(item_input)
# item_flatten = Flatten()(item_embedding)
shop_input = Input(shape=(1,), dtype="float32", name="shop_input")
# shop_embedding = Embedding(output_dim=shop_dim, input_dim=train_shop.shape[0], input_length=None)(shop_input)
# shop_flatten = Flatten()(shop_embedding)
# item_category_input = Input(shape=(1,), dtype="int32", name="item_category_input")
# item_category_embedding = Embedding(output_dim=item_category_dim, input_dim=train_item_category.shape[0], input_length=None)(item_category_input)
# item_category_flatten = Flatten()(item_category_embedding)
# concatenated_info = concatenate([item_embedding, shop_embedding, item_category_embedding], axis=2)
# concatenated_info = concatenate([item_flatten, shop_flatten, item_category_flatten], axis=-1)
concatenated_info = concatenate([item_input, shop_input], axis=-1)
info_dense = Dense(4)(concatenated_info)
# concatenated_info = Input(shape=(train_info.shape[1],),dtype='float32', name="info_input")
concatenated_all = concatenate([hidden_series, info_dense], axis=-1)
output = Dense(1, activation=hidden_activation, name="model_output")(concatenated_all)
# dense_all = Dense(hidden_layers,)(concatenated_all)
# dense_all = Dropout(0.5)(dense_all)
# output = Dense(1, activation=hidden_activation, name="model_output")(dense_all)
# model = Model([series_input, info_input], output)
model = Model([series_input, item_input, shop_input], output)
model.compile(loss="mse", optimizer="adam")
print("data_name : " + data_name)
print("model_name : ", model_name)
model.summary()
model_dir = '../model/' + file_name
plot_model(model, to_file= model_dir + '.png', show_shapes=True, show_layer_names=True)
mc_cb = ModelCheckpoint(model_dir + ".hdf5", save_best_only=True)
es_cb = EarlyStopping(monitor='val_loss' ,patience=7, verbose=1) # simple_dataではpatience=3だった
if y_standard_F:
history = model.fit({"series_input":train_x, "item_input":train_item, "shop_input":train_shop}, {"model_output":train_y}, batch_size=batch_size, epochs=100, validation_split=0.2, callbacks=[mc_cb,es_cb])
else:
history = model.fit({"series_input":train_x, "item_input":train_item, "shop_input":train_shop}, {"model_output":train_y_ori}, batch_size=batch_size, epochs=100, validation_split=0.2, callbacks=[mc_cb,es_cb])
with open("../result/other/history/" + file_name + ".pickle", mode="wb") as f:
pickle.dump(history.history, f)
test_y_pre = model.predict({"series_input":test_x, "item_input":test_item, "shop_input":test_shop})
if y_standard_F:
test_y_pre_fix = (test_y_pre + test_y_mean) * test_y_std
result_check = pd.DataFrame(np.concatenate([test_y_label, test_y_pre_fix.reshape(-1,1)], axis=1))
else:
result_check = pd.DataFrame(np.concatenate([test_y_label, test_y_pre.reshape(-1,1)], axis=1))
result_check.columns = ["item_id","shop_id","正解値","予測値"]
result_dir = "../result/test/" + file_name + ".csv"
result_check.to_csv(result_dir, encoding='cp932')
if y_standard_F:
rmse = np.sqrt(mean_squared_error(test_y,test_y_pre))
else:
rmse = np.sqrt(mean_squared_error(test_y_ori,test_y_pre))
print('Val RMSE: %.3f' % rmse)
def build_conv_model(sentences_train,
sentences_test,
features_train,
features_test,
labels_train,
labels_test,
refers_train,
refers_test,
abstract_train,
abstract_test,
standardized=True) -> Model:
# if standardized:
# ss = StandardScaler()
# features_train = ss.fit_transform(features_train)
# sentences_train = ss.fit_transform(sentences_train)
# abstract_train = ss.fit_transform(abstract_train)
#
# features_test = ss.fit_transform(features_test)
# sentences_test = ss.fit_transform(sentences_test)
# abstract_test = ss.fit_transform(abstract_test)
# features_train = scale(features_train)
# sentences_train = scale(sentences_train)
# abstract_train = scale(abstract_train)
# features_test = scale(features_test)
# sentences_test = scale(sentences_test)
# abstract_test = scale(abstract_test)
sentences_train = np.expand_dims(sentences_train, axis=2)
features_train = np.expand_dims(features_train, axis=2)
refers_train = np.expand_dims(refers_train, axis=2)
sentences_test = np.expand_dims(sentences_test, axis=2)
features_test = np.expand_dims(features_test, axis=2)
refers_test = np.expand_dims(refers_test, axis=2)
# input1
X_train_1, X_test_1 = sentences_train, sentences_test
# input2
X_train_2, X_test_2 = features_train, features_test
# input3
X_train_3, X_test_3 = refers_train, refers_test
# input4
X_train_4, X_test_4 = abstract_train, abstract_test
y_train = to_categorical(labels_train, num_classes=2)
y_test = to_categorical(labels_test, num_classes=2)
y_test_origin = labels_test
kernel_size = 5
inputs1 = Input(shape=(sentences_train.shape[1], 1))
inputs1_conv = Conv1D(filters=64,
kernel_size=kernel_size,
activation='relu')(inputs1)
# inputs1_pool = GlobalMaxPooling1D()(inputs1_conv)
inputs1_p = MaxPool1D(pool_size=5)(inputs1_conv)
inputs1_pool = Flatten()(inputs1_p)
inputs1_d1 = Dense(64, activation='relu')(inputs1_pool)
inputs1_d1 = Dense(32, activation='relu')(inputs1_d1)
inputs1_d2 = Dense(32, activation='relu')(inputs1_d1)
inputs1_d3 = Dense(16, activation='relu')(inputs1_d2)
inputs2 = Input(shape=(features_train.shape[1], 1))
inputs2_conv = Conv1D(filters=16,
kernel_size=kernel_size,
activation='relu')(inputs2)
# inputs2_pool = GlobalMaxPooling1D()(inputs2_conv)
inputs2_p = MaxPool1D(pool_size=3)(inputs2_conv)
inputs2_pool = Flatten()(inputs2_p)
inputs2_d1 = Dense(64, activation='relu')(inputs2_pool)
inputs2_d2 = Dense(32, activation='relu')(inputs2_d1)
inputs2_d2 = Dense(32, activation='relu')(inputs2_d2)
inputs2_d3 = Dense(16, activation='relu')(inputs2_d2)
# reference
inputs3 = Input(shape=(refers_train.shape[1], 1))
inputs3_conv = Conv1D(filters=16,
kernel_size=kernel_size,
activation='relu')(inputs3)
inputs3_p = MaxPool1D(pool_size=5)(inputs3_conv)
inputs3_pool = Flatten()(inputs3_p)
inputs3_d = Dense(64, activation='relu')(inputs3_pool)
inputs3_d1 = Dense(32, activation='relu')(inputs3_d)
inputs3_d2 = Dense(32, activation='relu')(inputs3_d1)
inputs3_d3 = Dense(16, activation='relu')(inputs3_d2)
# abstract
inputs4 = Input(shape=(abstract_train.shape[1], ))
inputs4_d = Dense(64, activation='relu')(inputs4)
inputs4_d1 = Dense(32, activation='relu')(inputs4_d)
inputs4_d2 = Dense(16, activation='relu')(inputs4_d1)
# conca = Concatenate(axis=1)([inputs1_d3, inputs2_d3])
# conca = Concatenate(axis=1)([inputs1_d3, inputs2_d3, inputs3_d3])
conca = Concatenate(axis=1)(
[inputs1_d3, inputs2_d3, inputs3_d3, inputs4_d2])
output = Dense(2, activation='softmax')(conca)
# model = Model(inputs=[inputs1, inputs2], outputs=[output])
# model = Model(inputs=[inputs1, inputs2, inputs3], outputs=[output])
model = Model(inputs=[inputs1, inputs2, inputs3, inputs4],
outputs=[output])
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['acc'])
# model.fit([X_train_1, X_train_2], y_train, epochs=20,
# validation_data=([X_test_1, X_test_2], y_test))
# model.fit([X_train_1, X_train_2, X_train_3], y_train, epochs=20,
# validation_data=([X_test_1, X_test_2, X_test_3], y_test))
model.fit([X_train_1, X_train_2, X_train_3, X_train_4],
y_train,
epochs=10,
batch_size=512,
validation_data=([X_test_1, X_test_2, X_test_3,
X_test_4], y_test))
# y_pred = [0 if a[0] > a[1] else 1 for a in model.predict([X_test_1, X_test_2])]
# y_pred = [0 if a[0] > a[1] else 1 for a in model.predict([X_test_1, X_test_2, X_test_3])]
y_pred = [
0 if a[0] > a[1] else 1
for a in model.predict([X_test_1, X_test_2, X_test_3, X_test_4])
]
print('accuracy: ', accuracy_score(y_test_origin, y_pred))
print('precision: ', precision_score(y_test_origin, y_pred))
print('recall: ', recall_score(y_test_origin, y_pred))
print('f1: ', f1_score(y_test_origin, y_pred))
print(confusion_matrix(y_test_origin, y_pred))
return model
def get_lstm_siamese(input_shape, feature_vector_size, lstm_nodes, dropout):
def create_base_network(input_shape):
model = Sequential()
model.add(
Bidirectional(LSTM(lstm_nodes,
return_sequences=True,
dropout=dropout,
recurrent_dropout=dropout),
input_shape=input_shape))
model.add(
Bidirectional(
LSTM(lstm_nodes,
return_sequences=False,
dropout=dropout,
recurrent_dropout=dropout)))
# model.add(LSTM(1024, return_sequences=False, dropout=0.2, recurrent_dropout=0.2))
# model.add(LSTM(64, return_sequences=False))
# model.add(Dropout(0.1))
# model.add(LSTM(128, return_sequences=False))
# model.add(Dropout(0.4))
# model.add(LSTM(256))
# model.add(Dropout(0.2))
model.add(Dense(feature_vector_size, activation='relu'))
model.add(Dense(feature_vector_size, activation='relu'))
print(model.summary())
return model
# network definition
base_network = create_base_network(input_shape)
input_a = Input(shape=input_shape)
input_b = Input(shape=input_shape)
# because we re-use the same instance `base_network`,
# the weights of the network
# will be shared across the two branches
processed_a = base_network(input_a)
processed_b = base_network(input_b)
distance = Lambda(euclidean_distance, output_shape=eucl_dist_output_shape)(
[processed_a, processed_b])
model = Model([input_a, input_b], distance)
print(model.summary())
# optimiser = RMSprop()
optimiser = Adam()
model.compile(loss=contrastive_loss,
optimizer=optimiser,
metrics=[accuracy])
# loss_weights = {
# 'main_output': 1.0, 'sequential_1': 0.0}
intermediate_layer_model = Model(input=base_network.layers[0].input,
output=base_network.layers[-1].output)
return model, intermediate_layer_model
whole_image_check_overlapping
from keras.applications import VGG16
from keras.engine import Model
from keras import backend as K, Input
from keras import optimizers
from keras.layers import Conv2D, UpSampling2D, Lambda, Dense, Merge, merge, concatenate, regularizers
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
b_size = 32
input_shape = (32, 32, 1)
# main network
main_input = Input(shape=input_shape, name='image_part_input')
x = Conv2D(64, (3, 3), strides=(2, 2), padding="same", activation="relu",
kernel_regularizer=regularizers.l2(0.01))(main_input)
x = Conv2D(128, (3, 3), padding="same", activation="relu", kernel_regularizer=regularizers.l2(0.01))(x)
x = Conv2D(128, (3, 3), strides=(2, 2), padding="same", activation="relu",
kernel_regularizer=regularizers.l2(0.01))(x)
x = Conv2D(256, (3, 3), padding="same", activation="relu", kernel_regularizer=regularizers.l2(0.01))(x)
x = Conv2D(256, (3, 3), strides=(2, 2), padding="same", activation="relu",
kernel_regularizer=regularizers.l2(0.01))(x)
x = Conv2D(512, (3, 3), padding="same", activation="relu", kernel_regularizer=regularizers.l2(0.01))(x)
x = Conv2D(512, (3, 3), padding="same", activation="relu", kernel_regularizer=regularizers.l2(0.01))(x)
main_output = Conv2D(256, (3, 3), padding="same", activation="relu",
def unet(pretrained_weights=None, input_size=(256, 256, 3), lr=1e-4, **kwargs):
inputs = Input((256, 256, 3))
c1 = Conv2D(filters=16,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(inputs)
c1 = Dropout(0.1)(c1)
c1 = Conv2D(filters=16,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c1)
p1 = MaxPooling2D(pool_size=(2, 2))(c1)
c2 = Conv2D(filters=32,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p1)
c2 = Dropout(0.1)(c2)
c2 = Conv2D(filters=32,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c2)
p2 = MaxPooling2D(pool_size=(2, 2))(c2)
c3 = Conv2D(filters=64,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p2)
c3 = Dropout(0.2)(c3)
c3 = Conv2D(filters=64,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c3)
p3 = MaxPooling2D(pool_size=(2, 2))(c3)
c4 = Conv2D(filters=128,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p3)
c4 = Dropout(0.2)(c4)
c4 = Conv2D(filters=128,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c4)
p4 = MaxPooling2D(pool_size=(2, 2))(c4)
c5 = Conv2D(filters=256,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p4)
c5 = Dropout(0.3)(c5)
c5 = Conv2D(filters=256,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c5)
p5 = MaxPooling2D(pool_size=(2, 2))(c5)
c_b = Conv2D(filters=512,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p5)
c_b = Dropout(0.2)(c_b)
c_b = Conv2D(filters=512,
kernel_size=(3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c_b)
mid_prob_output = GlobalAveragePooling2D()(c_b)
mid_prob_output = Dense(256, activation='tanh')(mid_prob_output)
mid_prob_output = Dense(1, activation='sigmoid')(mid_prob_output)
u_b = Conv2DTranspose(filters=256,
kernel_size=(2, 2),
strides=(2, 2),
padding='same')(c_b)
u_b = Conv2D(filters=256,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(Concatenate()([u_b, c5]))
u_b = Dropout(0.2)(u_b)
u_b = Conv2D(filters=256,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(u_b)
u6 = Conv2DTranspose(filters=128,
kernel_size=(2, 2),
strides=(2, 2),
padding='same')(u_b)
u6 = Conv2D(filters=128,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(Concatenate()([u6, c4]))
u6 = Dropout(0.2)(u6)
u6 = Conv2D(filters=128,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(u6)
u7 = Conv2DTranspose(filters=64,
kernel_size=(2, 2),
strides=(2, 2),
padding='same')(u6)
u7 = Conv2D(filters=64,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(Concatenate()([u7, c3]))
u7 = Dropout(0.2)(u7)
u7 = Conv2D(filters=64,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(u7)
u8 = Conv2DTranspose(filters=32,
kernel_size=(2, 2),
strides=(2, 2),
padding='same')(u7)
u8 = Conv2D(filters=32,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(Concatenate()([u8, c2]))
u8 = Dropout(0.1)(u8)
u8 = Conv2D(filters=32,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(u8)
u9 = Conv2DTranspose(filters=16,
kernel_size=(2, 2),
strides=(2, 2),
padding='same')(u8)
u9 = Conv2D(filters=16,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(Concatenate()([u9, c1]))
u9 = Dropout(0.1)(u9)
u9 = Conv2D(filters=16,
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='elu')(u9)
last = Conv2D(filters=1, kernel_size=(1, 1), activation='sigmoid')(u9)
mask_output = Lambda(lambda x: K.squeeze(x, axis=3))(last)
prob_output = GlobalAveragePooling2D(name='prob')(last)
model = Model(input=inputs,
output=[mask_output, mid_prob_output, prob_output])
model.compile(optimizer=Adam(lr=lr),
loss='binary_crossentropy',
loss_weights=[1, 0.5, 1],
metrics={'prob': get_metrics()})
model.summary()
if (pretrained_weights):
model.load_weights(pretrained_weights)
return model
def main():
encoder_input_data, decoder_input_data, decoder_target_data = get_data()
from utils import convert_chord_indices_to_embeddings
# prepare embeddings
encoder_input_embeddings = np.array([
convert_chord_indices_to_embeddings(chord)
for chord in encoder_input_data
])
# encoder_input_data = to_categorical(encoder_input_data, num_classes=26)
decoder_input_data = to_categorical(decoder_input_data, num_classes=130)
decoder_target_data = to_categorical(decoder_target_data, num_classes=130)
print(encoder_input_data.shape, decoder_input_data.shape,
decoder_target_data.shape)
num_encoder_tokens = 32
num_decoder_tokens = 130
latent_dim = 128
max_length = 600
# Define an input sequence and process it.
encoder_inputs = Input(shape=(None, num_encoder_tokens))
print("Encoder inputs: ", encoder_inputs)
encoder = LSTM(latent_dim, return_sequences=True, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs)
print("Encoder outputs: ", encoder_outputs)
# We discard `encoder_outputs` and only keep the states.
encoder_states = [state_h, state_c]
# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(None, num_decoder_tokens))
print("Decoder inputs: ", decoder_inputs)
# We set up our decoder to return full output sequences,
# and to return internal states as well. We don't use the
# return states in the training model, but we will use them in inference.
decoder = LSTM(latent_dim, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder(decoder_inputs,
initial_state=[state_h, state_c])
print("Decoder outputs: ", decoder_outputs)
# Added attention layer here
attention = dot([decoder_outputs, encoder_outputs], axes=[2, 2])
attention = Activation('softmax', name='attention')(attention)
print('attention', attention)
context = dot([attention, encoder_outputs], axes=[2, 1])
print('context', context)
decoder_combined_context = concatenate([context, decoder_outputs])
print('decoder_combined_context', decoder_combined_context)
# Has another weight + tanh layer as described in equation (5) of the paper
output = TimeDistributed(Dense(
64, activation="tanh"))(decoder_combined_context)
output = TimeDistributed(Dense(130, activation="softmax"))(output)
print('output', output)
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=[output])
encoder_model = Model(encoder_inputs, encoder_states)
decoder_state_input_h = Input(shape=(latent_dim, ))
decoder_state_input_c = Input(shape=(latent_dim, ))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
decoder_outputs, state_h, state_c = decoder(
decoder_inputs, initial_state=decoder_states_inputs)
decoder_states = [state_h, state_c]
attention = dot([decoder_outputs, encoder_outputs], axes=[2, 2])
attention = Activation('softmax', name='attention')(attention)
print('attention', attention)
context = dot([attention, encoder_outputs], axes=[2, 1])
print('context', context)
decoder_combined_context = concatenate([context, decoder_outputs])
print('decoder_combined_context', decoder_combined_context)
# Has another weight + tanh layer as described in equation (5) of the paper
output = TimeDistributed(Dense(
64, activation="tanh"))(decoder_combined_context)
output = TimeDistributed(Dense(130, activation="softmax"))(output)
decoder_model = Model([decoder_inputs] + decoder_states_inputs,
[decoder_outputs] + decoder_states)
# Run training using Xavier's learning rate manual decay mechanism
if not os.path.exists('s2s_attention_augmented.h5'):
def train_by_adaptive_lr():
# manual run epochs, change decay rate for optimizers each epoch
number_of_epochs = 10
prev_validation_loss = 10000
cur_validation_loss = 10000
losses = []
val_losses = []
# run for 1 epoch first
learning_rate = 1.0001
decay_factor = 0.9
optimizer = Adam(clipnorm=1.0, lr=learning_rate)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['categorical_accuracy'])
print(model.summary()) # only print on first epoch
history = model.fit(
x=[encoder_input_data[:100], decoder_input_data[:100]],
y=[decoder_target_data[:100]],
batch_size=32,
epochs=1,
validation_split=0.1)
cur_validation_loss = history.history['val_loss'][0]
print("Loss: {} Validation loss: {}\n".format(
history.history['loss'][0], history.history['val_loss'][0]))
losses.append(history.history['loss'][0])
val_losses.append(history.history['val_loss'][0])
for ep in range(number_of_epochs):
optimizer = Adam(clipnorm=1.0, lr=learning_rate)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['categorical_accuracy'])
history = model.fit(
x=[encoder_input_data[:100], decoder_input_data[:100]],
y=[decoder_target_data[:100]],
batch_size=32,
epochs=1,
validation_split=0.1)
prev_validation_loss = cur_validation_loss
cur_validation_loss = history.history['val_loss'][0]
validation_delta_percentage = (
cur_validation_loss -
prev_validation_loss) / prev_validation_loss
print("validation delta percentage: {}".format(
validation_delta_percentage))
print("Loss: {} Validation loss: {}\n".format(
history.history['loss'][0],
history.history['val_loss'][0]))
if abs(validation_delta_percentage) < 0.01:
learning_rate *= decay_factor
losses.append(history.history['loss'][0])
val_losses.append(history.history['val_loss'][0])
return losses, val_losses
optimizer = Adam(clipnorm=1.0, lr=0.01)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['categorical_accuracy'])
print(model.summary()) # only print on first epoch
def train_each_timestep(encoder_input_data, decoder_input_data,
decoder_target_data):
epochs = 5
length_of_sequence = 100
train_test_split = 0.1
losses = []
val_losses = []
# smaller dataset
encoder_input_data = encoder_input_data[:100]
decoder_input_data = decoder_input_data[:100]
decoder_target_data = decoder_target_data[:100]
num_examples = len(encoder_input_data)
split_point = int(num_examples * (1 - train_test_split))
encoder_input_train, encoder_input_test = encoder_input_data[:split_point], \
encoder_input_data[split_point:]
decoder_input_train, decoder_input_test = decoder_input_data[:split_point], \
decoder_input_data[split_point:]
decoder_target_train, decoder_target_test = decoder_target_data[:split_point], \
decoder_target_data[split_point:]
for ep in range(epochs):
t1 = time.time()
temp_loss = []
temp_val_loss = []
for length in range(1, length_of_sequence):
print("Sequence index: {}".format(length))
history = model.fit(
x=[
encoder_input_train[:, :length, :],
decoder_input_train[:, :length, :]
],
y=[decoder_target_train[:, :length, :]],
batch_size=32,
epochs=1)
temp_loss.append(history.history["loss"][0])
val_loss = model.evaluate(
x=[
encoder_input_test[:, :length, :],
decoder_input_test[:, :length, :]
],
y=[decoder_target_test[:, :length, :]])[0]
temp_val_loss.append(val_loss)
losses.append(sum(temp_loss) / len(temp_loss))
val_losses.append(sum(temp_val_loss) / len(temp_val_loss))
print("Loss: {} Val loss: {}".format(
sum(temp_loss) / len(temp_loss),
sum(temp_val_loss) / len(temp_val_loss)))
print("Time used for 1 epoch: {}".format(time.time() - t1))
return losses, val_losses
def normal_training():
nb_epochs = 250
history = model.fit(x=[encoder_input_data, decoder_input_data],
y=[decoder_target_data],
batch_size=32,
epochs=nb_epochs,
validation_split=0.1)
losses = history.history['val_loss'][0]
val_losses = history.history['val_loss'][0]
return losses, val_losses
losses, val_losses = normal_training() # choose training method here
plt.plot(range(len(losses)), losses, label='train loss')
plt.plot(range(len(val_losses)), val_losses, label='validation loss')
plt.savefig('loss_train_test.png')
# Save model
model.save_weights('s2s_attention.h5')
else:
model.load_weights('s2s_attention_augmented.h5')
ind = 12
input_seq = np.expand_dims(encoder_input_embeddings[ind], axis=0)
print(np.argmax(decoder_target_data[ind], axis=-1))
visualize_attention(model, input_seq, encoder_input_data[ind],
decoder_input_data[ind])
def FCANet(pretrained_weights=None, img_input=(256, 256, 1)):
input = Input(shape=img_input)
conv1_1 = Conv2D(64,
7,
strides=(2, 2),
padding='same',
use_bias=False,
kernel_initializer='he_normal')(input)
conv1_1 = BatchNormalization(axis=3)(conv1_1)
conv1_1 = Activation('relu')(conv1_1)
Attention1_1 = Attention_block(conv1_1, 64)
conv1_2 = MaxPooling2D(pool_size=(2, 2), padding='same')(conv1_1)
conv2_1 = res2net_bottleneck_block(conv1_2, 64, s=4, expansion=4)
conv2_2 = res2net_bottleneck_block(conv2_1, 64, s=4, expansion=4)
conv2_3 = res2net_bottleneck_block(conv2_2, 64, s=4, expansion=4)
Attention2_3 = Attention_block(conv2_3, 256)
conv3_1 = res2net_bottleneck_block(
conv2_3,
128,
s=4,
expansion=4,
)
conv3_2 = res2net_bottleneck_block(conv3_1, 128, s=4, expansion=4)
conv3_3 = res2net_bottleneck_block(conv3_2, 128, s=4, expansion=4)
conv3_4 = res2net_bottleneck_block(conv3_3, 128, s=4, expansion=4)
conv3_4 = MaxPooling2D()(conv3_4)
Attention3_4 = Attention_block(conv3_4, 512)
conv4 = res2net_bottleneck_block(conv3_4,
256,
s=4,
expansion=4,
dilation=(2, 2))
for _ in range(22):
conv4 = res2net_bottleneck_block(conv4,
256,
s=4,
expansion=4,
dilation=(2, 2))
conv5_1 = res2net_bottleneck_block(conv4,
512,
s=4,
expansion=4,
dilation=(4, 4))
conv5_2 = res2net_bottleneck_block(conv5_1,
512,
s=4,
expansion=4,
dilation=(4, 4))
conv5_3 = res2net_bottleneck_block(conv5_2,
512,
s=4,
expansion=4,
dilation=(4, 4))
reduce_conv5_3 = Conv2D(512,
3,
padding='same',
use_bias=False,
kernel_initializer='he_normal')(conv5_3)
reduce_conv5_3 = BatchNormalization(axis=3)(reduce_conv5_3)
reduce_conv5_3 = Activation('relu')(reduce_conv5_3)
feature_sum = Attention_block(reduce_conv5_3, 512)
feature_sum = Dropout(0.5)(feature_sum)
feature_sum = Conv2d_BN(feature_sum, 512, 3)
merge7 = concatenate([Attention3_4, feature_sum], axis=3)
conv7 = Conv2d_BN(merge7, 512, 3)
conv7 = Conv2d_BN(conv7, 512, 3)
up8 = Conv2d_BN(UpSampling2D(size=(2, 2))(conv7), 256, 2)
merge8 = concatenate([Attention2_3, up8], axis=3)
conv8 = Conv2d_BN(merge8, 256, 3)
conv8 = Conv2d_BN(conv8, 256, 3)
up9 = Conv2d_BN(UpSampling2D(size=(2, 2))(conv8), 64, 2)
merge9 = concatenate([Attention1_1, up9], axis=3)
conv9 = Conv2d_BN(merge9, 64, 3)
conv9 = Conv2d_BN(conv9, 64, 3)
up10 = Conv2d_BN(UpSampling2D(size=(2, 2))(conv9), 64, 2)
conv10 = Conv2d_BN(up10, 64, 3)
conv10 = Conv2d_BN(conv10, 64, 3)
conv10 = Conv2D(2,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv10)
conv10 = Conv2D(1, 1, activation='sigmoid')(conv10)
model = Model(inputs=input, outputs=conv10)
metrics = ['acc', 'pw_precesion', 'iou', 'dice']
# model = multi_gpu_model(model, gpus=2)
compile_model(model, 1, metrics=metrics, loss='ce_dice_loss', lr=1e-4)
if (pretrained_weights):
model.load_weights(pretrained_weights)
return model
def MobileUNet(input_shape=None,
alpha=1.0,
alpha_up=1.0,
depth_multiplier=1,
dropout=1e-3,
input_tensor=None,
weight_decay=1e-5):
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
b00 = _conv_block(img_input, 32, alpha, strides=(4, 4), block_id=0)
b01 = _depthwise_conv_block(b00, 64, alpha, depth_multiplier, block_id=1)
b02 = _depthwise_conv_block(b01, 128, alpha, depth_multiplier, block_id=2, strides=(2, 2))
b03 = _depthwise_conv_block(b02, 128, alpha, depth_multiplier, block_id=3)
b04 = _depthwise_conv_block(b03, 256, alpha, depth_multiplier, block_id=4, strides=(2, 2))
b05 = _depthwise_conv_block(b04, 256, alpha, depth_multiplier, block_id=5)
b06 = _depthwise_conv_block(b05, 256, alpha, depth_multiplier, block_id=6, strides=(2, 2))
b07 = _depthwise_conv_block(b06, 256, alpha, depth_multiplier, block_id=7)
b08 = _depthwise_conv_block(b07, 256, alpha, depth_multiplier, block_id=8)
b09 = _depthwise_conv_block(b08, 256, alpha, depth_multiplier, block_id=9)
b10 = _depthwise_conv_block(b09, 256, alpha, depth_multiplier, block_id=10)
b11 = _depthwise_conv_block(b10, 256, alpha, depth_multiplier, block_id=11)
b12 = _depthwise_conv_block(b11, 512, alpha, depth_multiplier, block_id=12, strides=(2, 2))
b13 = _depthwise_conv_block(b12, 512, alpha, depth_multiplier, block_id=13)
# b13 = Dropout(dropout)(b13)
filters = int(256 * alpha)
up1 = concatenate([
Conv2DTranspose(filters, (2, 2), strides=(2, 2), padding='same',
kernel_regularizer=regu.l2(weight_decay),
bias_regularizer=regu.l2(weight_decay))(b13),
b11,
], axis=3)
b14 = _depthwise_conv_block(up1, filters, alpha_up, depth_multiplier, block_id=14)
filters = int(256 * alpha)
up2 = concatenate([
Conv2DTranspose(filters, (2, 2), strides=(2, 2), padding='same',
kernel_regularizer=regu.l2(weight_decay),
bias_regularizer=regu.l2(weight_decay))(b14),
b05,
], axis=3)
b15 = _depthwise_conv_block(up2, filters, alpha_up, depth_multiplier, block_id=15)
filters = int(128 * alpha)
up3 = concatenate([
Conv2DTranspose(filters, (2, 2), strides=(2, 2), padding='same',
kernel_regularizer=regu.l2(weight_decay),
bias_regularizer=regu.l2(weight_decay))(b15),
b03,
], axis=3)
b16 = _depthwise_conv_block(up3, filters, alpha_up, depth_multiplier, block_id=16)
filters = int(64 * alpha)
up4 = concatenate([
Conv2DTranspose(filters, (2, 2), strides=(2,2), padding='same',
kernel_regularizer=regu.l2(weight_decay),
bias_regularizer=regu.l2(weight_decay))(b16),
b01,
], axis=3)
b17 = _depthwise_conv_block(up4, filters, alpha_up, depth_multiplier, block_id=17)
filters = int(32 * alpha)
up5 = concatenate([b17, b00], axis=3)
# b18 = _depthwise_conv_block(up5, filters, alpha_up, depth_multiplier, block_id=18)
b18 = _conv_block(up5, filters, alpha_up, block_id=18)
logits = Conv2D(1, (1, 1), kernel_initializer='he_normal', activation='linear',
kernel_regularizer=regu.l2(weight_decay),
bias_regularizer=regu.l2(weight_decay))(b18)
logits = BilinearUpSampling2D(size=(4, 4),name='logits')(logits)
proba = Activation('sigmoid', name='proba')(logits)
model = Model(img_input, proba)
return model
def SegNet(input_shape=(256, 256, 1),
kernel=3,
pool_size=(2, 2),
output_mode="sigmoid"):
# encoder
inputs = Input(shape=input_shape)
conv_1 = Convolution2D(64, (kernel, kernel), padding="same")(inputs)
conv_1 = BatchNormalization()(conv_1)
conv_1 = Activation("relu")(conv_1)
conv_2 = Convolution2D(64, (kernel, kernel), padding="same")(conv_1)
conv_2 = BatchNormalization()(conv_2)
conv_2 = Activation("relu")(conv_2)
pool_1, mask_1 = MaxPoolingWithArgmax2D(pool_size)(conv_2)
conv_3 = Convolution2D(128, (kernel, kernel), padding="same")(pool_1)
conv_3 = BatchNormalization()(conv_3)
conv_3 = Activation("relu")(conv_3)
conv_4 = Convolution2D(128, (kernel, kernel), padding="same")(conv_3)
conv_4 = BatchNormalization()(conv_4)
conv_4 = Activation("relu")(conv_4)
pool_2, mask_2 = MaxPoolingWithArgmax2D(pool_size)(conv_4)
conv_5 = Convolution2D(256, (kernel, kernel), padding="same")(pool_2)
conv_5 = BatchNormalization()(conv_5)
conv_5 = Activation("relu")(conv_5)
conv_6 = Convolution2D(256, (kernel, kernel), padding="same")(conv_5)
conv_6 = BatchNormalization()(conv_6)
conv_6 = Activation("relu")(conv_6)
conv_7 = Convolution2D(256, (kernel, kernel), padding="same")(conv_6)
conv_7 = BatchNormalization()(conv_7)
conv_7 = Activation("relu")(conv_7)
pool_3, mask_3 = MaxPoolingWithArgmax2D(pool_size)(conv_7)
conv_8 = Convolution2D(512, (kernel, kernel), padding="same")(pool_3)
conv_8 = BatchNormalization()(conv_8)
conv_8 = Activation("relu")(conv_8)
conv_9 = Convolution2D(512, (kernel, kernel), padding="same")(conv_8)
conv_9 = BatchNormalization()(conv_9)
conv_9 = Activation("relu")(conv_9)
conv_10 = Convolution2D(512, (kernel, kernel), padding="same")(conv_9)
conv_10 = BatchNormalization()(conv_10)
conv_10 = Activation("relu")(conv_10)
pool_4, mask_4 = MaxPoolingWithArgmax2D(pool_size)(conv_10)
conv_11 = Convolution2D(512, (kernel, kernel), padding="same")(pool_4)
conv_11 = BatchNormalization()(conv_11)
conv_11 = Activation("relu")(conv_11)
conv_12 = Convolution2D(512, (kernel, kernel), padding="same")(conv_11)
conv_12 = BatchNormalization()(conv_12)
conv_12 = Activation("relu")(conv_12)
conv_13 = Convolution2D(512, (kernel, kernel), padding="same")(conv_12)
conv_13 = BatchNormalization()(conv_13)
conv_13 = Activation("relu")(conv_13)
pool_5, mask_5 = MaxPoolingWithArgmax2D(pool_size)(conv_13)
print("Build enceder done..")
unpool_1 = MaxUnpooling2D(pool_size)([pool_5, mask_5])
conv_14 = Convolution2D(512, (kernel, kernel), padding="same")(unpool_1)
conv_14 = BatchNormalization()(conv_14)
conv_14 = Activation("relu")(conv_14)
conv_15 = Convolution2D(512, (kernel, kernel), padding="same")(conv_14)
conv_15 = BatchNormalization()(conv_15)
conv_15 = Activation("relu")(conv_15)
conv_16 = Convolution2D(512, (kernel, kernel), padding="same")(conv_15)
conv_16 = BatchNormalization()(conv_16)
conv_16 = Activation("relu")(conv_16)
unpool_2 = MaxUnpooling2D(pool_size)([conv_16, mask_4])
conv_17 = Convolution2D(512, (kernel, kernel), padding="same")(unpool_2)
conv_17 = BatchNormalization()(conv_17)
conv_17 = Activation("relu")(conv_17)
conv_18 = Convolution2D(512, (kernel, kernel), padding="same")(conv_17)
conv_18 = BatchNormalization()(conv_18)
conv_18 = Activation("relu")(conv_18)
conv_19 = Convolution2D(256, (kernel, kernel), padding="same")(conv_18)
conv_19 = BatchNormalization()(conv_19)
conv_19 = Activation("relu")(conv_19)
unpool_3 = MaxUnpooling2D(pool_size)([conv_19, mask_3])
conv_20 = Convolution2D(256, (kernel, kernel), padding="same")(unpool_3)
conv_20 = BatchNormalization()(conv_20)
conv_20 = Activation("relu")(conv_20)
conv_21 = Convolution2D(256, (kernel, kernel), padding="same")(conv_20)
conv_21 = BatchNormalization()(conv_21)
conv_21 = Activation("relu")(conv_21)
conv_22 = Convolution2D(128, (kernel, kernel), padding="same")(conv_21)
conv_22 = BatchNormalization()(conv_22)
conv_22 = Activation("relu")(conv_22)
unpool_4 = MaxUnpooling2D(pool_size)([conv_22, mask_2])
conv_23 = Convolution2D(128, (kernel, kernel), padding="same")(unpool_4)
conv_23 = BatchNormalization()(conv_23)
conv_23 = Activation("relu")(conv_23)
conv_24 = Convolution2D(64, (kernel, kernel), padding="same")(conv_23)
conv_24 = BatchNormalization()(conv_24)
conv_24 = Activation("relu")(conv_24)
unpool_5 = MaxUnpooling2D(pool_size)([conv_24, mask_1])
conv_25 = Convolution2D(64, (kernel, kernel), padding="same")(unpool_5)
conv_25 = BatchNormalization()(conv_25)
conv_25 = Activation("relu")(conv_25)
conv_26 = Convolution2D(1, (1, 1), padding="valid")(conv_25)
conv_26 = BatchNormalization()(conv_26)
conv_26 = Reshape(
(input_shape[0] * input_shape[1], 1),
input_shape=(input_shape[0], input_shape[1], 1),
)(conv_26)
outputs = Activation(output_mode)(conv_26)
print("Build decoder done..")
model = Model(inputs=inputs, outputs=outputs)
return model
# criterion='gini',
# max_depth=None,
# max_features='sqrt',
# max_leaf_nodes=None,
# min_samples_leaf=1,
# min_samples_split=2,
# n_estimators=10
# )
# Define the models.
models = []
for second_layer in range(20, 101, 20):
models.append(KerasSequential(
layers=[
Input(shape=features_shape),
Dense(
500,
activation='relu',
kernel_regularizer=regularizers.l2(0.01)
),
Dense(
second_layer,
activation='relu',
kernel_regularizer=regularizers.l2(0.01)
),
Dense(1, activation='sigmoid')
]
))
# Create model evaluator.
def Unet(img_input=(256, 256, 1)):
inputs = Input(img_input)
conv1 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(inputs)
conv1 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool1)
conv2 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool2)
conv3 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool3)
conv4 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv4)
drop4 = Dropout(0.5)(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool4)
conv5 = Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv5)
drop5 = Dropout(0.5)(conv5)
up6 = Conv2D(512,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(UpSampling2D(size=(2,
2))(drop5))
merge6 = concatenate([drop4, up6], axis=3)
conv6 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge6)
conv6 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv6)
up7 = Conv2D(256,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(UpSampling2D(size=(2,
2))(conv6))
merge7 = concatenate([conv3, up7], axis=3)
conv7 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge7)
conv7 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv7)
up8 = Conv2D(128,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(UpSampling2D(size=(2,
2))(conv7))
merge8 = concatenate([conv2, up8], axis=3)
conv8 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge8)
conv8 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv8)
up9 = Conv2D(64,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(UpSampling2D(size=(2,
2))(conv8))
merge9 = concatenate([conv1, up9], axis=3)
conv9 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge9)
conv9 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv9)
conv9 = Conv2D(2,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv9)
conv10 = Conv2D(1, 1, activation='sigmoid')(conv9)
model = Model(input=inputs, output=conv10)
return model
trainig_data_labels.astype("float32")
print(trainig_data.shape)
print(trainig_data_labels.shape)
trains_nums = int(trainig_data.shape[0] * 0.8)
val_nums = int(trainig_data.shape[0] * 0.2)
trains_d = trainig_data[0:trains_nums]
trains_l = trainig_data_labels[0:trains_nums]
print(trains_d.shape)
print(trains_l.shape)
val_d = trainig_data[trains_nums:val_nums + trains_nums]
val_l = trainig_data_labels[trains_nums:val_nums + trains_nums]
# graph
input_tensor = Input(shape=(13, ))
x = layers.Dense(
64, activation='relu',
kernel_regularizer=keras.regularizers.l2(0.001))(input_tensor)
x = layers.Dense(128,
activation='relu',
kernel_regularizer=keras.regularizers.l2(0.001))(x)
x = layers.Dropout(0.5)(x)
x = layers.Dense(64,
activation='relu',
kernel_regularizer=keras.regularizers.l2(0.001))(x)
output_tensor = layers.Dense(14, activation='softmax')(x)
model = Model(input_tensor, output_tensor)
model.summary()
tf_sess.run([
tf.assign(tf_ffn.filter_dense_layer.kernel, weight_filter),
tf.assign(tf_ffn.filter_dense_layer.bias, weight_bias_filter),
tf.assign(tf_ffn.output_dense_layer.kernel, weight_output),
tf.assign(tf_ffn.output_dense_layer.bias, weight_bias_output),
tf.assign(tf_wrapper.layer_norm.scale, scale_init),
tf.assign(tf_wrapper.layer_norm.bias, bias_init),
])
tf_res = tf_sess.run(tf_output, feed_dict={tf_input: my_input})
print("tf output:")
print(tf_res)
k_ffn = KFeedFowardNetwork(hidden_size, filter_size, relu_dropout=0.5)
k_input = Input(shape=(_seq_len, hidden_size))
k_wrapper = KPrePostProcessingWrapper(k_ffn, params)
k_output = k_wrapper(k_input, train=False)
tf_sess.run([
tf.assign(k_ffn.filter_dense_layer.kernel, weight_filter),
tf.assign(k_ffn.filter_dense_layer.bias, weight_bias_filter),
tf.assign(k_ffn.output_dense_layer.kernel, weight_output),
tf.assign(k_ffn.output_dense_layer.bias, weight_bias_output),
tf.assign(k_wrapper.layer_norm.scale, scale_init),
tf.assign(k_wrapper.layer_norm.bias, bias_init),
])
k_run = K.function([k_input], [k_output])
k_res = k_run([my_input])[0]
def CreateModel(self):
'''
定义CNN/LSTM/CTC模型，使用函数式模型
输入层：200维的特征值序列，一条语音数据的最大长度设为1600（大约16s）
隐藏层：卷积池化层，卷积核大小为3x3，池化窗口大小为2
隐藏层：全连接层
输出层：全连接层，神经元数量为self.MS_OUTPUT_SIZE，使用softmax作为激活函数，
CTC层：使用CTC的loss作为损失函数，实现连接性时序多输出
'''
'''
input_data = Input(name='the_input', shape=(self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH, 1))
layer_h1 = Conv2D(32, (3, 3), use_bias=False, activation='relu', padding='same',
kernel_initializer='he_normal')(input_data) # 卷积层
# layer_h1 = Dropout(0.05)(layer_h1)
layer_h2 = Conv2D(32, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(
layer_h1) # 卷积层
layer_h3 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h2) # 池化层
# layer_h3 = Dropout(0.05)(layer_h3) # 随机中断部分神经网络连接，防止过拟合
layer_h4 = Conv2D(64, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(
layer_h3) # 卷积层
# layer_h4 = Dropout(0.1)(layer_h4)
layer_h5 = Conv2D(64, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(
layer_h4) # 卷积层
layer_h6 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h5) # 池化层
# layer_h6 = Dropout(0.1)(layer_h6)
layer_h7 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h6) # 卷积层
# layer_h7 = Dropout(0.15)(layer_h7)
layer_h8 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h7) # 卷积层
layer_h9 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h8) # 池化层
# layer_h9 = Dropout(0.15)(layer_h9)
layer_h10 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h9) # 卷积层
# layer_h10 = Dropout(0.2)(layer_h10)
layer_h11 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h10) # 卷积层
layer_h12 = MaxPooling2D(pool_size=1, strides=None, padding="valid")(layer_h11) # 池化层
# layer_h12 = Dropout(0.2)(layer_h12)
layer_h13 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h12) # 卷积层
# layer_h13 = Dropout(0.3)(layer_h13)
layer_h14 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h13) # 卷积层
layer_h15 = MaxPooling2D(pool_size=1, strides=None, padding="valid")(layer_h14) # 池化层
# test=Model(inputs = input_data, outputs = layer_h12)
# test.summary()
# print(layer_h15.shape)
layer_h16 = Reshape((212, 1280))(layer_h15) # Reshape层
# layer_h16 = Dropout(0.3)(layer_h16) # 随机中断部分神经网络连接，防止过拟合
layer_h17 = Dense(128, activation="relu", use_bias=True, kernel_initializer='he_normal')(layer_h16) # 全连接层
inner = layer_h17
# layer_h5 = LSTM(256, activation='relu', use_bias=True, return_sequences=True)(layer_h4) # LSTM层
rnn_size = 128
gru_1 = GRU(rnn_size, return_sequences=True, kernel_initializer='he_normal', name='gru1')(inner)
gru_1b = GRU(rnn_size, return_sequences=True, go_backwards=True, kernel_initializer='he_normal', name='gru1_b')(
inner)
gru1_merged = add([gru_1, gru_1b])
gru_2 = GRU(rnn_size, return_sequences=True, kernel_initializer='he_normal', name='gru2')(gru1_merged)
gru_2b = GRU(rnn_size, return_sequences=True, go_backwards=True, kernel_initializer='he_normal', name='gru2_b')(
gru1_merged)
gru2 = concatenate([gru_2, gru_2b])
layer_h20 = gru2
# layer_h20 = Dropout(0.4)(gru2)
layer_h21 = Dense(128, activation="relu", use_bias=True, kernel_initializer='he_normal')(layer_h20) # 全连接层
# layer_h17 = Dropout(0.3)(layer_h17)
layer_h22 = Dense(self.MS_OUTPUT_SIZE, use_bias=True, kernel_initializer='he_normal')(layer_h21) # 全连接层
y_pred = Activation('softmax', name='Activation0')(layer_h22)
model_data = Model(inputs=input_data, outputs=y_pred)
# model_data.summary()
labels = Input(name='the_labels', shape=[self.label_max_string_length], dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
# Keras doesn't currently support loss funcs with extra parameters
# so CTC loss is implemented in a lambda layer
# layer_out = Lambda(ctc_lambda_func,output_shape=(self.MS_OUTPUT_SIZE, ), name='ctc')([y_pred, labels, input_length, label_length])#(layer_h6) # CTC
loss_out = Lambda(self.ctc_lambed_func, output_shape=(1,), name='ctc')([y_pred, labels, input_length, label_length])
model = Model(inputs=[input_data, labels, input_length, label_length], outputs=loss_out)
model.summary()
# clipnorm seems to speeds up convergence
# sgd = SGD(lr=0.0001, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
# ada_d = Adadelta(lr = 0.01, rho = 0.95, epsilon = 1e-06)
opt = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, decay=0.0, epsilon=10e-8)
# model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd)
model.build((self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH, 1))
model = ParallelModel(model, NUM_GPU)
model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=opt)
# captures output of softmax so we can decode the output during visualization
test_func = K.function([input_data], [y_pred])
# print('[*提示] 创建模型成功，模型编译成功')
print('[*Info] Create Model Successful, Compiles Model Successful. ')
return model, model_data
'''
input_data = Input(name='the_input', shape=(self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH, 1))
layer_h1 = Conv2D(32, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(
input_data) # 卷积层
layer_h1 = Dropout(0.1)(layer_h1)
layer_h2 = Conv2D(32, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(
layer_h1) # 卷积层
layer_h3 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h2) # 池化层
# layer_h3 = Dropout(0.2)(layer_h2) # 随机中断部分神经网络连接，防止过拟合
layer_h3 = Dropout(0.1)(layer_h3)
layer_h4 = Conv2D(64, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(
layer_h3) # 卷积层
layer_h4 = Dropout(0.2)(layer_h4)
layer_h5 = Conv2D(64, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(
layer_h4) # 卷积层
layer_h6 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h5) # 池化层
layer_h6 = Dropout(0.2)(layer_h6)
layer_h7 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h6) # 卷积层
layer_h7 = Dropout(0.3)(layer_h7)
layer_h8 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h7) # 卷积层
layer_h9 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h8) # 池化层
layer_h9 = Dropout(0.3)(layer_h9)
layer_h10 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h9) # 卷积层
layer_h10 = Dropout(0.4)(layer_h10)
layer_h11 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same',
kernel_initializer='he_normal')(layer_h10) # 卷积层
layer_h12 = MaxPooling2D(pool_size=1, strides=None, padding="valid")(layer_h11) # 池化层
# test=Model(inputs = input_data, outputs = layer_h12)
## test.summary()
layer_h10 = Reshape((212, 1280))(layer_h12) # Reshape层
# layer_h5 = LSTM(256, activation='relu', use_bias=True, return_sequences=True)(layer_h4) # LSTM层
# layer_h6 = Dropout(0.2)(layer_h5) # 随机中断部分神经网络连接，防止过拟合
layer_h10 = Dropout(0.4)(layer_h10)
layer_h11 = Dense(128, activation="relu", use_bias=True, kernel_initializer='he_normal')(layer_h10) # 全连接层
layer_h11 = Dropout(0.5)(layer_h11)
layer_h12 = Dense(self.MS_OUTPUT_SIZE, use_bias=True, kernel_initializer='he_normal')(layer_h11) # 全连接层
y_pred = Activation('softmax', name='Activation0')(layer_h12)
model_data = Model(inputs=input_data, outputs=y_pred)
# model_data.summary()
labels = Input(name='the_labels', shape=[self.label_max_string_length], dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
# Keras doesn't currently support loss funcs with extra parameters
# so CTC loss is implemented in a lambda layer
# layer_out = Lambda(ctc_lambda_func,output_shape=(self.MS_OUTPUT_SIZE, ), name='ctc')([y_pred, labels, input_length, label_length])#(layer_h6) # CTC
loss_out = Lambda(self.ctc_lambda_func, output_shape=(1,), name='ctc')(
[y_pred, labels, input_length, label_length])
model = Model(inputs=[input_data, labels, input_length, label_length], outputs=loss_out)
# model.summary()
# clipnorm seems to speeds up convergence
# sgd = SGD(lr=0.0001, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
ada_d = Adadelta(lr=0.01, rho=0.95, epsilon=1e-06)
# model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd)
model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=ada_d)
# captures output of softmax so we can decode the output during visualization
test_func = K.function([input_data], [y_pred])
print('[*提示] 创建模型成功，模型编译成功')
return model, model_data
def build(size, seq_len , learning_rate ,
optimizer_class ,\
initial_weights ,\
cnn_class ,\
pre_weights , \
lstm_conf , \
cnn_train_type, classes = 1, dropout = 0.0):
input_layer = Input(shape=(seq_len, size, size, 3))
if cnn_train_type != 'train':
if cnn_class.__name__ == "ResNet50":
cnn = cnn_class(weights=pre_weights,
include_top=False,
input_shape=(size, size, 3))
else:
cnn = cnn_class(weights=pre_weights, include_top=False)
else:
cnn = cnn_class(include_top=False)
#control Train_able of CNNN
if (cnn_train_type == 'static'):
for layer in cnn.layers:
layer.trainable = False
if (cnn_train_type == 'retrain'):
for layer in cnn.layers:
layer.trainable = True
cnn = TimeDistributed(cnn)(input_layer)
#the resnet output shape is 1,1,20148 and need to be reshape for the ConvLSTM filters
# if cnn_class.__name__ == "ResNet50":
# cnn = Reshape((seq_len,4, 4, 128), input_shape=(seq_len,1, 1, 2048))(cnn)
lstm = lstm_conf[0](**lstm_conf[1])(cnn)
lstm = MaxPooling2D(pool_size=(2, 2))(lstm)
flat = Flatten()(lstm)
flat = BatchNormalization()(flat)
flat = Dropout(dropout)(flat)
linear = Dense(1000)(flat)
relu = Activation('relu')(linear)
linear = Dense(256)(relu)
linear = Dropout(dropout)(linear)
relu = Activation('relu')(linear)
linear = Dense(10)(relu)
linear = Dropout(dropout)(linear)
relu = Activation('relu')(linear)
activation = 'sigmoid'
loss_func = 'binary_crossentropy'
if classes > 1:
activation = 'softmax'
loss_func = 'categorical_crossentropy'
predictions = Dense(classes, activation=activation)(relu)
model = Model(inputs=input_layer, outputs=predictions)
optimizer = optimizer_class[0](lr=learning_rate, **optimizer_class[1])
model.compile(optimizer=optimizer, loss=loss_func, metrics=['acc'])
print(model.summary())
return model
from keras import layers from keras import Input from keras.models import Model # Instantiates a single LSTM layer, once lstm = layers.LSTM(32) # Building the left branch of the model: inputs are variable-length # sequences of vectors of size 128. left_input = Input(shape=(None, 128)) left_output = lstm(left_input) # Building the right branch of the model: when you call an existing layer # instance, you reuse its weights. right_input = Input(shape=(None, 128)) right_output = lstm(right_input) # Builds the classifier on top merged = layers.concatenate([left_output, right_output], axis=-1) predictions = layers.Dense(1, activation='sigmoid')(merged) # Instantiating and training the model: when you # train such a model, the weights of the LSTM layer # are updated based on both inputs. model = Model([left_input, right_input], predictions) model.fit([left_data, right_data], targets)