def evaluate(self):
begin = datetime.now()
current_time = begin.strftime("%H:%M:%S")
print("*** estimation begin time***:", current_time)
epochs = self.config['epochs']
batch_round = utili.get_table_value(self.config, 'batch_round')
x_train, y_train = self.data_manager.get_training_data()
x_test, y_test = self.data_manager.get_test_data()
task_num = self.data_manager.get_task_num()
self.model_manager.compile()
if self.config['print_summary']:
print(self.model_manager.get_summary())
if not self.config['train_model']:
return
if batch_round:
round_size = utili.get_table_value(self.config, 'round_size', 10)
total_size = (epochs + round_size - 1) // round_size
for i in range(total_size):
self._evaluate(x_train, y_train, x_test, y_test, round_size, i)
else:
self._evaluate(x_train, y_train, x_test, y_test, epochs)
end = datetime.now()
current_time = end.strftime("%H:%M:%S")
print("***end time***:", current_time)
print("total estimation time cost:", end - begin)
print("========================done==========================")
def save_model(self, suffix=""):
save_model_name = utili.get_table_value(self.config, 'save_model_name')
if save_model_name:
save_model_name + suffix
save_path = utili.get_table_value(self.config, 'save_path', './')
save_name = save_path + '/' + save_model_name
self.context['model'].save(save_name + '.h5')
model = self.context['model']
self.context['model'] = None
store = {
'config': self.config,
'data_manager_info': self.data_manager.get_encode_info(),
'name': self.config['name']
}
utili.save_obj(store, save_name)
self.context['model'] = model
def _create_main_path(self, lastLayer):
pooling_strides = self.config['pooling_strides']
pool_size = self.config['pool_size']
layer_len = self.config['layer_len']
conv_len = self.config['conv_len']
conv_strides = utili.get_table_value(self.config, 'conv_strides', 1)
conv_kernel_width = self.config['conv_kernel_width']
delta = self.config['filter_delta']
pool_interval = utili.get_table_value(self.config, 'pool_inverval', 2)
drop_out_rate = utili.get_table_value(self.config, 'drop_out_rate', 0.2)
start_width = utili.get_table_value(self.config, 'start_width', 48)
for i in range(layer_len):
for j in range(conv_len):
lastLayer = Conv1D(start_width +delta * j, conv_kernel_width, strides=conv_strides,padding='same', activation='relu')(lastLayer)
if j % pool_interval == 0:
lastLayer = Dropout(drop_out_rate)(lastLayer)
lastLayer = MaxPooling1D(pool_size=pool_size, strides=pooling_strides, padding='same')(lastLayer)
lastLayer = Flatten()(lastLayer)
lastLayer = Dropout(drop_out_rate)(lastLayer)
return lastLayer
def _create_end(self, input_layer, lastLayer):
last_activation = utili.get_table_value(self.config,'last_activation', 'sigmoid')
print('last_activation:', last_activation)
output = []
task_loss_num = 1
train_target = None
test_target = None
for i in range(self.data_manager.get_task_num()):
task_lastLayer = Dense(self.config['hidden_width'], activation='relu')(lastLayer)
task_lastLayer = Dense(self.config['hidden_width'], activation='relu')(lastLayer)
task_lastLayer = Dense(self.data_manager.get_max_category()[i], activation=last_activation, name="task_%d_1" % i)(task_lastLayer)
output.append(task_lastLayer)
model = Model(inputs=input_layer, outputs=output)
return model
def _create_main_path(self, lastLayer):
dense_type = utili.get_table_value(self.config, 'dense_type', 'd121')
dense_k = utili.get_table_value(self.config, 'dense_k', 12)
conv_kernel_width = utili.get_table_value(self.config,
'conv_kernel_width', 3)
bottleneck_size = utili.get_table_value(self.config, 'bottleneck_size',
1)
transition_pool_size = utili.get_table_value(self.config,
'transition_pool_size', 2)
transition_pool_stride = utili.get_table_value(
self.config, 'transition_pool_stride', 1)
theta = utili.get_table_value(self.config, 'theta', 1)
initial_conv_width = utili.get_table_value(self.config,
'initial_conv_width', 3)
initial_stride = utili.get_table_value(self.config, 'initial_stride',
1)
initial_filters = utili.get_table_value(self.config, 'initial_filters',
48)
initial_pool_width = utili.get_table_value(self.config,
'initial_pool_width', 2)
initial_pool_stride = utili.get_table_value(self.config,
'initial_pool_stride', 1)
use_global_pooling = utili.get_table_value(self.config,
'use_global_pooling', False)
#it can be d121,d169,d201 or d264
if dense_type == 'd121':
lastLayer = dense_net.DenseNet121(
dense_k, conv_kernel_width, bottleneck_size,
transition_pool_size, transition_pool_stride, theta,
initial_conv_width, initial_stride, initial_filters,
initial_pool_width, initial_pool_stride,
use_global_pooling)(lastLayer)
elif dense_type == 'd169':
lastLayer = dense_net.DenseNet169(
dense_k, conv_kernel_width, bottleneck_size,
transition_pool_size, transition_pool_stride, theta,
initial_conv_width, initial_stride, initial_filters,
initial_pool_width, initial_pool_stride,
use_global_pooling)(lastLayer)
elif dense_type == 'd201':
lastLayer = dense_net.DenseNet201(
dense_k, conv_kernel_width, bottleneck_size,
transition_pool_size, transition_pool_stride, theta,
initial_conv_width, initial_stride, initial_filters,
initial_pool_width, initial_pool_stride,
use_global_pooling)(lastLayer)
elif dense_type == 'd264':
lastLayer = dense_net.DenseNet264(
dense_k, conv_kernel_width, bottleneck_size,
transition_pool_size, transition_pool_stride, theta,
initial_conv_width, initial_stride, initial_filters,
initial_pool_width, initial_pool_stride,
use_global_pooling)(lastLayer)
lastLayer = Flatten()(lastLayer)
return lastLayer