def LoadModel():
global D
D=None
D=load_model('./tdoa1.h5')
if D==None:
i=Input(shape=(M,4))
print("1=====",i)
a=Flatten()(i)
a=Dense(200,activation='relu')(a)
a=Dense(160,activation='relu')(a)
a=Dense(120,activation='relu')(a)
a=Dense(80,activation='relu')(a)
a=Dense(80,activation='relu')(a)
a=Dense(80,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(60,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(40,activation='relu')(a)
a=Dense(20,activation='relu')(a)
a=Dense(10,activation='relu')(a)
o=Dense(2,activation='tanh')(a)
D=Model(inputs=i,outputs=o)
D.compile(loss='mse',optimizer='adam',metrics=['accuracy'])
def __init__(self,
session,
feature_layers=None,
feature_weights=None,
gram_weights=None):
K.set_session(session)
self.base_model = VGG19(include_top=False, weights='imagenet')
if feature_layers is None:
feature_layers = [
"input_1", "block1_conv2", "block2_conv2", "block3_conv2",
"block4_conv2", "block5_conv2"
]
self.layer_names = [l.val_set_name for l in self.base_model.layers]
for k in feature_layers:
if not k in self.layer_names:
raise KeyError("Invalid layer {}. Available layers: {}".format(
k, self.layer_names))
features = [
self.base_model.get_layer(k).output for k in feature_layers
]
self.model = Model(inputs=self.base_model.input, outputs=features)
if feature_weights is None:
feature_weights = len(feature_layers) * [1.0]
if gram_weights is None:
gram_weights = len(feature_layers) * [0.1]
self.feature_weights = feature_weights
self.gram_weights = gram_weights
assert len(self.feature_weights) == len(features)
self.use_gram = np.max(self.gram_weights) > 0.0
self.variables = self.base_model.weights
def __init__(self, nn_type="resnet50", restore = None, session=None, use_imagenet_pretrain=False, use_softmax=True):
self.image_size = 224
self.num_channels = 3
self.num_labels = 8
input_layer = Input(shape=(self.image_size, self.image_size, self.num_channels))
weights = "imagenet" if use_imagenet_pretrain else None
if nn_type == "resnet50":
base_model = ResNet50(weights=weights, input_tensor=input_layer)
elif nn_type == "vgg16":
base_model = VGG16(weights=weights, input_tensor=input_layer)
# base_model = VGG16(weights=None, input_tensor=input_layer)
x = base_model.output
x = LeakyReLU()(x)
x = Dense(1024)(x)
x = Dropout(0.2)(x)
x = LeakyReLU()(x)
x = Dropout(0.3)(x)
x = Dense(8)(x)
if use_softmax:
x = Activation("softmax")(x)
model = Model(inputs=base_model.input, outputs=x)
# for layer in base_model.layers:
# layer.trainable = False
if restore:
print("Load: {}".format(restore))
model.load_weights(restore)
self.model = model
def __init__(self):
self.growth_rate = 32
in_ = Input(shape=(224, 224, 3))
self.num_dense_block = 4
# Layer 1:
x = Conv2D(64, (7, 7), (2, 2), padding="SAME")(in_)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = MaxPool2D((3, 3), (2, 2), padding="VALID")(x)
filter = 64
num_node_each_layer = [6, 12, 24, 16]
for i in range(self.num_dense_block):
x, filter = dense_block(x,
num_node_each_layer[i],
filter,
growth_rate=32)
if i != self.num_dense_block - 1:
x = transition_block(x, filter, 1.0)
filter = filter * 1.0
# Output from loop statement, x still in conv layer
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = GlobalAveragePooling2D()(x)
x = Dense(1000, activation="softmax")(x)
model = Model(inputs=in_, outputs=x)
model.summary()
self.model = model
def on_epoch_end(self, epoch, logs=None):
self.losses.append(logs.get('loss'))
self.num_epochs = epoch
self.losses.append(logs.get('loss'))
if epoch % 6 != 0: return
# return
intermediate_layer_model = Model(
inputs=self.model.input,
outputs=self.model.get_layer('abundances').output)
abundances = intermediate_layer_model.predict(self.input)
endmembers = self.model.layers[len(self.model.layers) -
1].get_weights()[0]
plotHist(self.losses, 33)
if self.plotGT:
dict = order_endmembers(endmembers, self.endmembersGT)
# if self.is_GT_for_A:
# plotAbundances(self.num_endmembers, self.size_data, abundances, self.abundancesGT, dict, self.use_ASC)
# else:
# plotAbundances(self.num_endmembers, self.size_data, abundances, None, None, self.use_ASC, is_GT=False)
plotEndmembersAndGT(endmembers, self.endmembersGT, dict)
# plotAbundancesSimple(self.num_endmembers, self.size_data, abundances, dict, use_ASC=1, figure_nr=10)
else:
# plotAbundances(self.num_endmembers, self.size_data, abundances, None, None, self.use_ASC)
plotEndmembers(self.num_endmembers, endmembers)
print(K.eval(self.model._collected_trainable_weights[-3]))
return
def CreateSimpleImageModel_512(): dataIn = Input(shape=(3,)) layer = Dense(4 * 4, activation='tanh')(dataIn) layer = Dense(512 * 512 * 4, activation='linear')(layer) layer = Reshape((1, 512, 512, 4))(layer) modelOut = layer model = Model(inputs=[dataIn], outputs=[modelOut]) adam = Adam(lr=0.005, decay=0.0001) model.compile(loss='mean_squared_error', optimizer=adam, metrics=['accuracy']) return model
def CreateSimpleImageModel_512():
dataIn = Input(shape=(3, ))
layer = Dense(4 * 4, activation='tanh')(dataIn)
layer = Dense(512 * 512 * 4, activation='linear')(layer)
layer = Reshape((1, 512, 512, 4))(layer)
modelOut = layer
model = Model(inputs=[dataIn], outputs=[modelOut])
adam = Adam(lr=0.005, decay=0.0001)
model.compile(loss='mean_squared_error',
optimizer=adam,
metrics=['accuracy'])
return model
def ResNet34V2_model():
inpt = Input(shape=(224, 224, 3))
x = ZeroPadding2D((3, 3))(inpt)
x = _BN_ReLU_Conv2d(x,
nb_filter=64,
kernel_size=(7, 7),
strides=(2, 2),
padding='valid')
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')(x)
# (56,56,64)
x = Conv_Block(x, nb_filter=64, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=64, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=64, kernel_size=(3, 3))
# (28,28,128)
x = Conv_Block(x,
nb_filter=128,
kernel_size=(3, 3),
strides=(2, 2),
with_conv_shortcut=True)
x = Conv_Block(x, nb_filter=128, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=128, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=128, kernel_size=(3, 3))
# (14,14,256)
x = Conv_Block(x,
nb_filter=256,
kernel_size=(3, 3),
strides=(2, 2),
with_conv_shortcut=True)
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=256, kernel_size=(3, 3))
# (7,7,512)
x = Conv_Block(x,
nb_filter=512,
kernel_size=(3, 3),
strides=(2, 2),
with_conv_shortcut=True)
x = Conv_Block(x, nb_filter=512, kernel_size=(3, 3))
x = Conv_Block(x, nb_filter=512, kernel_size=(3, 3))
x = AveragePooling2D(pool_size=(7, 7))(x)
x = Flatten()(x)
# x = Dense(1000,activation='softmax')(x)
x = [
Dense(n_class, activation='softmax', name='P%d' % (i + 1))(x)
for i in range(7)
]
model = Model(inputs=inpt, outputs=x)
model.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
return model
def _build_conv_model(self):
input_layer = Input(tensor=self.obsPH)
with tf.variable_scope(
'DQN_std'): # std graph must be constructed before tgt!
model_layers = networks.build_conv(input_layer)
DQN_std = Model(inputs=input_layer, outputs=model_layers)
with tf.variable_scope('DQN_tgt'):
model_layers = networks.build_conv(input_layer)
DQN_tgt = Model(inputs=input_layer, outputs=model_layers)
return DQN_std, DQN_tgt
def load_vgg16(fc):
""" Creates VGG16 model.
:param fc: fully connected layer as output layer if true
:type fc: bool
:return: instance of VGG16 keras model
:rtype: keras.Model
"""
base_model = VGG16(include_top=True, weights='imagenet', input_shape=(224, 224, 3))
if fc:
model = Model(inputs=base_model.input, outputs=base_model.get_layer(name='fc2').output)
else:
model = Model(inputs=base_model.input, outputs=base_model.get_layer(name='block5_pool').output)
model.trainable = False
return model
def __init__(
self,
vgg,
feature_weights=[1.0] * 6,
use_gram=False,
gram_weights=[0.1] * 6,
eager=False,
session=None,
):
self.vgg = vgg
self.feature_weights = feature_weights
self.gram_weights = gram_weights
self.use_gram = use_gram
self.target_layers = [
# "input_1",
"block1_conv2",
"block2_conv2",
"block3_conv2",
"block4_conv2",
"block5_conv2",
]
if eager:
pass
else:
K.set_session(session)
self.layer_names = [layer.name for layer in self.vgg.layers]
for k in self.target_layers:
if k not in self.layer_names:
raise KeyError("Invalid layer {}. Available layers: {}".format(
k, self.layer_names))
features = [self.vgg.get_layer(k).output for k in self.target_layers]
self.model = Model(inputs=self.vgg.input, outputs=features)
self.variables = self.vgg.weights
def build_discriminator(self):
model = Sequential()
model.add(
Conv2D(32,
kernel_size=3,
strides=2,
input_shape=self.img_shape,
padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(256, kernel_size=3, strides=1, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
# model.summary()
img = Input(shape=self.img_shape)
validity = model(img)
return Model(img, validity)
def build_generator_dense():
model = Sequential()
# Add arbitrary layers
first = True
for size in generator_layers.split(":"):
size = int(size)
if first:
model.add(Dense(size, input_shape=noise_shape, activation=generator_activation))
else:
model.add(Dense(size, activation=generator_activation))
model.add(Dropout(dropout_value))
first = False
# Add the final layer
model.add(Dense( np.prod(url_shape) , activation="tanh"))
model.add(Dropout(dropout_value))
model.add(Reshape(url_shape))
model.summary()
# Build the model
noise = Input(shape=noise_shape)
gen = model(noise)
return Model(noise, gen)
def __init__(
self,
session,
feature_layers=None,
feature_weights=None,
gram_weights=None,
default_gram=0.1,
original_scale=False,
eager=False,
):
if eager:
pass
else:
K.set_session(session)
self.base_model = VGG19(include_top=False, weights="imagenet")
if feature_layers is None:
feature_layers = [
"input_1",
"block1_conv2",
"block2_conv2",
"block3_conv2",
"block4_conv2",
"block5_conv2",
]
self.layer_names = [l.name for l in self.base_model.layers]
for k in feature_layers:
if not k in self.layer_names:
raise KeyError("Invalid layer {}. Available layers: {}".format(
k, self.layer_names))
self.feature_layers = feature_layers
features = [
self.base_model.get_layer(k).output for k in feature_layers
]
self.model = Model(inputs=self.base_model.input, outputs=features)
if feature_weights is None:
feature_weights = len(feature_layers) * [1.0]
if gram_weights is None:
gram_weights = len(feature_layers) * [default_gram]
elif isinstance(gram_weights, (int, float)):
gram_weights = len(feature_layers) * [gram_weights]
self.feature_weights = feature_weights
self.gram_weights = gram_weights
assert len(self.feature_weights) == len(features)
self.use_gram = np.max(self.gram_weights) > 0.0
self.original_scale = original_scale
self.variables = self.base_model.weights
def inception(self, img_size=(299, 299), img_channels=3, output_size=1000):
input_shape = Input(shape=(*img_size, img_channels))
x = inception.inception_v3(input_shape,
num_classes=output_size,
aux_logits=True,
transform_input=False)
model = Model(inputs=input_shape, outputs=x)
self.classifier = model
def on_epoch_end(self, epoch, logs=None):
self.losses.append(logs.get('loss'))
self.num_epochs = epoch
self.losses.append(logs.get('loss'))
if epoch % self.plot_every_n != 0: return
return
if self.plotS:
intermediate_layer_model = Model(
inputs=self.model.input,
outputs=self.model.get_layer('abundances').output)
abundances = intermediate_layer_model.predict(self.input)
if self.size is None:
self.size = (int(np.sqrt(abundances.shape[0])),
int(np.sqrt(abundances.shape[0])))
endmembers = self.model.layers[len(self.model.layers) -
1].get_weights()[0]
# plotHist(self.losses, 33)
self.plotGT = True
if self.plotGT:
dict = order_endmembers(endmembers, self.endmembersGT)
# if self.is_GT_for_A:
# plotAbundances(self.num_endmembers, self.size_data, abundances, self.abundancesGT, dict, self.use_ASC)
# else:
# plotAbundances(self.num_endmembers, self.size_data, abundances, None, None, self.use_ASC, is_GT=False)
plotEndmembersAndGT(self.endmembersGT, endmembers, dict)
if self.plotS:
plotAbundancesSimple(self.num_endmembers,
(self.size[0], self.size[1]),
abundances,
dict,
use_ASC=1,
figure_nr=10)
else:
# plotAbundances(self.num_endmembers, self.size_data, abundances, None, None, self.use_ASC)
plotEndmembers(self.num_endmembers, endmembers)
plotAbundancesSimple(self.num_endmembers,
(self.size[0], self.size[1]),
abundances,
dict=None,
use_ASC=1,
figure_nr=10)
return
def load_vgg16():
'''Method to load the VGG16 model'''
base_model = VGG16(include_top=True,
weights='imagenet',
input_shape=(224, 224, 3))
model = Model(inputs=base_model.input,
outputs=base_model.get_layer(name="fc2").output)
return model
def __init__(self, config):
self.name = config.model_type + '_' + config.model_version
self.data_set = config.data_set
self.batch_size = config.batch_size
self.num_actions = config.num_actions
self.seq_len = config.pick_num if config.pick_num > 0 else (
config.crop_len if config.crop_len > 0 else None)
self.njoints = config.njoints
self.body_members = config.body_members
self.dropout = config.dropout
real_seq = Input(
batch_shape=(self.batch_size, self.njoints, self.seq_len, 3),
name='real_seq', dtype='float32')
pred_action = self.classifier(real_seq)
self.model = Model(real_seq, pred_action, name=self.name)
self.model.compile(Adam(lr=config.learning_rate), 'sparse_categorical_crossentropy', ['accuracy'])
def feature_extraction(sz_input, sz_input2):
i = Input(shape=(sz_input, sz_input2, 1))
firstconv = convbn(i, 4, 3, 1, 1)
firstconv = Activation('relu')(firstconv)
firstconv = convbn(firstconv, 4, 3, 1, 1)
firstconv = Activation('relu')(firstconv)
layer1 = _make_layer(firstconv, 4, 2, 1, 1) # (?, 32, 32, 4)
layer2 = _make_layer(layer1, 8, 8, 1, 1) # (?, 32, 32, 8)
layer3 = _make_layer(layer2, 16, 2, 1, 1) # (?, 32, 32, 16)
layer4 = _make_layer(layer3, 16, 2, 1, 2) # (?, 32, 32, 16)
layer4_size = (layer4.get_shape().as_list()[1],
layer4.get_shape().as_list()[2])
branch1 = AveragePooling2D((2, 2), (2, 2),
'same',
data_format='channels_last')(layer4)
branch1 = convbn(branch1, 4, 1, 1, 1)
branch1 = Activation('relu')(branch1)
branch1 = UpSampling2DBilinear(layer4_size)(branch1)
branch2 = AveragePooling2D((4, 4), (4, 4),
'same',
data_format='channels_last')(layer4)
branch2 = convbn(branch2, 4, 1, 1, 1)
branch2 = Activation('relu')(branch2)
branch2 = UpSampling2DBilinear(layer4_size)(branch2)
branch3 = AveragePooling2D((8, 8), (8, 8),
'same',
data_format='channels_last')(layer4)
branch3 = convbn(branch3, 4, 1, 1, 1)
branch3 = Activation('relu')(branch3)
branch3 = UpSampling2DBilinear(layer4_size)(branch3)
branch4 = AveragePooling2D((16, 16), (16, 16),
'same',
data_format='channels_last')(layer4)
branch4 = convbn(branch4, 4, 1, 1, 1)
branch4 = Activation('relu')(branch4)
branch4 = UpSampling2DBilinear(layer4_size)(branch4)
output_feature = concatenate(
[layer2, layer4, branch4, branch3, branch2, branch1], )
lastconv = convbn(output_feature, 16, 3, 1, 1)
lastconv = Activation('relu')(lastconv)
lastconv = Conv2D(4,
1, (1, 1),
'same',
data_format='channels_last',
use_bias=False)(lastconv)
print(lastconv.get_shape())
model = Model(inputs=[i], outputs=[lastconv])
return model
def build_models(seq_len=12, num_classes=4, load_weights=False):
# DST-Net: ResNet50
resnet = ResNet50(weights='imagenet', include_top=False)
for layer in resnet.layers:
layer.trainable = False
resnet.load_weights('model/resnet.h5')
# DST-Net: Conv3D + Bi-LSTM
inputs = Input(shape=(seq_len, 7, 7, 2048))
# conv1_1, conv3D and flatten
conv1_1 = TimeDistributed(Conv2D(128, 1, 1, activation='relu'))(inputs)
conv3d = Conv3D(64, 3, 1, 'SAME', activation='relu')(conv1_1)
flatten = Reshape(target_shape=(seq_len, 7 * 7 * 64))(conv3d)
# 2 Layers Bi-LSTM
bilstm_1 = Bidirectional(LSTM(128, dropout=0.5,
return_sequences=True))(flatten)
bilstm_2 = Bidirectional(LSTM(128, dropout=0.5,
return_sequences=False))(bilstm_1)
outputs = Dense(num_classes, activation='softmax')(bilstm_2)
dstnet = Model(inputs=inputs, outputs=outputs)
dstnet.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=0.001, momentum=0.9, nesterov=True))
# load models
if load_weights:
dstnet.load_weights('model/dstnet.h5')
return resnet, dstnet
def get_model(filters_count, conv_depth, learning_rate, input_shape=(512, 512, 9)):
# input shape=512x512x9 ?灰度化的9个图？
input_90d = Input(shape=input_shape, name='input_90d')
input_0d = Input(shape=input_shape, name='input_0d')
input_45d = Input(shape=input_shape, name='input_45d')
input_m45d = Input(shape=input_shape, name='input_m45d')
# 4 Stream layer
stream_ver = layersP1_multistream(input_shape, int(filters_count))(input_90d)
stream_hor = layersP1_multistream(input_shape, int(filters_count))(input_0d)
stream_45d = layersP1_multistream(input_shape, int(filters_count))(input_45d)
stream_m45d = layersP1_multistream(input_shape, int(filters_count))(input_m45d)
# merge streams
merged = concatenate([stream_ver,stream_hor, stream_45d, stream_m45d], name='merged')
# layers part2: conv-relu-bn-conv-relu
merged = layersP2_merged(input_shape=(input_shape[0], input_shape[1], int(filters_count) * 4),
filters_count=int(filters_count) * 4,
conv_depth=conv_depth)(merged)
# output
output = layersP3_output(input_shape=(input_shape[0], input_shape[1], int(filters_count) * 4),
filters_count=int(filters_count) * 4)(merged)
mymodel = Model(inputs=[input_90d,input_0d, input_45d, input_m45d], outputs=[output])
optimizer = RMSprop(lr=learning_rate)
mymodel.compile(optimizer=optimizer, loss='mae')
mymodel.summary()
return mymodel
def define_epinet(sz_input,sz_input2,view_n,conv_depth,filt_num,learning_rate):
''' 4-Input : Conv - Relu - Conv - BN - Relu '''
input_stack_90d = Input(shape=(sz_input,sz_input2,len(view_n)), name='input_stack_90d')
input_stack_0d= Input(shape=(sz_input,sz_input2,len(view_n)), name='input_stack_0d')
input_stack_45d= Input(shape=(sz_input,sz_input2,len(view_n)), name='input_stack_45d')
input_stack_M45d= Input(shape=(sz_input,sz_input2,len(view_n)), name='input_stack_M45d')
''' 4-Stream layer : Conv - Relu - Conv - BN - Relu '''
mid_90d=layer1_multistream(sz_input,sz_input2,len(view_n),int(filt_num))(input_stack_90d)
mid_0d=layer1_multistream(sz_input,sz_input2,len(view_n),int(filt_num))(input_stack_0d)
mid_45d=layer1_multistream(sz_input,sz_input2,len(view_n),int(filt_num))(input_stack_45d)
mid_M45d=layer1_multistream(sz_input,sz_input2,len(view_n),int(filt_num))(input_stack_M45d)
''' Merge layers '''
mid_merged = concatenate([mid_90d,mid_0d,mid_45d,mid_M45d], name='mid_merged')
''' Merged layer : Conv - Relu - Conv - BN - Relu '''
mid_merged_=layer2_merged(sz_input-6,sz_input2-6,int(4*filt_num),int(4*filt_num),conv_depth)(mid_merged)
''' Last Conv layer : Conv - Relu - Conv '''
output=layer3_last(sz_input-18,sz_input2-18,int(4*filt_num),int(4*filt_num))(mid_merged_)
model_512 = Model(inputs = [input_stack_90d,input_stack_0d,
input_stack_45d,input_stack_M45d], outputs = [output])
opt = RMSprop(lr=learning_rate)
model_512.compile(optimizer=opt, loss='mae')
model_512.summary()
return model_512
def __init__(self):
# Input shape
self.img_rows = 28
self.img_cols = 28
self.channels = 1
self.img_shape = (self.img_rows, self.img_cols, self.channels)
self.latent_dim = 100
optimizer = Adam(0.0002, 0.5)
# Build and compile the discriminator
self.discriminator = self.build_discriminator()
# Build the generator
self.generator = self.build_generator()
# load weight
self.load_weights_from_file()
# Compile the discriminator
self.discriminator.compile(loss='binary_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
# The generator takes noise as input and generates imgs
z = Input(shape=(self.latent_dim, ))
img = self.generator(z)
# For the combined model we will only train the generator
self.discriminator.trainable = False
# The discriminator takes generated images as input and determines validity
valid = self.discriminator(img)
# The combined model (stacked generator and discriminator)
# Trains the generator to fool the discriminator
self.combined = Model(z, valid)
self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)
def _build_model(self):
input_layer = Input(tensor=self.obsPH)
if self.config.model_type == 'dense':
model_layers = networks.build_dense(input_layer,
self.config.layers,
name_stem='dense_')
elif self.config.model_type == 'conv':
model_layers = networks.build_conv(input_layer)
else:
print("ERROR:", self.config.model_type,
"is an unrecognized model type.")
model = Model(inputs=input_layer, outputs=model_layers)
return model
def squeezenet(self,
type,
img_size=(64, 64),
img_channels=3,
output_size=1000):
input_shape = Input(shape=(*img_size, img_channels))
if type == 1:
x = squeezenet.squeezenet1_0(input_shape, num_classes=output_size)
elif type == 1.1:
x = squeezenet.squeezenet1_1(input_shape, num_classes=output_size)
else:
print("请输入1,1.0这两个数字中的一个！")
model = Model(inputs=input_shape, outputs=x)
self.classifier = model
def define_AttMLFNet(sz_input, sz_input2, view_n, learning_rate):
""" 4 branches inputs"""
input_list = []
for i in range(len(view_n) * 4):
input_list.append(Input(shape=(sz_input, sz_input2, 1)))
""" 4 branches features"""
feature_extraction_layer = feature_extraction(sz_input, sz_input2)
feature_list = []
for i in range(len(view_n) * 4):
feature_list.append(feature_extraction_layer(input_list[i]))
feature_v_list = []
feature_h_list = []
feature_45_list = []
feature_135_list = []
for i in range(9):
feature_h_list.append(feature_list[i])
for i in range(9, 18):
feature_v_list.append(feature_list[i])
for i in range(18, 27):
feature_45_list.append(feature_list[i])
for i in range(27, len(feature_list)):
feature_135_list.append(feature_list[i])
""" cost volume """
cv_h = Lambda(_get_h_CostVolume_)(feature_h_list)
cv_v = Lambda(_get_v_CostVolume_)(feature_v_list)
cv_45 = Lambda(_get_45_CostVolume_)(feature_45_list)
cv_135 = Lambda(_get_135_CostVolume_)(feature_135_list)
""" intra branch """
cv_h_3d, cv_h_ca = to_3d_h(cv_h)
cv_v_3d, cv_v_ca = to_3d_v(cv_v)
cv_45_3d, cv_45_ca = to_3d_45(cv_45)
cv_135_3d, cv_135_ca = to_3d_135(cv_135)
""" inter branch """
cv, attention_4 = branch_attention(
multiply([cv_h_3d, cv_v_3d, cv_45_3d, cv_135_3d]), cv_h_ca, cv_v_ca,
cv_45_ca, cv_135_ca)
""" cost volume regression """
cost = basic(cv)
cost = Lambda(lambda x: K.permute_dimensions(K.squeeze(x, -1),
(0, 2, 3, 1)))(cost)
pred = Activation('softmax')(cost)
pred = Lambda(disparityregression)(pred)
model = Model(inputs=input_list, outputs=[pred])
model.summary()
opt = Adam(lr=learning_rate)
model.compile(optimizer=opt, loss='mae')
return model
def train(self,
x_train,
x_test,
y_train,
y_test,
embedding_matrix,
num_classes,
seq_length=200,
emb_dim=100,
train_emb=True,
windows=(3, 4, 5, 6),
dropouts=(0.2, 0.4),
filter_sz=100,
hid_dim=100,
bch_siz=50,
epoch=8):
#setup and train the nueral net
from tensorflow.contrib.keras.api.keras.models import Model
from tensorflow.contrib.keras.api.keras.layers import Activation, Dense, Dropout, Embedding, Flatten, Input, Concatenate, Conv1D, MaxPool1D
inp = Input(shape=(seq_length, ))
out = Embedding(input_dim=len(embedding_matrix[:, 1]),
output_dim=emb_dim,
input_length=seq_length,
weights=[embedding_matrix],
trainable=train_emb)(inp)
out = Dropout(dropouts[0])(out)
convs = []
for w in windows:
conv = Conv1D(filters=filter_sz,
kernel_size=w,
padding='valid',
activation='relu',
strides=1)(out)
conv = MaxPool1D(pool_size=2)(conv)
conv = Flatten()(conv)
convs.append(conv)
out = Concatenate()(convs)
out = Dense(hid_dim, activation='relu')(out)
out = Dropout(dropouts[1])(out)
out = Activation('relu')(out)
out = Dense(num_classes, activation='softmax')(out)
model = Model(inp, out)
model.compile(loss='categorical_crossentropy',
optimizer='nadam',
metrics=['accuracy'])
model.fit(x_train,
y_train,
batch_size=bch_siz,
epochs=epoch,
verbose=2,
validation_data=(x_test, y_test))
return model
def build_discriminator_dense():
model = Sequential()
model.add(Flatten(input_shape=url_shape))
# Add arbitrary layers
for size in discriminator_layers.split(":"):
size = int(size)
model.add(Dense(size, activation=discriminator_activation))
model.add(Dropout(dropout_value))
# Add the final layer, with a single output
model.add(Dense(1, activation='sigmoid'))
model.summary()
# Build the model
gen = Input(shape=url_shape)
validity = model(gen)
return Model(gen, validity)
def densenet(self,
type,
img_size=(299, 299),
img_channels=3,
output_size=1000):
input_shape = Input(shape=(*img_size, img_channels))
if type == 161:
x = densenet.densenet161(input_shape, num_classes=output_size)
elif type == 121:
x = densenet.densenet121(input_shape, num_classes=output_size)
elif type == 169:
x = densenet.densenet169(input_shape, num_classes=output_size)
elif type == 201:
x = densenet.densenet201(input_shape, num_classes=output_size)
else:
print("请输入161,121,169,201这四个数字中的一个！")
return
model = Model(inputs=input_shape, outputs=x)
self.classifier = model
def inference(self):
''' 4-Input : Conv - Relu - Conv - BN - Relu '''
input_stack_90d = Input(shape=(self.img_height, self.img_width,
len(self.view_n)),
name='input_stack_90d')
input_stack_0d = Input(shape=(self.img_height, self.img_width,
len(self.view_n)),
name='input_stack_0d')
input_stack_45d = Input(shape=(self.img_height, self.img_width,
len(self.view_n)),
name='input_stack_45d')
input_stack_M45d = Input(shape=(self.img_height, self.img_width,
len(self.view_n)),
name='input_stack_M45d')
''' 4-Stream layer : Conv - Relu - Conv - BN - Relu '''
mid_90d = self.layer1_multistream(self.img_height, self.img_width,
len(self.view_n),
int(self.filt_num))(input_stack_90d)
mid_0d = self.layer1_multistream(self.img_height, self.img_width,
len(self.view_n),
int(self.filt_num))(input_stack_0d)
mid_45d = self.layer1_multistream(self.img_height, self.img_width,
len(self.view_n),
int(self.filt_num))(input_stack_45d)
mid_M45d = self.layer1_multistream(
self.img_height, self.img_width, len(self.view_n),
int(self.filt_num))(input_stack_M45d)
''' Merge layers '''
mid_merged = concatenate([mid_90d, mid_0d, mid_45d, mid_M45d],
name='mid_merged')
''' Merged layer : Conv - Relu - Conv - BN - Relu '''
mid_merged_ = self.layer2_merged(self.img_height - 6,
self.img_width - 6,
int(4 * self.filt_num),
int(4 * self.filt_num),
self.conv_depth)(mid_merged)
''' Last Conv layer : Conv - Relu - Conv '''
output = self.layer3_last(self.img_height - 18, self.img_width - 18,
int(4 * self.filt_num),
int(4 * self.filt_num))(mid_merged_)
epinet = Model(inputs=[
input_stack_90d, input_stack_0d, input_stack_45d, input_stack_M45d
],
outputs=[output])
opt = RMSprop(lr=self.learning_rate)
epinet.compile(optimizer=opt, loss='mae')
epinet.summary()
return epinet
def resnet(self,
type,
img_size=(64, 64),
img_channels=3,
output_size=1000):
input_shape = Input(shape=(*img_size, img_channels))
if type == 18:
x = resnet.resnet18(input_shape, num_classes=output_size)
elif type == 34:
x = resnet.resnet34(input_shape, num_classes=output_size)
elif type == 50:
x = resnet.resnet50(input_shape, num_classes=output_size)
elif type == 101:
x = resnet.resnet101(input_shape, num_classes=output_size)
elif type == 152:
x = resnet.resnet152(input_shape, num_classes=output_size)
else:
print("请输入18,34,50,101,152这五个数字中的一个！")
return
model = Model(inputs=input_shape, outputs=x)
self.classifier = model
embedding_layer = Embedding(num_words,
EMBEDDING_DIM,
weights=[embedding_matrix],
input_length=MAX_SEQUENCE_LENGTH,
trainable=False)
print('Training model.')
# train a 1D convnet with global maxpooling
sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
x = Conv1D(128, 5, activation='relu')(embedded_sequences)
x = MaxPooling1D(5)(x)
x = Conv1D(128, 5, activation='relu')(x)
x = MaxPooling1D(5)(x)
x = Conv1D(128, 5, activation='relu')(x)
x = MaxPooling1D(35)(x)
x = Flatten()(x)
x = Dense(128, activation='relu')(x)
preds = Dense(len(labels_index), activation='softmax')(x)
model = Model(sequence_input, preds)
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['acc'])
model.fit(x_train, y_train,
batch_size=128,
epochs=10,
validation_data=(x_val, y_val))
