std::pair<testing_result_smart_ptr, training_stat_smart_ptr> network_updater::update(
supervised_data_reader& reader,
const std::vector<std::vector<float> >& learning_rates,
network_data_smart_ptr data,
unsigned int batch_size,
float weight_decay,
float momentum,
const std::map<unsigned int, float>& layer_to_dropout_rate_map)
{
// Check data-schema consistency
data->check_network_data_consistency(*schema);
set_input_configuration_specific(reader.get_input_configuration());
// Check schema-reader consistency
layer_config_list[layer_config_list.size() - 1].check_equality(reader.get_output_configuration());
nnforge_uniform_real_distribution<float> dist(0.0F, 1.0F);
for(std::vector<float>::iterator it = random_uniform_list.begin(); it != random_uniform_list.end(); ++it)
*it = dist(gen);
std::pair<testing_result_smart_ptr, training_stat_smart_ptr> res = actual_update(reader, learning_rates, data, batch_size, weight_decay, momentum, layer_to_dropout_rate_map);
return res;
}
network_data_smart_ptr hessian_calculator::get_hessian(
unsupervised_data_reader& reader,
network_data_smart_ptr data,
unsigned int hessian_entry_to_process_count)
{
set_input_configuration_specific(reader.get_input_configuration());
// Check data-schema consistency
data->check_network_data_consistency(*schema);
return actual_get_hessian(
reader,
data,
hessian_entry_to_process_count);
}
backward_propagation::stat backward_propagation::run(
structured_data_bunch_reader& reader,
structured_data_bunch_writer& writer,
network_data& data,
network_data::ptr momentum_data,
network_data::ptr momentum_data2,
const std::map<std::string, std::vector<float> >& learning_rates,
unsigned int batch_size,
float weight_decay,
training_momentum momentum,
unsigned int epoch_id)
{
backward_propagation::stat res;
// Check data-schema consistency
data.check_network_data_consistency(schema->get_layers());
std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
set_input_configuration_specific(reader.get_config_map());
structured_data_bunch_reader::ptr narrow_reader = reader.get_narrow_reader(data_layer_names);
res.flops_per_entry = flops;
std::vector<std::string> data_layer_name_list(data_layer_names.begin(), data_layer_names.end());
std::map<std::string, layer_configuration_specific> output_config_map;
for(std::vector<std::string>::const_iterator it = output_layer_names.begin(); it != output_layer_names.end(); ++it)
output_config_map[*it] = layer_config_map[*it];
writer.set_config_map(output_config_map);
std::map<layer_name_with_action, float> action_seconds;
actual_run(
narrow_reader ? *narrow_reader : reader,
writer,
data,
momentum_data,
momentum_data2,
learning_rates,
batch_size,
weight_decay,
momentum,
epoch_id,
res.average_absolute_updates,
res.entry_processed_count,
action_seconds);
std::chrono::duration<float> sec = std::chrono::high_resolution_clock::now() - start;
res.total_seconds = sec.count();
if (profile->is_profile() && !action_seconds.empty())
{
std::map<std::string, std::string> layer_name_to_layer_type_map;
std::vector<layer::const_ptr> layer_list = schema->get_layers();
for(std::vector<layer::const_ptr>::const_iterator it = layer_list.begin(); it != layer_list.end(); ++it)
layer_name_to_layer_type_map.insert(std::make_pair((*it)->instance_name, (*it)->get_type_name()));
profile_util::dump_layer_action_performance(
profile,
get_max_flops(),
"backward_prop",
res.entry_processed_count,
action_flops_per_entry,
action_seconds,
layer_name_to_layer_type_map,
res.total_seconds);
}
return res;
}
