def inference(self, mode='simple'):
left_image = Input(shape=(self.model_in_height, self.model_in_width,
self.model_in_depth),
name='left_input')
right_image = Input(shape=(self.model_in_height, self.model_in_width,
self.model_in_depth),
name='right_image')
if mode == 'simple':
concate_view = concatenate([left_image, right_image],
axis=3,
name='concate_view')
prediction = self.FlowNetSimple(concate_view)
FlowNet = Model(inputs=[left_image, right_image],
outputs=[prediction])
opt = Adam(lr=self.learning_rate)
FlowNet.compile(optimizer=opt, loss='mae')
FlowNet.summary()
return FlowNet
if mode == 'correlation':
prediction = self.FlowNetCorr(left_image, right_image)
FlowNet = Model(inputs=[left_image, right_image],
outputs=[prediction])
opt = Adam(lr=self.learning_rate)
FlowNet.compile(optimizer=opt, loss='mae')
FlowNet.summary()
return FlowNet
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 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 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 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 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 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 define_cepinet(sz_input,sz_input2,view_n,conv_depth,filt_num,learning_rate,for_vis = False):
global feats
if for_vis:
feats = []
else:
feats = None
''' 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')
num_stacks = 3
with tf.variable_scope("4-Stream"):
''' 4-Stream layer : Conv - Relu - Conv - BN - Relu '''
mid_90d = layer1_multistream(sz_input,sz_input2,len(view_n),int(filt_num),do_vis=True,name="90d")(input_stack_90d)
mid_0d = layer1_multistream(sz_input,sz_input2,len(view_n),int(filt_num),do_vis=True,name="0d")(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),do_vis=True,name="M45d")(input_stack_M45d)
with tf.variable_scope("Merge"):
''' Merge layers '''
mid_merged = concatenate([mid_90d,mid_0d,mid_M45d], name='mid_merged')
''' Merged layer : Conv - Relu - Conv - BN - Relu '''
mid_merged_=layer2_merged(sz_input-6,sz_input2-6,int(num_stacks*filt_num),int(num_stacks*filt_num),conv_depth)(mid_merged)
with tf.variable_scope("Last"):
''' Last Conv layer : Conv - Relu - Conv '''
output=layer3_last(sz_input-18,sz_input2-18,int(num_stacks*filt_num),int(num_stacks*filt_num))(mid_merged_)
if for_vis:
feat_outs90d = [feat(input_stack_90d) for feat in feats[0:6]]
feat_outs0d = [feat(input_stack_0d) for feat in feats[6:12]]
feat_outsM45d = [feat(input_stack_M45d) for feat in feats[12:18]]
outputs = feat_outs90d + feat_outs0d + feat_outsM45d + [output]
else:
outputs = [output]
model_512 = Model(inputs = [input_stack_90d,input_stack_0d,
# input_stack_45d,
input_stack_M45d], outputs = outputs)
opt = RMSprop(lr=learning_rate)
model_512.compile(optimizer=opt, loss='mae')
model_512.summary()
return model_512, feat_names
def define_LFattNet(sz_input, sz_input2, view_n, learning_rate):
""" 81 inputs"""
input_list = []
for i in range(len(view_n) * len(view_n)):
print('input ' + str(i))
input_list.append(Input(shape=(sz_input, sz_input2, 1)))
""" 81 features"""
feature_extraction_layer = feature_extraction(sz_input, sz_input2)
feature_list = []
for i in range(len(view_n) * len(view_n)):
print('feature ' + str(i))
feature_list.append(feature_extraction_layer(input_list[i]))
""" cost volume """
cv = Lambda(_getCostVolume_)(feature_list)
""" channel attention """
cv, attention = channel_attention(cv)
""" 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)
# when training use below
# model = Model(inputs=input_list, outputs=[pred])
# when evaluation use below
model = Model(inputs=input_list, outputs=[pred, attention])
model.summary()
opt = Adam(lr=learning_rate)
model.compile(optimizer=opt, loss='mae')
return model
class _DMNN(object):
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 update_lr(self, lr):
K.set_value(self.model.optimizer.lr, lr)
def define_epinet(sz_input, sz_input2, view_n, conv_depth, filt_num,
learning_rate):
global feats
''' 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),
do_vis=True,
name="90d")(input_stack_90d)
mid_0d = layer1_multistream(sz_input,
sz_input2,
len(view_n),
int(filt_num),
do_vis=True,
name="0d")(input_stack_0d)
mid_45d = layer1_multistream(sz_input,
sz_input2,
len(view_n),
int(filt_num),
do_vis=True,
name="45d")(input_stack_45d)
mid_M45d = layer1_multistream(sz_input,
sz_input2,
len(view_n),
int(filt_num),
do_vis=True,
name="M45d")(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_)
feat_outs90d = [feat(input_stack_90d) for feat in feats[0:1]]
feat_outs0d = [feat(input_stack_0d) for feat in feats[1:2]]
feat_outs45d = [feat(input_stack_45d) for feat in feats[2:3]]
feat_outsM45d = [feat(input_stack_M45d) for feat in feats[3:4]]
outputs = feat_outs90d + feat_outs0d + feat_outs45d + feat_outsM45d + [
output
]
model_512 = Model(inputs=[
input_stack_90d, input_stack_0d, input_stack_45d, input_stack_M45d
],
outputs=outputs)
opt = RMSprop(lr=learning_rate)
model_512.compile(optimizer=opt, loss='mae')
model_512.summary()
return model_512, feat_names
class DCGAN():
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_generator(self):
model = Sequential()
model.add(
Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))
model.add(Reshape((7, 7, 128)))
model.add(UpSampling2D())
model.add(Conv2D(128, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(UpSampling2D())
model.add(Conv2D(64, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(Conv2D(self.channels, kernel_size=3, padding="same"))
model.add(Activation("tanh"))
# model.summary()
noise = Input(shape=(self.latent_dim, ))
img = model(noise)
return Model(noise, img)
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 train(self, epochs, batch_size=128, save_interval=50):
# Load the dataset
# (X_train, _), (_, _) = mnist.load_data()
(X_train, y_train) = mnist.train.images, mnist.train.labels
# Rescale -1 to 1
X_train = X_train / 127.5 - 1.
print(X_train.shape)
X_train = np.reshape(X_train, (-1, 28, 28, 1))
# Adversarial ground truths
valid = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
for epoch in range(epochs):
# ---------------------
# Train Discriminator
# ---------------------
# Select a random half of images
idx = np.random.randint(0, X_train.shape[0], batch_size)
imgs = X_train[idx]
# Sample noise and generate a batch of new images
noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
gen_imgs = self.generator.predict(noise)
# Train the discriminator (real classified as ones and generated as zeros)
d_loss_real = self.discriminator.train_on_batch(imgs, valid)
d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# ---------------------
# Train Generator
# ---------------------
# Train the generator (wants discriminator to mistake images as real)
g_loss = self.combined.train_on_batch(noise, valid)
# Plot the progress
print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" %
(epoch, d_loss[0], 100 * d_loss[1], g_loss))
# If at save interval => save generated image samples
if epoch % save_interval == 0:
self.save_imgs(epoch)
self.save_model()
def save_imgs(self, epoch):
r, c = 5, 5
noise = np.random.normal(0, 1, (r * c, self.latent_dim))
gen_imgs = self.generator.predict(noise)
# Rescale images 0 - 1
gen_imgs = 0.5 * gen_imgs + 0.5
fig, axs = plt.subplots(r, c)
cnt = 0
for i in range(r):
for j in range(c):
axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
axs[i, j].axis('off')
cnt += 1
fig.savefig("images/mnist_%d.png" % epoch)
plt.close()
return
# Save model
def save_model(self):
self.discriminator.save_weights(weight_path +
'dcgan_discriminator_weight.h5')
self.generator.save_weights(weight_path + 'dcgan_generator_weight.h5')
print("save model")
# load weights
def load_weights_from_file(self):
# discriminator weight
if self.discriminator != None and os.path.isfile(
weight_path + "dcgan_discriminator_weight.h5"):
print("discriminator_weights exists")
self.discriminator.load_weights(weight_path +
"dcgan_discriminator_weight.h5")
# generator weight
if self.generator != None and os.path.isfile(
weight_path + "dcgan_generator_weight.h5"):
print("generator_weights exists")
self.generator.load_weights(weight_path +
"dcgan_generator_weight.h5")
row, col, pixel = x_train.shape[1:]
# 4D input.
x = Input(shape=(row, col, pixel))
# Encodes a row of pixels using TimeDistributed Wrapper.
encoded_rows = TimeDistributed(LSTM(row_hidden))(x)
# Encodes columns of encoded rows.
encoded_columns = LSTM(col_hidden)(encoded_rows)
# Final predictions and model.
prediction = Dense(num_classes, activation='softmax')(encoded_columns)
model = Model(x, prediction)
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
# Training.
model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test))
# Evaluation.
scores = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
def main():
# Define Functions
build_generator = build_generator_dense
build_discriminator = build_discriminator_dense
# Build dictionary
dictionary = {}
reverse_dictionary = {}
for i, c in enumerate(alphabet):
dictionary[c]=i+1
reverse_dictionary[i+1]=c
# Build Oprimizer
optimizer = Adam(learning_rate, 0.5)
# Build and compile the discriminator
print ("*** BUILDING DISCRIMINATOR ***")
discriminator = build_discriminator()
discriminator.compile(loss='binary_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
# Build and compile the generator
print ("*** BUILDING GENERATOR ***")
generator = build_generator()
generator.compile(loss='binary_crossentropy', optimizer=optimizer)
# The generator takes noise as input and generated samples
z = Input(shape=noise_shape)
gen = generator(z)
# For the combined model we will only train the generator
discriminator.trainable = False
# The valid takes generated samples as input and determines validity
valid = discriminator(gen)
# The combined model (stacked generator and discriminator) takes
# noise as input => generates samples => determines validity
combined = Model(z, valid)
combined.compile(loss='binary_crossentropy', optimizer=optimizer)
# Load the dataset
data = []
for line in open(input_data,"r").read().splitlines():
this_sample=np.zeros(url_shape)
line = line.lower()
if len ( set(line) - set(alphabet)) == 0 and len(line) < url_len:
for i, position in enumerate(this_sample):
this_sample[i][0]=1.0
for i, char in enumerate(line):
this_sample[i][0]=0.0
this_sample[i][dictionary[char]]=1.0
data.append(this_sample)
else:
print("Uncompatible line:", line)
print("Data ready. Lines:", len(data))
X_train = np.array(data)
print ("Array Shape:", X_train.shape)
half_batch = int(batch_size / 2)
# Start Training
for epoch in range(epochs):
# ---------------------
# Train Discriminator
# ---------------------
# Select a random half batch of data
idx = np.random.randint(0, X_train.shape[0], half_batch)
samples = X_train[idx]
noise_batch_shape = (half_batch,) + noise_shape
noise = np.random.normal(0, 1, noise_batch_shape)
# Generate a half batch of new data
gens = generator.predict(noise)
# Train the discriminator
d_loss_real = discriminator.train_on_batch(samples, np.ones((half_batch, 1)))
d_loss_fake = discriminator.train_on_batch(gens, np.zeros((half_batch, 1)))
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# ---------------------
# Train Generator
# ---------------------
noise_batch_shape = (batch_size,) + noise_shape
noise = np.random.normal(0, 1, noise_batch_shape)
# The generator wants the discriminator to label the generated samples as valid (ones)
valid_y = np.array([1] * batch_size)
# Train the generator
g_loss = combined.train_on_batch(noise, valid_y)
# Plot the progress
print ("%d [D loss: %0.3f, acc.: %0.3f%%] [G loss: %0.3f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))
# If at save interval, print some examples
if epoch % save_interval == 0:
generated_samples=[]
r, c = 5, 5
noise_batch_shape = (print_size,) + noise_shape
noise = np.random.normal(0, 1, noise_batch_shape)
gens = generator.predict(noise)
for url in gens:
this_url_gen = ""
for position in url:
this_index = np.argmax(position)
if this_index != 0:
this_url_gen += reverse_dictionary[this_index]
print(this_url_gen)
generated_samples.append(this_url_gen)
# Save networks
discriminator.save(discriminator_savefile)
generator.save(generator_savefile)
# Save Samples
fo = open(generated_savefile, "w")
for url in generated_samples:
print (url, file=fo)
fo.close()
return dense3
if __name__ == '__main__':
# 输入
myinput = Input([32, 32, 3])
# 构建网络
output = lenet(myinput)
# 建立模型
model = Model(myinput, output)
# 定义优化器，这里选用Adam优化器，学习率设置为0.0003
adam = Adam(lr=0.0003)
# 编译模型
model.compile(optimizer=adam,
loss="categorical_crossentropy",
metrics=['accuracy'])
# 准备数据
# 获取输入的图像
X = GetTrainDataByLabel('data')
# 获取图像的label，这里使用to_categorical函数返回one-hot之后的label
Y = to_categorical(GetTrainDataByLabel('labels'))
# 开始训练模型，batch设置为200，一共50个epoch
model.fit(X,
Y,
200,
50,
1,
callbacks=[
def main():
batch_size = _BATCH_SIZE
noise_dim = _NOISE_DIM
lamb = 10.0
train = get_data()
train_images, train_labels = make_batch(train)
gen = generator()
dis = discriminator()
gen.summary()
dis.summary()
dis_opt = Adam(lr=1.0e-4, beta_1=0.0, beta_2=0.9)
gen_opt = Adam(lr=1.0e-4, beta_1=0.0, beta_2=0.9)
gen.trainable = True
dis.trainable = False
gen_inputs = Input(shape=(noise_dim, ))
gen_outputs = gen(gen_inputs)
dis_outputs = dis(gen_outputs)
gen_model = Model(inputs=[gen_inputs], outputs=[dis_outputs])
gen_model.compile(loss=wasserstein_loss, optimizer=gen_opt)
gen_model.summary()
gen.trainable = False
dis.trainable = True
real_inputs = Input(shape=train_images.shape[1:])
dis_real_outputs = dis(real_inputs)
fake_inputs = Input(shape=(noise_dim, ))
gen_fake_outputs = gen(fake_inputs)
dis_fake_outputs = dis(gen_fake_outputs)
interpolate = RandomWeightedAverage()([real_inputs, gen_fake_outputs])
dis_interpolate_outputs = dis(interpolate)
gp_reg = partial(gradient_penalty, interpolate=interpolate, lamb=lamb)
#gp_reg.__name__ = 'gradient_penalty'
dis_model = Model(inputs=[real_inputs, fake_inputs],\
outputs=[dis_real_outputs, dis_fake_outputs,dis_interpolate_outputs])
dis_model.compile(loss=[wasserstein_loss, wasserstein_loss, gp_reg],
optimizer=dis_opt)
dis_model.summary()
max_epoch = 10001
max_train_only_dis = 5
minibatch_size = batch_size * max_train_only_dis
max_loop = int(train_images.shape[0] / minibatch_size)
real = np.zeros((batch_size, train_images.shape[1], train_images.shape[2],
train_images.shape[3]),
dtype=np.float32)
minibatch_train_images = np.zeros(
(minibatch_size, train_images.shape[1], train_images.shape[2],
train_images.shape[3]),
dtype=np.float32)
progbar = Progbar(target=max_epoch)
real_label = [-1] * batch_size
fake_label = [1] * batch_size
dummy_label = [0] * batch_size
for epoch in range(max_epoch):
np.random.shuffle(train_images)
for loop in range(max_loop):
minibatch_train_images = train_images[loop *
minibatch_size:(loop + 1) *
minibatch_size]
for train_only_dis in range(max_train_only_dis):
real = minibatch_train_images[train_only_dis *
batch_size:(train_only_dis + 1) *
batch_size]
noise = np.random.uniform(
-1, 1, (batch_size, noise_dim)).astype(np.float32)
dis_loss = dis_model.train_on_batch(
[real, noise], [real_label, fake_label, dummy_label])
noise = np.random.uniform(-1, 1, (batch_size, noise_dim)).astype(
np.float32)
gen_loss = gen_model.train_on_batch(noise, real_label)
progbar.add(1,
values=[("dis_loss", dis_loss[0]), ("gen_loss", gen_loss)])
if epoch % 100 == 0:
noise = np.random.uniform(-1, 1,
(batch_size, 10)).astype(np.float32)
fake = gen.predict(noise)
tmp = [r.reshape(-1, 32) for r in fake]
tmp = np.concatenate(tmp, axis=1)
img = ((tmp / 2.0 + 0.5) * 255.0).astype(np.uint8)
Image.fromarray(img).save("generate/%d.png" % (epoch))
backend.clear_session()
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))
def train(data,
file_name,
nlayer,
num_epochs=10,
batch_size=128,
train_temp=1,
init=None,
activation=tf.nn.relu):
"""
Train a n-layer CNN for MNIST and CIFAR
"""
inputs = Input(shape=(28, 28, 1))
if nlayer == 2:
x = Residual2(8, activation)(inputs)
x = Lambda(activation)(x)
x = Residual2(16, activation)(x)
x = Lambda(activation)(x)
x = AveragePooling2D(pool_size=7)(x)
x = Flatten()(x)
x = Dense(10)(x)
if nlayer == 3:
x = Residual2(8, activation)(inputs)
x = Lambda(activation)(x)
x = Residual(8, activation)(x)
x = Lambda(activation)(x)
x = Residual2(16, activation)(x)
x = Lambda(activation)(x)
x = AveragePooling2D(pool_size=7)(x)
x = Flatten()(x)
x = Dense(10)(x)
if nlayer == 4:
x = Residual2(8, activation)(inputs)
x = Lambda(activation)(x)
x = Residual(8, activation)(x)
x = Lambda(activation)(x)
x = Residual2(16, activation)(x)
x = Lambda(activation)(x)
x = Residual(16, activation)(x)
x = Lambda(activation)(x)
x = AveragePooling2D(pool_size=7)(x)
x = Flatten()(x)
x = Dense(10)(x)
if nlayer == 5:
x = Residual2(8, activation)(inputs)
x = Lambda(activation)(x)
x = Residual(8, activation)(x)
x = Lambda(activation)(x)
x = Residual(8, activation)(x)
x = Lambda(activation)(x)
x = Residual2(16, activation)(x)
x = Lambda(activation)(x)
x = Residual(16, activation)(x)
x = Lambda(activation)(x)
x = AveragePooling2D(pool_size=7)(x)
x = Flatten()(x)
x = Dense(10)(x)
model = Model(inputs=inputs, outputs=x)
# load initial weights when given
if init != None:
model.load_weights(init)
# define the loss function which is the cross entropy between prediction and true label
def fn(correct, predicted):
return tf.nn.softmax_cross_entropy_with_logits(labels=correct,
logits=predicted /
train_temp)
# initiate the Adam optimizer
sgd = Adam()
# compile the Keras model, given the specified loss and optimizer
model.compile(loss=fn, optimizer=sgd, metrics=['accuracy'])
model.summary()
# run training with given dataset, and print progress
history = model.fit(data.train_data,
data.train_labels,
batch_size=batch_size,
validation_data=(data.validation_data,
data.validation_labels),
epochs=num_epochs,
shuffle=True)
# save model to a file
if file_name != None:
model.save(file_name)
return {'model': model, 'history': history}
def main():
if os.path.isfile(macro._LOCAL_SAVE_DATA) == 0:
# download data and compute featuers (see "download_data.py")
# atomic_numbers use to compute composition vector
# labels is target properties (formation energy)
train_labels, compositions, features, atomic_numbers = dl.get_data()
# compute bag-of-atom vector that trains GAN (see "preprocess.py")
boa_vectors = pre.compute_bag_of_atom_vector(compositions,
atomic_numbers)
train_data = np.concatenate([boa_vectors, features], axis=1)
save_data = pd.DataFrame(
np.concatenate([train_labels, train_data], axis=1))
save_data.to_csv(macro._LOCAL_SAVE_DATA, index=False, header=False)
else:
data = pd.read_csv(macro._LOCAL_SAVE_DATA,
delimiter=',',
engine="python",
header=None)
data = np.array(data)
train_labels, train_data = np.split(data, [1], axis=1)
# normalization of training data such that min is 0 and max is 1 (see "preprocess.py")
normalized_train_data, data_max, data_min = pre.normalize_for_train(
train_data)
normalized_train_labels, max_train_prop, min_train_prop = pre.normalize_for_train(
train_labels)
# Save normalization parameter to .csv to use generation
save_data = pd.DataFrame(
np.concatenate([max_train_prop, min_train_prop, data_max, data_min],
axis=0))
save_data.to_csv(macro._SAVE_NORMALIZATION_PARAM,
index=False,
header=False)
### start initialization of training GAN ###
# set hyperparameters
batch_size = macro._BATCH_SIZE # batch size
noise_dim = macro._NOISE_DIM # dimension of noise to input generator
property_dim = macro._PROP_DIM # the number of properties
lamb = macro._LAMB # hyperparameter for W-GAN-GP
max_epoch = macro._MAX_EPOCH # maximum iteration of outer loop
max_train_only_dis = macro._MAX_EPOCH_TRAIN_DISCRIMINATOR # maximum iteration of inner loop defined by W-GAN-GP paper (https://arxiv.org/pdf/1704.00028.pdf)
max_loop = int(train_data.shape[0] / batch_size)
# set model (see "model.py")
# in this code, we apply AC-GAN based network architecture (https://arxiv.org/abs/1610.09585)
# difference between AC-GAN is that our model is the regression, not classification
gen = model.generator(normalized_train_data.shape[1])
dis = model.discriminator(normalized_train_data.shape[1])
# rf is the output layer of discriminator that discriminates real or fake
rf = model.real_fake()
# pred is the output layer of discriminator that predicts target property
pred = model.prediction()
# set optimization method
dis_opt = Adam(lr=1.0e-4, beta_1=0.0, beta_2=0.9)
gen_opt = Adam(lr=1.0e-4, beta_1=0.0, beta_2=0.9)
# first set discriminator's parameters for training
gen.trainable = False # generator's parameter does not update
dis.trainable = True
rf.trainable = True
pred.trainable = True
# set variables when inputting real data
real_inputs = Input(shape=normalized_train_data.shape[1:])
dis_real_outputs = dis(real_inputs)
real_fake_from_real = rf(dis_real_outputs)
predictions_from_real = pred(dis_real_outputs)
# set variables when inputting fake data
fake_inputs = Input(shape=(noise_dim + property_dim, ))
gen_fake_outputs = gen(fake_inputs)
dis_fake_outputs = dis(gen_fake_outputs)
real_fake_from_fake = rf(dis_fake_outputs)
# set loss function for discriminator
# in this case, we apply W-GAN-GP based loss function because of improving stability
# W-GAN-GP (https://arxiv.org/pdf/1704.00028.pdf)
# W-GAN-GP is unsupervised training, on the other hand, our model is supervised (conditional).
# So, we apply wasserstein_loss to real_fake part and apply mean_squared_error to prediction part
interpolate = model.RandomWeightedAverage()(
[real_inputs, gen_fake_outputs])
dis_interpolate_outputs = dis(interpolate)
real_fake_interpolate = rf(dis_interpolate_outputs)
# gradient penalty of W-GAN-GP
gp_reg = partial(model.gradient_penalty,
interpolate=interpolate,
lamb=lamb)
gp_reg.__name__ = 'gradient_penalty'
# connect inputs and outputs of the discriminator
# prediction part is trained by only using training dataset (i.e., predict part is not trained by generated samples)
dis_model = Model(inputs=[real_inputs, fake_inputs],\
outputs=[real_fake_from_real, real_fake_from_fake, real_fake_interpolate, predictions_from_real])
# compile
dis_model.compile(loss=[model.wasserstein_loss,model.wasserstein_loss,\
gp_reg,'mean_squared_error'],optimizer=dis_opt)
# second set generator's parameters for training
gen.trainable = True # generator's parameters only update
dis.trainable = False
rf.trainable = False
pred.trainable = False
# set variables when inputting noise and target property
gen_inputs = Input(shape=(noise_dim + property_dim, ))
gen_outputs = gen(gen_inputs)
# set variables for discriminator when inputting fake data
dis_outputs = dis(gen_outputs)
real_fake = rf(dis_outputs)
predictions = pred(dis_outputs)
# connect inputs and outputs of the discriminator
gen_model = Model(inputs=[gen_inputs], outputs=[real_fake, predictions])
# compile
# generator is trained by real_fake classification and prediction of target property
gen_model.compile(loss=[model.wasserstein_loss, 'mean_squared_error'],
optimizer=gen_opt)
# if you need progress bar
progbar = Progbar(target=max_epoch)
# set the answer to train each model
real_label = [-1] * batch_size
fake_label = [1] * batch_size
dummy_label = [0] * batch_size
#real = np.zeros((batch_size,train_data.shape[1]), dtype=np.float32)
inputs = np.zeros((batch_size, noise_dim + property_dim), dtype=np.float32)
# epoch
for epoch in range(max_epoch):
# iteration
for loop in range(max_loop):
# shuffle to change the trainng order and select data
sdata, slabels, bak = pre.paired_shuffle(normalized_train_data,
normalized_train_labels)
real = sdata[loop * batch_size:(loop + 1) * batch_size]
properties = slabels[loop * batch_size:(loop + 1) * batch_size]
# generator's parameters does not update
gen.trainable = False
dis.trainable = True
rf.trainable = True
pred.trainable = True
# train discriminator
for train_only_dis in range(max_train_only_dis):
noise = np.random.uniform(
-1, 1, (batch_size, noise_dim)).astype(np.float32)
for i in range(len(noise)):
inputs[i] = np.hstack((noise[i], properties[i]))
dis_loss = dis_model.train_on_batch(
[real, inputs],
[real_label, fake_label, dummy_label, properties])
# second train only generator
gen.trainable = True
dis.trainable = False
rf.trainable = False
pred.trainable = False
noise = np.random.uniform(-1, 1, (batch_size, noise_dim)).astype(
np.float32)
for i in range(len(noise)):
inputs[i] = np.hstack((noise[i], properties[i]))
gen_loss = gen_model.train_on_batch([inputs],
[real_label, properties])
# if you need progress bar
progbar.add(1,
values=[("dis_loss", dis_loss[0]),
("gen_loss", gen_loss[0])])
# save generated samples and models
eval.save(normalized_train_data, gen, dis, pred, rf)
backend.clear_session()
def transfer_model(source_df, target_df, test_df, method_flag, fold_num):
source_labels, source_data = np.split(np.array(source_df),[1],axis=1)
target_labels, target_data = np.split(np.array(target_df),[1],axis=1)
test_labels, test_data = np.split(np.array(test_df),[1],axis=1)
# normalization
#normalized_source_data = pre.normalize(source_data)
#normalized_target_data = pre.normalize(target_data)
#normalized_test_data = pre.normalize(test_data)
normalized_source_data = source_data
normalized_target_data = target_data
normalized_test_data = test_data
### constuct model for source domain task ###
# optimization
opt = Adam()
# network setting
latent = models.latent(normalized_source_data.shape[1])
sll = models.source_last_layer()
tll = models.target_last_layer()
source_inputs = Input(shape=normalized_source_data.shape[1:])
latent_features = latent(source_inputs)
source_predictors = sll(latent_features)
latent.trainable = mc._SORUCE_LATENT_TRAIN
source_predictors.trainable = True
source_nn = Model(inputs=[source_inputs], outputs=[source_predictors])
source_nn.compile(loss=['mean_squared_error'],optimizer=opt)
#source_nn.summary()
# training using source domain data
if method_flag != mc._SCRATCH:
source_max_loop = int(normalized_source_data.shape[0]/mc._BATCH_SIZE)
source_progbar = Progbar(target=mc._SOURCE_EPOCH_NUM)
for epoch in range(mc._SOURCE_EPOCH_NUM):
shuffle_data, shuffle_labels, _ = pre.paired_shuffle(normalized_source_data,source_labels,1)
for loop in range(source_max_loop):
batch_train_data = shuffle_data[loop*mc._BATCH_SIZE:(loop+1)*mc._BATCH_SIZE]
batch_train_labels = shuffle_labels[loop*mc._BATCH_SIZE:(loop+1)*mc._BATCH_SIZE]
batch_train_labels = np.reshape(batch_train_labels, [len(batch_train_labels)])
one_hots = np.identity(mc._SOURCE_DIM_NUM)[np.array(batch_train_labels, dtype=np.int32)]
loss = source_nn.train_on_batch([batch_train_data],[one_hots])
#source_progbar.add(1, values=[("source loss",loss)])
# save
#latent.save('../results/source_latent.h5')
#sll.save('../results/source_last_layer.h5')
# compute relation vectors
if method_flag == mc._SCRATCH or method_flag == mc._CONV_TRANSFER:
target_vectors = np.identity(mc._TARGET_DIM_NUM)[np.array(target_labels, dtype=np.int32)]
target_vectors = np.reshape(target_vectors, [target_vectors.shape[0], target_vectors.shape[2]])
elif method_flag == mc._COUNT_ATDL:
target_labels, relations = rv.compute_relation_labels(source_nn, normalized_target_data, target_labels, fold_num)
target_vectors = np.identity(mc._SOURCE_DIM_NUM)[np.array(target_labels, dtype=np.int32)]
target_vectors = np.reshape(target_vectors, [target_vectors.shape[0], target_vectors.shape[2]])
else:
relation_vectors = rv.compute_relation_vectors(source_nn, normalized_target_data, target_labels, fold_num, method_flag)
target_vectors = np.zeros((len(target_labels),mc._SOURCE_DIM_NUM), dtype=np.float32)
for i in range(len(target_labels)):
target_vectors[i] = relation_vectors[int(target_labels[i])]
### tuning model for target domain task ###
latent.trainable = mc._TARGET_LATENT_TRAIN
target_inputs = Input(shape=normalized_target_data.shape[1:])
latent_features = latent(target_inputs)
if method_flag == mc._SCRATCH or method_flag == mc._CONV_TRANSFER:
predictors = tll(latent_features)
label_num = mc._TARGET_DIM_NUM
else:
predictors= sll(latent_features)
label_num = mc._SOURCE_DIM_NUM
target_nn = Model(inputs=[target_inputs], outputs=[predictors])
target_nn.compile(loss=['mean_squared_error'],optimizer=opt)
#target_nn.summary()
# training using target domain data
target_max_loop = int(normalized_target_data.shape[0]/mc._BATCH_SIZE)
target_progbar = Progbar(target=mc._TARGET_EPOCH_NUM)
for epoch in range(mc._TARGET_EPOCH_NUM):
shuffle_data, shuffle_labels, _ = \
pre.paired_shuffle(normalized_target_data, target_vectors, label_num)
for loop in range(target_max_loop):
batch_train_data = shuffle_data[loop*mc._BATCH_SIZE:(loop+1)*mc._BATCH_SIZE]
batch_train_labels = shuffle_labels[loop*mc._BATCH_SIZE:(loop+1)*mc._BATCH_SIZE]
loss = target_nn.train_on_batch([batch_train_data],[batch_train_labels])
#target_progbar.add(1, values=[("target loss",loss)])
# compute outputs of test data of target domain
x = target_nn.predict([normalized_test_data])
if method_flag == mc._SCRATCH or method_flag == mc._CONV_TRANSFER:
idx = np.argmax(x, axis=1)
elif method_flag == mc._COUNT_ATDL:
idx = np.argmax(x,axis=1)
for j in range(len(test_labels)):
for i in range(mc._TARGET_DIM_NUM):
if test_labels[j] == i:
test_labels[j] = relations[i]
break
else:
distance, idx = Neighbors(x, relation_vectors, 1)
idx = idx[:,0]
backend.clear_session()
return idx.T, test_labels.T