def _run(model_file_name, init_function_name, component_type_string,
target_class, layer_name, neuron_indices, channel_index,
ideal_activation, num_iterations, learning_rate, output_file_name):
"""Runs backwards optimization on a trained CNN.
This is effectively the main method.
:param model_file_name: See documentation at top of file.
:param init_function_name: Same.
:param component_type_string: Same.
:param target_class: Same.
:param layer_name: Same.
:param neuron_indices: Same.
:param channel_index: Same.
:param ideal_activation: Same.
:param num_iterations: Same.
:param learning_rate: Same.
:param output_file_name: Same.
"""
model_interpretation.check_component_type(component_type_string)
if ideal_activation <= 0:
ideal_activation = None
print('Reading model from: "{0:s}"...'.format(model_file_name))
model_object = load_keras_model(
model_file_name,
custom_objects={'brier_skill_score_keras': _brier_skill_score_keras})
init_function = _create_initializer(init_function_name)
print(SEPARATOR_STRING)
if component_type_string == CLASS_COMPONENT_TYPE_STRING:
print(
'Optimizing image for target class {0:d}...'.format(target_class))
result_dict = backwards_opt.optimize_input_for_class(
model_object=model_object,
target_class=target_class,
init_function_or_matrices=init_function,
num_iterations=num_iterations,
learning_rate=learning_rate)
elif component_type_string == NEURON_COMPONENT_TYPE_STRING:
print('Optimizing image for neuron {0:s} in layer "{1:s}"...'.format(
str(neuron_indices), layer_name))
result_dict = backwards_opt.optimize_input_for_neuron(
model_object=model_object,
layer_name=layer_name,
neuron_indices=neuron_indices,
init_function_or_matrices=init_function,
num_iterations=num_iterations,
learning_rate=learning_rate,
ideal_activation=ideal_activation)
else:
print('Optimizing image for channel {0:d} in layer "{1:s}"...'.format(
channel_index, layer_name))
result_dict = backwards_opt.optimize_input_for_channel(
model_object=model_object,
layer_name=layer_name,
channel_index=channel_index,
init_function_or_matrices=init_function,
stat_function_for_neuron_activations=K.max,
num_iterations=num_iterations,
learning_rate=learning_rate,
ideal_activation=ideal_activation)
print(SEPARATOR_STRING)
initial_activations = numpy.array(
[result_dict[backwards_opt.INITIAL_ACTIVATION_KEY]])
final_activations = numpy.array(
[result_dict[backwards_opt.FINAL_ACTIVATION_KEY]])
print('Denormalizing input and output (optimized) example...')
denorm_input_matrix = _denormalize_data(
result_dict[backwards_opt.NORM_INPUT_MATRICES_KEY])
denorm_output_matrix = _denormalize_data(
result_dict[backwards_opt.NORM_OUTPUT_MATRICES_KEY])
print('Writing results to: "{0:s}"...'.format(output_file_name))
bwo_metadata_dict = backwards_opt.check_metadata(
component_type_string=component_type_string,
num_iterations=num_iterations,
learning_rate=learning_rate,
target_class=target_class,
layer_name=layer_name,
ideal_activation=ideal_activation,
neuron_indices=neuron_indices,
channel_index=channel_index,
l2_weight=None,
radar_constraint_weight=None,
minmax_constraint_weight=None)
backwards_opt.write_standard_file(
pickle_file_name=output_file_name,
denorm_input_matrices=[denorm_input_matrix],
denorm_output_matrices=[denorm_output_matrix],
initial_activations=initial_activations,
final_activations=final_activations,
model_file_name=model_file_name,
metadata_dict=bwo_metadata_dict,
full_storm_id_strings=None,
storm_times_unix_sec=None,
sounding_pressure_matrix_pa=None)
def _run(model_file_name, init_function_name, component_type_string,
target_class, layer_name, neuron_indices, channel_index,
ideal_activation, num_iterations, learning_rate, output_file_name):
"""Runs backwards optimization on a trained CNN.
This is effectively the main method.
:param model_file_name: See documentation at top of file.
:param init_function_name: Same.
:param component_type_string: Same.
:param target_class: Same.
:param layer_name: Same.
:param neuron_indices: Same.
:param channel_index: Same.
:param ideal_activation: Same.
:param num_iterations: Same.
:param learning_rate: Same.
:param output_file_name: Same.
"""
model_interpretation.check_component_type(component_type_string)
if ideal_activation <= 0:
ideal_activation = None
print('Reading model from: "{0:s}"...'.format(model_file_name))
custom_dict = {'brier_skill_score_keras': _brier_skill_score_keras}
model_object = load_keras_model(model_file_name, custom_objects=custom_dict)
init_function = _create_initializer(init_function_name)
print(SEPARATOR_STRING)
if component_type_string == CLASS_COMPONENT_TYPE_STRING:
print('Optimizing image for target class {0:d}...'.format(target_class))
list_of_optimized_matrices, initial_activation, final_activation = (
backwards_opt.optimize_input_for_class(
model_object=model_object, target_class=target_class,
init_function_or_matrices=init_function,
num_iterations=num_iterations, learning_rate=learning_rate)
)
elif component_type_string == NEURON_COMPONENT_TYPE_STRING:
print('Optimizing image for neuron {0:s} in layer "{1:s}"...'.format(
str(neuron_indices), layer_name
))
list_of_optimized_matrices, initial_activation, final_activation = (
backwards_opt.optimize_input_for_neuron(
model_object=model_object, layer_name=layer_name,
neuron_indices=neuron_indices,
init_function_or_matrices=init_function,
num_iterations=num_iterations, learning_rate=learning_rate,
ideal_activation=ideal_activation)
)
else:
print('Optimizing image for channel {0:d} in layer "{1:s}"...'.format(
channel_index, layer_name))
list_of_optimized_matrices, initial_activation, final_activation = (
backwards_opt.optimize_input_for_channel(
model_object=model_object, layer_name=layer_name,
channel_index=channel_index,
init_function_or_matrices=init_function,
stat_function_for_neuron_activations=K.max,
num_iterations=num_iterations, learning_rate=learning_rate,
ideal_activation=ideal_activation)
)
print(SEPARATOR_STRING)
print('Denormalizing optimized examples...')
list_of_optimized_matrices[0] = _denormalize_data(
list_of_optimized_matrices[0]
)
print('Writing results to: "{0:s}"...'.format(output_file_name))
backwards_opt.write_standard_file(
pickle_file_name=output_file_name,
list_of_optimized_matrices=list_of_optimized_matrices,
initial_activations=numpy.array([initial_activation]),
final_activations=numpy.array([final_activation]),
model_file_name=model_file_name,
init_function_name_or_matrices=init_function_name,
num_iterations=num_iterations, learning_rate=learning_rate,
component_type_string=component_type_string, target_class=target_class,
layer_name=layer_name, neuron_indices=neuron_indices,
channel_index=channel_index, ideal_activation=ideal_activation)
def _run(model_file_name, init_function_name, storm_metafile_name,
num_examples, top_example_dir_name, component_type_string,
target_class, layer_name, neuron_indices, channel_index,
num_iterations, ideal_activation, learning_rate, l2_weight,
radar_constraint_weight, minmax_constraint_weight, output_file_name):
"""Runs backwards optimization on a trained CNN.
This is effectively the main method.
:param model_file_name: See documentation at top of file.
:param init_function_name: Same.
:param storm_metafile_name: Same.
:param num_examples: Same.
:param top_example_dir_name: Same.
:param component_type_string: Same.
:param target_class: Same.
:param layer_name: Same.
:param neuron_indices: Same.
:param channel_index: Same.
:param num_iterations: Same.
:param ideal_activation: Same.
:param learning_rate: Same.
:param l2_weight: Same.
:param radar_constraint_weight: Same.
:param minmax_constraint_weight: Same.
:param output_file_name: Same.
"""
if l2_weight <= 0:
l2_weight = None
if radar_constraint_weight <= 0:
radar_constraint_weight = None
if minmax_constraint_weight <= 0:
minmax_constraint_weight = None
if ideal_activation <= 0:
ideal_activation = None
if init_function_name in ['', 'None']:
init_function_name = None
model_interpretation.check_component_type(component_type_string)
model_metafile_name = '{0:s}/model_metadata.p'.format(
os.path.split(model_file_name)[0])
print(
'Reading model metadata from: "{0:s}"...'.format(model_metafile_name))
model_metadata_dict = cnn.read_model_metadata(model_metafile_name)
input_matrices = None
init_function = None
full_storm_id_strings = None
storm_times_unix_sec = None
sounding_pressure_matrix_pa = None
if init_function_name is None:
print('Reading storm metadata from: "{0:s}"...'.format(
storm_metafile_name))
full_storm_id_strings, storm_times_unix_sec = (
tracking_io.read_ids_and_times(storm_metafile_name))
if 0 < num_examples < len(full_storm_id_strings):
full_storm_id_strings = full_storm_id_strings[:num_examples]
storm_times_unix_sec = storm_times_unix_sec[:num_examples]
example_dict = testing_io.read_predictors_specific_examples(
top_example_dir_name=top_example_dir_name,
desired_full_id_strings=full_storm_id_strings,
desired_times_unix_sec=storm_times_unix_sec,
option_dict=model_metadata_dict[cnn.TRAINING_OPTION_DICT_KEY],
layer_operation_dicts=model_metadata_dict[
cnn.LAYER_OPERATIONS_KEY])
print(SEPARATOR_STRING)
input_matrices = example_dict[testing_io.INPUT_MATRICES_KEY]
sounding_pressure_matrix_pa = example_dict[
testing_io.SOUNDING_PRESSURES_KEY]
num_examples = input_matrices[0].shape[0]
else:
num_examples = 1
init_function = _create_initializer(
init_function_name=init_function_name,
model_metadata_dict=model_metadata_dict)
print('Reading model from: "{0:s}"...'.format(model_file_name))
model_object = cnn.read_model(model_file_name)
output_matrices = None
initial_activations = numpy.full(num_examples, numpy.nan)
final_activations = numpy.full(num_examples, numpy.nan)
for i in range(num_examples):
if init_function_name is None:
this_init_arg = [a[[i], ...] for a in input_matrices]
else:
this_init_arg = init_function
if component_type_string == CLASS_COMPONENT_TYPE_STRING:
print((
'\nOptimizing {0:d}th of {1:d} images for target class {2:d}...'
).format(i + 1, num_examples, target_class))
this_result_dict = backwards_opt.optimize_input_for_class(
model_object=model_object,
target_class=target_class,
init_function_or_matrices=this_init_arg,
num_iterations=num_iterations,
learning_rate=learning_rate,
l2_weight=l2_weight,
radar_constraint_weight=radar_constraint_weight,
minmax_constraint_weight=minmax_constraint_weight,
model_metadata_dict=model_metadata_dict)
elif component_type_string == NEURON_COMPONENT_TYPE_STRING:
print((
'\nOptimizing {0:d}th of {1:d} images for neuron {2:s} in layer'
' "{3:s}"...').format(i + 1, num_examples, str(neuron_indices),
layer_name))
this_result_dict = backwards_opt.optimize_input_for_neuron(
model_object=model_object,
layer_name=layer_name,
neuron_indices=neuron_indices,
init_function_or_matrices=this_init_arg,
num_iterations=num_iterations,
learning_rate=learning_rate,
l2_weight=l2_weight,
ideal_activation=ideal_activation,
radar_constraint_weight=radar_constraint_weight,
minmax_constraint_weight=minmax_constraint_weight,
model_metadata_dict=model_metadata_dict)
else:
print(('\nOptimizing {0:d}th of {1:d} images for channel {2:d} in '
'layer "{3:s}"...').format(i + 1, num_examples,
channel_index, layer_name))
this_result_dict = backwards_opt.optimize_input_for_channel(
model_object=model_object,
layer_name=layer_name,
channel_index=channel_index,
init_function_or_matrices=this_init_arg,
stat_function_for_neuron_activations=K.max,
num_iterations=num_iterations,
learning_rate=learning_rate,
l2_weight=l2_weight,
ideal_activation=ideal_activation,
radar_constraint_weight=radar_constraint_weight,
minmax_constraint_weight=minmax_constraint_weight,
model_metadata_dict=model_metadata_dict)
initial_activations[i] = this_result_dict[
backwards_opt.INITIAL_ACTIVATION_KEY]
final_activations[i] = this_result_dict[
backwards_opt.FINAL_ACTIVATION_KEY]
these_output_matrices = this_result_dict[
backwards_opt.NORM_OUTPUT_MATRICES_KEY]
if output_matrices is None:
output_matrices = [None] * len(these_output_matrices)
for k in range(len(output_matrices)):
if output_matrices[k] is None:
output_matrices[k] = these_output_matrices[k] + 0.
else:
output_matrices[k] = numpy.concatenate(
(output_matrices[k], these_output_matrices[k]), axis=0)
if init_function_name is None:
continue
these_input_matrices = this_result_dict[
backwards_opt.NORM_INPUT_MATRICES_KEY]
if input_matrices is None:
input_matrices = [None] * len(these_input_matrices)
for k in range(len(input_matrices)):
if input_matrices[k] is None:
input_matrices[k] = these_input_matrices[k] + 0.
else:
input_matrices[k] = numpy.concatenate(
(input_matrices[k], these_input_matrices[k]), axis=0)
print(SEPARATOR_STRING)
training_option_dict = model_metadata_dict[cnn.TRAINING_OPTION_DICT_KEY]
print('Denormalizing input examples...')
input_matrices = trainval_io.separate_shear_and_reflectivity(
list_of_input_matrices=input_matrices,
training_option_dict=training_option_dict)
input_matrices = model_interpretation.denormalize_data(
list_of_input_matrices=input_matrices,
model_metadata_dict=model_metadata_dict)
print('Denormalizing optimized examples...')
output_matrices = trainval_io.separate_shear_and_reflectivity(
list_of_input_matrices=output_matrices,
training_option_dict=training_option_dict)
output_matrices = model_interpretation.denormalize_data(
list_of_input_matrices=output_matrices,
model_metadata_dict=model_metadata_dict)
print('Writing results to: "{0:s}"...'.format(output_file_name))
bwo_metadata_dict = backwards_opt.check_metadata(
component_type_string=component_type_string,
num_iterations=num_iterations,
learning_rate=learning_rate,
target_class=target_class,
layer_name=layer_name,
ideal_activation=ideal_activation,
neuron_indices=neuron_indices,
channel_index=channel_index,
l2_weight=l2_weight,
radar_constraint_weight=radar_constraint_weight,
minmax_constraint_weight=minmax_constraint_weight)
backwards_opt.write_standard_file(
pickle_file_name=output_file_name,
denorm_input_matrices=input_matrices,
denorm_output_matrices=output_matrices,
initial_activations=initial_activations,
final_activations=final_activations,
model_file_name=model_file_name,
metadata_dict=bwo_metadata_dict,
full_storm_id_strings=full_storm_id_strings,
storm_times_unix_sec=storm_times_unix_sec,
sounding_pressure_matrix_pa=sounding_pressure_matrix_pa)
def _run(model_file_name, init_function_name, storm_metafile_name,
num_examples, top_example_dir_name, component_type_string,
target_class, layer_name, neuron_indices, channel_index,
num_iterations, ideal_activation, learning_rate, output_file_name):
"""Runs backwards optimization on a trained CNN.
This is effectively the main method.
:param model_file_name: See documentation at top of file.
:param init_function_name: Same.
:param storm_metafile_name: Same.
:param num_examples: Same.
:param top_example_dir_name: Same.
:param component_type_string: Same.
:param target_class: Same.
:param layer_name: Same.
:param neuron_indices: Same.
:param channel_index: Same.
:param num_iterations: Same.
:param ideal_activation: Same.
:param learning_rate: Same.
:param output_file_name: Same.
"""
model_interpretation.check_component_type(component_type_string)
if ideal_activation <= 0:
ideal_activation = None
if init_function_name in ['', 'None']:
init_function_name = None
model_metafile_name = '{0:s}/model_metadata.p'.format(
os.path.split(model_file_name)[0])
print 'Reading model metadata from: "{0:s}"...'.format(model_metafile_name)
model_metadata_dict = cnn.read_model_metadata(model_metafile_name)
if init_function_name is None:
print 'Reading storm metadata from: "{0:s}"...'.format(
storm_metafile_name)
storm_ids, storm_times_unix_sec = tracking_io.read_ids_and_times(
storm_metafile_name)
if 0 < num_examples < len(storm_ids):
storm_ids = storm_ids[:num_examples]
storm_times_unix_sec = storm_times_unix_sec[:num_examples]
list_of_init_matrices = testing_io.read_specific_examples(
desired_storm_ids=storm_ids,
desired_times_unix_sec=storm_times_unix_sec,
option_dict=model_metadata_dict[cnn.TRAINING_OPTION_DICT_KEY],
top_example_dir_name=top_example_dir_name,
list_of_layer_operation_dicts=model_metadata_dict[
cnn.LAYER_OPERATIONS_KEY])[0]
num_examples = list_of_init_matrices[0].shape[0]
print SEPARATOR_STRING
else:
storm_ids = None
storm_times_unix_sec = None
num_examples = 1
init_function = _create_initializer(
init_function_name=init_function_name,
model_metadata_dict=model_metadata_dict)
print 'Reading model from: "{0:s}"...'.format(model_file_name)
model_object = cnn.read_model(model_file_name)
list_of_optimized_matrices = None
for i in range(num_examples):
if init_function_name is None:
this_init_arg = [a[[i], ...] for a in list_of_init_matrices]
else:
this_init_arg = init_function
if component_type_string == CLASS_COMPONENT_TYPE_STRING:
print(
'\nOptimizing {0:d}th of {1:d} images for target class {2:d}...'
).format(i + 1, num_examples, target_class)
these_optimized_matrices = backwards_opt.optimize_input_for_class(
model_object=model_object,
target_class=target_class,
init_function_or_matrices=this_init_arg,
num_iterations=num_iterations,
learning_rate=learning_rate)
elif component_type_string == NEURON_COMPONENT_TYPE_STRING:
print(
'\nOptimizing {0:d}th of {1:d} images for neuron {2:s} in layer'
' "{3:s}"...').format(i + 1, num_examples, str(neuron_indices),
layer_name)
these_optimized_matrices = backwards_opt.optimize_input_for_neuron(
model_object=model_object,
layer_name=layer_name,
neuron_indices=neuron_indices,
init_function_or_matrices=this_init_arg,
num_iterations=num_iterations,
learning_rate=learning_rate,
ideal_activation=ideal_activation)
else:
print(
'\nOptimizing {0:d}th of {1:d} images for channel {2:d} in '
'layer "{3:s}"...').format(i + 1, num_examples, channel_index,
layer_name)
these_optimized_matrices = backwards_opt.optimize_input_for_channel(
model_object=model_object,
layer_name=layer_name,
channel_index=channel_index,
init_function_or_matrices=this_init_arg,
stat_function_for_neuron_activations=K.max,
num_iterations=num_iterations,
learning_rate=learning_rate,
ideal_activation=ideal_activation)
if list_of_optimized_matrices is None:
num_matrices = len(these_optimized_matrices)
list_of_optimized_matrices = [None] * num_matrices
for k in range(len(list_of_optimized_matrices)):
if list_of_optimized_matrices[k] is None:
list_of_optimized_matrices[
k] = these_optimized_matrices[k] + 0.
else:
list_of_optimized_matrices[k] = numpy.concatenate(
(list_of_optimized_matrices[k],
these_optimized_matrices[k]),
axis=0)
print SEPARATOR_STRING
print 'Denormalizing optimized examples...'
list_of_optimized_matrices = model_interpretation.denormalize_data(
list_of_input_matrices=list_of_optimized_matrices,
model_metadata_dict=model_metadata_dict)
if init_function_name is None:
print 'Denormalizing input examples...'
list_of_init_matrices = model_interpretation.denormalize_data(
list_of_input_matrices=list_of_init_matrices,
model_metadata_dict=model_metadata_dict)
this_init_arg = list_of_init_matrices
else:
this_init_arg = init_function_name + ''
print 'Writing results to: "{0:s}"...'.format(output_file_name)
backwards_opt.write_standard_file(
pickle_file_name=output_file_name,
list_of_optimized_matrices=list_of_optimized_matrices,
model_file_name=model_file_name,
init_function_name_or_matrices=this_init_arg,
num_iterations=num_iterations,
learning_rate=learning_rate,
component_type_string=component_type_string,
target_class=target_class,
layer_name=layer_name,
neuron_indices=neuron_indices,
channel_index=channel_index,
ideal_activation=ideal_activation,
storm_ids=storm_ids,
storm_times_unix_sec=storm_times_unix_sec)
def _run(model_file_name, example_file_name, num_examples, example_indices,
component_type_string, target_class, layer_name, ideal_activation,
neuron_indices, channel_index, num_iterations, learning_rate,
output_file_name):
"""Runs backwards optimization on a trained CNN.
This is effectively the main method.
:param model_file_name: See documentation at top of file.
:param example_file_name: Same.
:param num_examples: Same.
:param example_indices: Same.
:param component_type_string: Same.
:param target_class: Same.
:param layer_name: Same.
:param ideal_activation: Same.
:param neuron_indices: Same.
:param channel_index: Same.
:param num_iterations: Same.
:param learning_rate: Same.
:param output_file_name: Same.
"""
if num_examples <= 0:
num_examples = None
print 'Reading model from: "{0:s}"...'.format(model_file_name)
model_object = traditional_cnn.read_keras_model(model_file_name)
model_metafile_name = traditional_cnn.find_metafile(
model_file_name=model_file_name)
print 'Reading model metadata from: "{0:s}"...'.format(model_metafile_name)
model_metadata_dict = traditional_cnn.read_model_metadata(
model_metafile_name)
print 'Reading normalized examples from: "{0:s}"...'.format(
example_file_name)
example_dict = trainval_io.read_downsized_3d_examples(
netcdf_file_name=example_file_name,
predictor_names_to_keep=model_metadata_dict[
traditional_cnn.NARR_PREDICTOR_NAMES_KEY],
num_half_rows_to_keep=model_metadata_dict[
traditional_cnn.NUM_ROWS_IN_HALF_GRID_KEY],
num_half_columns_to_keep=model_metadata_dict[
traditional_cnn.NUM_COLUMNS_IN_HALF_GRID_KEY])
predictor_matrix = example_dict[trainval_io.PREDICTOR_MATRIX_KEY]
if num_examples is None:
error_checking.assert_is_geq_numpy_array(example_indices, 0)
num_examples = len(example_indices)
else:
error_checking.assert_is_greater(num_examples, 0)
num_examples_total = predictor_matrix.shape[0]
example_indices = numpy.linspace(0,
num_examples_total - 1,
num=num_examples_total,
dtype=int)
num_examples = min([num_examples, num_examples_total])
example_indices = numpy.random.choice(example_indices,
size=num_examples,
replace=False)
predictor_matrix = predictor_matrix[example_indices, ...]
optimized_predictor_matrix = numpy.full(predictor_matrix.shape, numpy.nan)
print SEPARATOR_STRING
for i in range(num_examples):
if component_type_string == CLASS_COMPONENT_TYPE_STRING:
print(
'Optimizing {0:d}th of {1:d} images for target class {2:d}...'
).format(i + 1, num_examples, target_class)
optimized_predictor_matrix[i, ...] = (
backwards_opt.optimize_input_for_class(
model_object=model_object,
target_class=target_class,
init_function_or_matrices=[predictor_matrix[[i], ...]],
num_iterations=num_iterations,
learning_rate=learning_rate)[0])
elif component_type_string == NEURON_COMPONENT_TYPE_STRING:
print(
'Optimizing {0:d}th of {1:d} images for neuron {2:s} in layer '
'"{3:s}"...').format(i + 1, num_examples, str(neuron_indices),
layer_name)
optimized_predictor_matrix[i, ...] = (
backwards_opt.optimize_input_for_neuron(
model_object=model_object,
layer_name=layer_name,
neuron_indices=neuron_indices,
init_function_or_matrices=[predictor_matrix[[i], ...]],
num_iterations=num_iterations,
learning_rate=learning_rate,
ideal_activation=ideal_activation)[0])
else:
print(
'Optimizing {0:d}th of {1:d} images for channel {2:d} in layer '
'"{3:s}"...').format(i + 1, num_examples, channel_index,
layer_name)
optimized_predictor_matrix[i, ...] = (
backwards_opt.optimize_input_for_channel(
model_object=model_object,
layer_name=layer_name,
channel_index=channel_index,
init_function_or_matrices=[predictor_matrix[[i], ...]],
stat_function_for_neuron_activations=K.max,
num_iterations=num_iterations,
learning_rate=learning_rate,
ideal_activation=ideal_activation)[0])
print SEPARATOR_STRING
print 'Writing results to: "{0:s}"...'.format(output_file_name)
backwards_opt.write_results(
pickle_file_name=output_file_name,
list_of_optimized_input_matrices=[optimized_predictor_matrix],
model_file_name=model_file_name,
init_function_name_or_matrices=[predictor_matrix],
num_iterations=num_iterations,
learning_rate=learning_rate,
component_type_string=component_type_string,
target_class=target_class,
layer_name=layer_name,
neuron_indices=neuron_indices,
channel_index=channel_index,
ideal_activation=ideal_activation)