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 train_inception(self, x_train, y_train, learn_rate=0.001, epoch=5, batch_size=128, validation_split_size=0.2, train_callbacks=()):
history = LossHistory()
X_train, X_valid, y_train, y_valid = train_test_split(x_train, y_train, test_size=validation_split_size)
# this is the model we will train
self.classifier = Model(inputs=self.base_model.input, outputs=self.predictions)
# first: train only the top layers (which were randomly initialized)
# i.e. freeze all convolutional InceptionV3 layers
for layer in base_model.layers:
layer.trainable = False
opt = RMSprop(lr=learn_rate)
# compile the model (should be done *after* setting layers to non-trainable)
self.classifier.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])
earlyStopping = EarlyStopping(monitor='val_loss', patience=3, verbose=0, mode='auto')
# train the model on the new data for a few epochs
self.classifier.fit_generator(...)
# at this point, the top layers are well trained and we can start fine-tuning
# convolutional layers from inception V3. We will freeze the bottom N layers
# and train the remaining top layers.
# let's visualize layer names and layer indices to see how many layers
# we should freeze:
for i, layer in enumerate(base_model.layers):
print(i, layer.name)
# we chose to train the top 2 inception blocks, i.e. we will freeze
# the first 249 layers and unfreeze the rest:
for layer in self.classifier.layers[:249]:
layer.trainable = False
for layer in self.classifier.layers[249:]:
layer.trainable = True
# we need to recompile the mode for these modifications to take effect
# we use SGD with a low learning rate
opt_sgd = SGD(lr=0.0001, momentum=0.9)
self.classifier.compile(optimizer=opt_sgd, loss='categorical_crossentropy', metrics=['accuracy'])
# we train our model again (this time fine-tuning the top 2 inception blocks
# alongside the top Dense layers
self.classifier.fit_generator(...)
self.classifier.fit(X_train, y_train,
batch_size=batch_size,
epochs=epoch,
verbose=1,
validation_data=(X_valid, y_valid),
callbacks=[history, *train_callbacks, earlyStopping])
fbeta_score = self._get_fbeta_score(self.classifier, X_valid, y_valid)
return [history.train_losses, history.val_losses, fbeta_score]
def train_model(self,
x_train,
y_train,
epoch=5,
batch_size=128,
validation_split_size=0.2,
train_callbacks=()):
history = LossHistory()
X_train, X_valid, y_train, y_valid = train_test_split(
x_train, y_train, test_size=validation_split_size)
adam = Adam(lr=0.01, decay=1e-6)
rms = RMSprop(lr=0.0001, decay=1e-6)
self.classifier.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print('X_train.shape[0]')
print(X_train.shape[0])
checkpointer = ModelCheckpoint(filepath="weights.best.hdf5",
verbose=1,
save_best_only=True)
datagen = ImageDataGenerator(
featurewise_center=False, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=
False, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=
0, # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=
0.1, # randomly shift images horizontally (fraction of total width)
height_shift_range=
0.1, # randomly shift images vertically (fraction of total height)
horizontal_flip=True, # randomly flip images
vertical_flip=False) # randomly flip images
datagen.fit(X_train)
self.classifier.fit_generator(
datagen.flow(X_train, y_train, batch_size=batch_size),
steps_per_epoch=X_train.shape[0] // batch_size,
epochs=epoch,
validation_data=(X_valid, y_valid),
callbacks=[history, *train_callbacks, checkpointer])
fbeta_score = self._get_fbeta_score(self.classifier, X_valid, y_valid)
print(fbeta_score)
return [history.train_losses, history.val_losses, fbeta_score]
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_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
def main_fun(args, ctx):
import numpy
import os
import tensorflow as tf
import tensorflow.contrib.keras as keras
from tensorflow.contrib.keras.api.keras import backend as K
from tensorflow.contrib.keras.api.keras.models import Sequential, load_model, save_model
from tensorflow.contrib.keras.api.keras.layers import Dense, Dropout
from tensorflow.contrib.keras.api.keras.optimizers import RMSprop
from tensorflow.contrib.keras.python.keras.callbacks import LambdaCallback, TensorBoard
from tensorflow.python.saved_model import builder as saved_model_builder
from tensorflow.python.saved_model import tag_constants
from tensorflow.python.saved_model.signature_def_utils_impl import predict_signature_def
from tensorflowonspark import TFNode
cluster, server = TFNode.start_cluster_server(ctx)
if ctx.job_name == "ps":
server.join()
elif ctx.job_name == "worker":
def generate_rdd_data(tf_feed, batch_size):
print("generate_rdd_data invoked")
while True:
batch = tf_feed.next_batch(batch_size)
imgs = []
lbls = []
for item in batch:
imgs.append(item[0])
lbls.append(item[1])
images = numpy.array(imgs).astype('float32') / 255
labels = numpy.array(lbls).astype('float32')
yield (images, labels)
with tf.device(
tf.train.replica_device_setter(
worker_device="/job:worker/task:%d" % ctx.task_index,
cluster=cluster)):
IMAGE_PIXELS = 28
batch_size = 100
num_classes = 10
# the data, shuffled and split between train and test sets
if args.input_mode == 'tf':
from tensorflow.contrib.keras.api.keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
else: # args.mode == 'spark'
x_train = tf.placeholder(tf.float32,
[None, IMAGE_PIXELS * IMAGE_PIXELS],
name="x_train")
y_train = tf.placeholder(tf.float32, [None, 10],
name="y_train")
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784, )))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(),
metrics=['accuracy'])
saver = tf.train.Saver()
with tf.Session(server.target) as sess:
K.set_session(sess)
def save_checkpoint(epoch, logs=None):
if epoch == 1:
tf.train.write_graph(sess.graph.as_graph_def(),
args.model_dir, 'graph.pbtxt')
saver.save(sess,
os.path.join(args.model_dir, 'model.ckpt'),
global_step=epoch * args.steps_per_epoch)
ckpt_callback = LambdaCallback(on_epoch_end=save_checkpoint)
tb_callback = TensorBoard(log_dir=args.model_dir,
histogram_freq=1,
write_graph=True,
write_images=True)
# add callbacks to save model checkpoint and tensorboard events (on worker:0 only)
callbacks = [ckpt_callback, tb_callback
] if ctx.task_index == 0 else None
if args.input_mode == 'tf':
# train & validate on in-memory data
history = model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=args.epochs,
verbose=1,
validation_data=(x_test, y_test),
callbacks=callbacks)
else: # args.input_mode == 'spark':
# train on data read from a generator which is producing data from a Spark RDD
tf_feed = TFNode.DataFeed(ctx.mgr)
history = model.fit_generator(
generator=generate_rdd_data(tf_feed, batch_size),
steps_per_epoch=args.steps_per_epoch,
epochs=args.epochs,
verbose=1,
callbacks=callbacks)
if args.export_dir and ctx.job_name == 'worker' and ctx.task_index == 0:
# save a local Keras model, so we can reload it with an inferencing learning_phase
save_model(model, "tmp_model")
# reload the model
K.set_learning_phase(False)
new_model = load_model("tmp_model")
# export a saved_model for inferencing
builder = saved_model_builder.SavedModelBuilder(
args.export_dir)
signature = predict_signature_def(
inputs={'images': new_model.input},
outputs={'scores': new_model.output})
builder.add_meta_graph_and_variables(
sess=sess,
tags=[tag_constants.SERVING],
signature_def_map={'predict': signature},
clear_devices=True)
builder.save()
if args.input_mode == 'spark':
tf_feed.terminate()