def _augment_eval_table(result_table_xarray):
"""Augments evaluation table.
Specifically, adds number of examples and actual values for each target
variable.
:param result_table_xarray: Table returned by `evaluation.read_file`.
:return: result_table_xarray: Same but with number of examples and actual
values for each target variable.
"""
prediction_file_name = (
result_table_xarray.attrs[evaluation.PREDICTION_FILE_KEY])
print('Reading data from: "{0:s}"...'.format(prediction_file_name))
prediction_dict = prediction_io.read_file(prediction_file_name)
num_examples = len(prediction_dict[prediction_io.EXAMPLE_IDS_KEY])
result_table_xarray.attrs[NUM_EXAMPLES_KEY] = num_examples
scalar_target_matrix = prediction_dict[prediction_io.SCALAR_TARGETS_KEY]
these_dim = (EXAMPLE_DIM, evaluation.SCALAR_FIELD_DIM)
result_table_xarray.update(
{SCALAR_TARGET_KEY: (these_dim, scalar_target_matrix)})
vector_target_matrix = prediction_dict[prediction_io.VECTOR_TARGETS_KEY]
these_dim = (EXAMPLE_DIM, evaluation.HEIGHT_DIM,
evaluation.VECTOR_FIELD_DIM)
result_table_xarray.update(
{VECTOR_TARGET_KEY: (these_dim, vector_target_matrix)})
try:
_ = result_table_xarray.coords[evaluation.AUX_TARGET_FIELD_DIM].values
except KeyError:
return result_table_xarray
example_dict = {
example_utils.SCALAR_TARGET_NAMES_KEY:
numpy.array(result_table_xarray.coords[
evaluation.SCALAR_FIELD_DIM].values).tolist(),
example_utils.VECTOR_TARGET_NAMES_KEY:
numpy.array(result_table_xarray.coords[
evaluation.VECTOR_FIELD_DIM].values).tolist(),
example_utils.HEIGHTS_KEY:
numpy.round(result_table_xarray.coords[
evaluation.HEIGHT_DIM].values).astype(int)
}
aux_target_matrix = evaluation.get_aux_fields(
prediction_dict=prediction_dict,
example_dict=example_dict)[evaluation.AUX_TARGET_VALS_KEY]
these_dim = (EXAMPLE_DIM, evaluation.AUX_TARGET_FIELD_DIM)
result_table_xarray.update(
{AUX_TARGET_KEY: (these_dim, aux_target_matrix)})
return result_table_xarray
def _run(input_file_name, use_pmm, max_pmm_percentile_level, output_file_name):
"""Averages predicted and target values over many examples.
This is effectively the main method.
:param input_file_name: See documentation at top of file.
:param use_pmm: Same.
:param max_pmm_percentile_level: Same.
:param output_file_name: Same.
"""
print((
'Reading predicted and target values for each example from: "{0:s}"...'
).format(input_file_name))
prediction_dict = prediction_io.read_file(input_file_name)
num_examples = prediction_dict[prediction_io.VECTOR_TARGETS_KEY].shape[0]
print('Averaging {0:d} examples...'.format(num_examples))
mean_prediction_dict = prediction_io.average_predictions(
prediction_dict=prediction_dict,
use_pmm=use_pmm,
max_pmm_percentile_level=max_pmm_percentile_level)
example_id_strings = [example_utils.get_dummy_example_id()]
print(example_id_strings)
print('Writing mean example to: "{0:s}"...'.format(output_file_name))
prediction_io.write_file(
netcdf_file_name=output_file_name,
scalar_target_matrix=mean_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=mean_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=mean_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=mean_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=mean_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=example_id_strings,
model_file_name=mean_prediction_dict[prediction_io.MODEL_FILE_KEY])
def _run(evaluation_file_names, line_styles, line_colour_strings,
set_descriptions_verbose, confidence_level, use_log_scale,
plot_by_height, output_dir_name):
"""Plots model evaluation.
This is effectively the main method.
:param evaluation_file_names: See documentation at top of file.
:param line_styles: Same.
:param line_colour_strings: Same.
:param set_descriptions_verbose: Same.
:param confidence_level: Same.
:param use_log_scale: Same.
:param plot_by_height: Same.
:param output_dir_name: Same.
"""
# Check input args.
file_system_utils.mkdir_recursive_if_necessary(
directory_name=output_dir_name)
if confidence_level < 0:
confidence_level = None
if confidence_level is not None:
error_checking.assert_is_geq(confidence_level, 0.9)
error_checking.assert_is_less_than(confidence_level, 1.)
num_evaluation_sets = len(evaluation_file_names)
expected_dim = numpy.array([num_evaluation_sets], dtype=int)
error_checking.assert_is_string_list(line_styles)
error_checking.assert_is_numpy_array(numpy.array(line_styles),
exact_dimensions=expected_dim)
error_checking.assert_is_string_list(set_descriptions_verbose)
error_checking.assert_is_numpy_array(numpy.array(set_descriptions_verbose),
exact_dimensions=expected_dim)
set_descriptions_verbose = [
s.replace('_', ' ') for s in set_descriptions_verbose
]
set_descriptions_abbrev = [
s.lower().replace(' ', '-') for s in set_descriptions_verbose
]
error_checking.assert_is_string_list(line_colour_strings)
error_checking.assert_is_numpy_array(numpy.array(line_colour_strings),
exact_dimensions=expected_dim)
line_colours = [
numpy.fromstring(s, dtype=float, sep='_') / 255
for s in line_colour_strings
]
for i in range(num_evaluation_sets):
error_checking.assert_is_numpy_array(line_colours[i],
exact_dimensions=numpy.array(
[3], dtype=int))
error_checking.assert_is_geq_numpy_array(line_colours[i], 0.)
error_checking.assert_is_leq_numpy_array(line_colours[i], 1.)
# Read files.
evaluation_tables_xarray = [xarray.Dataset()] * num_evaluation_sets
prediction_dicts = [dict()] * num_evaluation_sets
for i in range(num_evaluation_sets):
print('Reading data from: "{0:s}"...'.format(evaluation_file_names[i]))
evaluation_tables_xarray[i] = evaluation.read_file(
evaluation_file_names[i])
this_prediction_file_name = (
evaluation_tables_xarray[i].attrs[evaluation.PREDICTION_FILE_KEY])
print(
'Reading data from: "{0:s}"...'.format(this_prediction_file_name))
prediction_dicts[i] = prediction_io.read_file(
this_prediction_file_name)
model_file_name = (
evaluation_tables_xarray[0].attrs[evaluation.MODEL_FILE_KEY])
model_metafile_name = neural_net.find_metafile(
model_dir_name=os.path.split(model_file_name)[0],
raise_error_if_missing=True)
print('Reading metadata from: "{0:s}"...'.format(model_metafile_name))
model_metadata_dict = neural_net.read_metafile(model_metafile_name)
generator_option_dict = model_metadata_dict[
neural_net.TRAINING_OPTIONS_KEY]
scalar_target_names = (
generator_option_dict[neural_net.SCALAR_TARGET_NAMES_KEY])
vector_target_names = (
generator_option_dict[neural_net.VECTOR_TARGET_NAMES_KEY])
heights_m_agl = generator_option_dict[neural_net.HEIGHTS_KEY]
try:
t = evaluation_tables_xarray[0]
aux_target_names = t.coords[evaluation.AUX_TARGET_FIELD_DIM].values
except:
aux_target_names = []
num_scalar_targets = len(scalar_target_names)
num_vector_targets = len(vector_target_names)
num_heights = len(heights_m_agl)
num_aux_targets = len(aux_target_names)
example_dict = {
example_utils.SCALAR_TARGET_NAMES_KEY:
scalar_target_names,
example_utils.VECTOR_TARGET_NAMES_KEY:
vector_target_names,
example_utils.HEIGHTS_KEY:
heights_m_agl,
example_utils.SCALAR_PREDICTOR_NAMES_KEY:
generator_option_dict[neural_net.SCALAR_PREDICTOR_NAMES_KEY],
example_utils.VECTOR_PREDICTOR_NAMES_KEY:
generator_option_dict[neural_net.VECTOR_PREDICTOR_NAMES_KEY]
}
normalization_file_name = (
generator_option_dict[neural_net.NORMALIZATION_FILE_KEY])
print(('Reading training examples (for climatology) from: "{0:s}"...'
).format(normalization_file_name))
training_example_dict = example_io.read_file(normalization_file_name)
training_example_dict = example_utils.subset_by_height(
example_dict=training_example_dict, heights_m_agl=heights_m_agl)
mean_training_example_dict = normalization.create_mean_example(
new_example_dict=example_dict,
training_example_dict=training_example_dict)
print(SEPARATOR_STRING)
# Do actual stuff.
_plot_error_distributions(
prediction_dicts=prediction_dicts,
model_metadata_dict=model_metadata_dict,
aux_target_names=aux_target_names,
set_descriptions_abbrev=set_descriptions_abbrev,
set_descriptions_verbose=set_descriptions_verbose,
output_dir_name=output_dir_name)
print(SEPARATOR_STRING)
_plot_reliability_by_height(
evaluation_tables_xarray=evaluation_tables_xarray,
vector_target_names=vector_target_names,
heights_m_agl=heights_m_agl,
set_descriptions_abbrev=set_descriptions_abbrev,
set_descriptions_verbose=set_descriptions_verbose,
output_dir_name=output_dir_name)
print(SEPARATOR_STRING)
for k in range(num_vector_targets):
for this_score_name in list(SCORE_NAME_TO_PROFILE_KEY.keys()):
_plot_score_profile(
evaluation_tables_xarray=evaluation_tables_xarray,
line_styles=line_styles,
line_colours=line_colours,
set_descriptions_verbose=set_descriptions_verbose,
confidence_level=confidence_level,
target_name=vector_target_names[k],
score_name=this_score_name,
use_log_scale=use_log_scale,
output_dir_name=output_dir_name)
print(SEPARATOR_STRING)
for k in range(num_scalar_targets):
_plot_attributes_diagram(
evaluation_tables_xarray=evaluation_tables_xarray,
line_styles=line_styles,
line_colours=line_colours,
set_descriptions_abbrev=set_descriptions_abbrev,
set_descriptions_verbose=set_descriptions_verbose,
confidence_level=confidence_level,
mean_training_example_dict=mean_training_example_dict,
target_name=scalar_target_names[k],
output_dir_name=output_dir_name)
for k in range(num_aux_targets):
_plot_attributes_diagram(
evaluation_tables_xarray=evaluation_tables_xarray,
line_styles=line_styles,
line_colours=line_colours,
set_descriptions_abbrev=set_descriptions_abbrev,
set_descriptions_verbose=set_descriptions_verbose,
confidence_level=confidence_level,
mean_training_example_dict=mean_training_example_dict,
target_name=aux_target_names[k],
output_dir_name=output_dir_name)
if not plot_by_height:
return
print(SEPARATOR_STRING)
for k in range(num_vector_targets):
for j in range(num_heights):
_plot_attributes_diagram(
evaluation_tables_xarray=evaluation_tables_xarray,
line_styles=line_styles,
line_colours=line_colours,
set_descriptions_abbrev=set_descriptions_abbrev,
set_descriptions_verbose=set_descriptions_verbose,
confidence_level=confidence_level,
mean_training_example_dict=mean_training_example_dict,
height_m_agl=heights_m_agl[j],
target_name=vector_target_names[k],
output_dir_name=output_dir_name)
if k != num_vector_targets - 1:
print(SEPARATOR_STRING)
def _run(input_file_name, top_output_dir_name):
"""Splits predictions by site (point location).
This is effectively the main method.
:param input_file_name: See documentation at top of file.
:param top_output_dir_name: Same.
:raises: ValueError: if any example cannot be assigned to a site.
"""
# Read data.
print('Reading data from: "{0:s}"...'.format(input_file_name))
prediction_dict = prediction_io.read_file(input_file_name)
example_metadata_dict = example_utils.parse_example_ids(
prediction_dict[prediction_io.EXAMPLE_IDS_KEY])
example_latitudes_deg_n = number_rounding.round_to_nearest(
example_metadata_dict[example_utils.LATITUDES_KEY],
LATLNG_TOLERANCE_DEG)
example_longitudes_deg_e = number_rounding.round_to_nearest(
example_metadata_dict[example_utils.LONGITUDES_KEY],
LATLNG_TOLERANCE_DEG)
example_longitudes_deg_e = lng_conversion.convert_lng_positive_in_west(
example_longitudes_deg_e)
num_examples = len(example_latitudes_deg_n)
example_written_flags = numpy.full(num_examples, False, dtype=bool)
site_names = list(SITE_NAME_TO_LATLNG.keys())
num_sites = len(site_names)
for j in range(num_sites):
this_site_latitude_deg_n = SITE_NAME_TO_LATLNG[site_names[j]][0]
this_site_longitude_deg_e = SITE_NAME_TO_LATLNG[site_names[j]][1]
these_indices = numpy.where(
numpy.logical_and(
numpy.absolute(example_latitudes_deg_n -
this_site_latitude_deg_n) <=
LATLNG_TOLERANCE_DEG,
numpy.absolute(example_longitudes_deg_e -
this_site_longitude_deg_e) <=
LATLNG_TOLERANCE_DEG))[0]
this_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=these_indices)
this_output_file_name = '{0:s}/{1:s}/predictions.nc'.format(
top_output_dir_name, site_names[j])
print('Writing {0:d} examples to: "{1:s}"...'.format(
len(these_indices), this_output_file_name))
if len(these_indices) == 0:
continue
example_written_flags[these_indices] = True
prediction_io.write_file(
netcdf_file_name=this_output_file_name,
scalar_target_matrix=this_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=this_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=this_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=this_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=this_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=this_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=this_prediction_dict[prediction_io.MODEL_FILE_KEY])
if numpy.all(example_written_flags):
return
# bad_latitudes_deg_n = (
# example_latitudes_deg_n[example_written_flags == False]
# )
# bad_longitudes_deg_e = (
# example_longitudes_deg_e[example_written_flags == False]
# )
# bad_coord_matrix = numpy.transpose(numpy.vstack((
# bad_latitudes_deg_n, bad_longitudes_deg_e
# )))
# bad_coord_matrix = numpy.unique(bad_coord_matrix, axis=0)
# print(bad_coord_matrix)
error_string = (
'{0:d} of {1:d} examples could not be assigned to a site. This is a '
'BIG PROBLEM.').format(numpy.sum(example_written_flags == False),
num_examples)
raise ValueError(error_string)
def _run(input_prediction_file_name, model_file_name,
output_prediction_file_name):
"""Applies one set of isotonic-regression models to data.
This is effectively the main method.
:param input_prediction_file_name: See documentation at top of file.
:param model_file_name: Same.
:param output_prediction_file_name: Same.
:raises: ValueError: if predictions in `input_prediction_file_name` were
made with isotonic regression.
"""
print('Reading original predictions from: "{0:s}"...'.format(
input_prediction_file_name
))
prediction_dict = prediction_io.read_file(input_prediction_file_name)
if prediction_dict[prediction_io.ISOTONIC_MODEL_FILE_KEY] is not None:
raise ValueError(
'Input predictions must be made with base model only (i.e., must '
'not already include isotonic regression).'
)
orig_vector_prediction_matrix = (
None if prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY].size == 0
else prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY]
)
orig_scalar_prediction_matrix = (
None if prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY].size == 0
else prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY]
)
print('Reading isotonic-regression models from: "{0:s}"...'.format(
model_file_name
))
scalar_model_objects, vector_model_object_matrix = (
isotonic_regression.read_file(model_file_name)
)
print(SEPARATOR_STRING)
new_vector_prediction_matrix, new_scalar_prediction_matrix = (
isotonic_regression.apply_models(
orig_vector_prediction_matrix=orig_vector_prediction_matrix,
orig_scalar_prediction_matrix=orig_scalar_prediction_matrix,
scalar_model_objects=scalar_model_objects,
vector_model_object_matrix=vector_model_object_matrix
)
)
print(SEPARATOR_STRING)
print('Writing new predictions to: "{0:s}"...'.format(
output_prediction_file_name
))
prediction_io.write_file(
netcdf_file_name=output_prediction_file_name,
scalar_target_matrix=prediction_dict[prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=prediction_dict[prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=new_scalar_prediction_matrix,
vector_prediction_matrix=new_vector_prediction_matrix,
heights_m_agl=prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=prediction_dict[prediction_io.EXAMPLE_IDS_KEY],
model_file_name=prediction_dict[prediction_io.MODEL_FILE_KEY],
isotonic_model_file_name=model_file_name
)
def _get_target_values(prediction_file_name, model_metadata_dict,
example_id_strings, target_field_name,
target_height_m_agl):
"""Returns predicted and actual target values.
E = number of examples
:param prediction_file_name: See documentation at top of file.
:param model_metadata_dict: Dictionary returned by
`neural_net.read_metafile`.
:param example_id_strings: length-E list of example IDs. Will return target
values only for these examples.
:param target_field_name: Name of target variable.
:param target_height_m_agl: Height of target variable (metres above ground
level).
:return: predicted_values: length-E numpy array of predicted target values.
:return: actual_values: length-E numpy array of actual target values.
"""
print(('Reading predicted and actual target values from: "{0:s}"...'
).format(prediction_file_name))
prediction_dict = prediction_io.read_file(prediction_file_name)
example_indices = numpy.array([
prediction_dict[prediction_io.EXAMPLE_IDS_KEY].index(id)
for id in example_id_strings
],
dtype=int)
generator_option_dict = (
model_metadata_dict[neural_net.TRAINING_OPTIONS_KEY])
if target_height_m_agl is None:
scalar_target_names = (
generator_option_dict[neural_net.SCALAR_TARGET_NAMES_KEY])
channel_index = scalar_target_names.index(target_field_name)
actual_values = (
prediction_dict[prediction_io.SCALAR_TARGETS_KEY][example_indices,
channel_index])
predicted_values = (prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY][example_indices,
channel_index])
return predicted_values, actual_values
vector_target_names = (
generator_option_dict[neural_net.VECTOR_TARGET_NAMES_KEY])
channel_index = vector_target_names.index(target_field_name)
height_index = example_utils.match_heights(
heights_m_agl=generator_option_dict[neural_net.HEIGHTS_KEY],
desired_height_m_agl=target_height_m_agl)
actual_values = (
prediction_dict[prediction_io.VECTOR_TARGETS_KEY][example_indices,
height_index,
channel_index])
predicted_values = (
prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY][example_indices,
height_index,
channel_index])
return predicted_values, actual_values
def _run(input_file_name, min_latitude_deg, max_latitude_deg, min_longitude_deg,
max_longitude_deg, latitude_spacing_deg, longitude_spacing_deg,
output_dir_name):
"""Splits predictions by spatial region.
This is effectively the main method.
:param input_file_name: See documentation at top of file.
:param min_latitude_deg: Same.
:param max_latitude_deg: Same.
:param min_longitude_deg: Same.
:param max_longitude_deg: Same.
:param latitude_spacing_deg: Same.
:param longitude_spacing_deg: Same.
:param output_dir_name: Same.
"""
# Read data.
print('Reading data from: "{0:s}"...'.format(input_file_name))
prediction_dict = prediction_io.read_file(input_file_name)
example_metadata_dict = example_utils.parse_example_ids(
prediction_dict[prediction_io.EXAMPLE_IDS_KEY]
)
example_latitudes_deg = example_metadata_dict[example_utils.LATITUDES_KEY]
example_longitudes_deg = example_metadata_dict[example_utils.LONGITUDES_KEY]
these_limits_deg = numpy.array([
min_latitude_deg, max_latitude_deg, min_longitude_deg, max_longitude_deg
])
if numpy.any(numpy.isnan(these_limits_deg)):
min_latitude_deg = numpy.min(example_latitudes_deg)
max_latitude_deg = numpy.max(example_latitudes_deg)
min_longitude_deg = numpy.min(example_longitudes_deg)
max_longitude_deg = numpy.max(example_longitudes_deg)
# Create grid.
grid_point_latitudes_deg, grid_point_longitudes_deg = (
misc.create_latlng_grid(
min_latitude_deg=min_latitude_deg,
max_latitude_deg=max_latitude_deg,
latitude_spacing_deg=latitude_spacing_deg,
min_longitude_deg=min_longitude_deg,
max_longitude_deg=max_longitude_deg,
longitude_spacing_deg=longitude_spacing_deg
)
)
num_grid_rows = len(grid_point_latitudes_deg)
num_grid_columns = len(grid_point_longitudes_deg)
grid_edge_latitudes_deg, grid_edge_longitudes_deg = (
grids.get_latlng_grid_cell_edges(
min_latitude_deg=grid_point_latitudes_deg[0],
min_longitude_deg=grid_point_longitudes_deg[0],
lat_spacing_deg=numpy.diff(grid_point_latitudes_deg[:2])[0],
lng_spacing_deg=numpy.diff(grid_point_longitudes_deg[:2])[0],
num_rows=num_grid_rows, num_columns=num_grid_columns
)
)
print(SEPARATOR_STRING)
for i in range(num_grid_rows):
for j in range(num_grid_columns):
these_indices = grids.find_events_in_grid_cell(
event_x_coords_metres=example_longitudes_deg,
event_y_coords_metres=example_latitudes_deg,
grid_edge_x_coords_metres=grid_edge_longitudes_deg,
grid_edge_y_coords_metres=grid_edge_latitudes_deg,
row_index=i, column_index=j, verbose=False
)
this_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=these_indices
)
this_num_examples = len(
this_prediction_dict[prediction_io.EXAMPLE_IDS_KEY]
)
if this_num_examples == 0:
continue
this_output_file_name = prediction_io.find_file(
directory_name=output_dir_name, grid_row=i, grid_column=j,
raise_error_if_missing=False
)
print('Writing {0:d} examples to: "{1:s}"...'.format(
len(this_prediction_dict[prediction_io.EXAMPLE_IDS_KEY]),
this_output_file_name
))
prediction_io.write_file(
netcdf_file_name=this_output_file_name,
scalar_target_matrix=
this_prediction_dict[prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=
this_prediction_dict[prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=
this_prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=
this_prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=this_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=
this_prediction_dict[prediction_io.EXAMPLE_IDS_KEY],
model_file_name=
this_prediction_dict[prediction_io.MODEL_FILE_KEY]
)
print(SEPARATOR_STRING)
grid_metafile_name = prediction_io.find_grid_metafile(
prediction_dir_name=output_dir_name, raise_error_if_missing=False
)
print('Writing grid metadata to: "{0:s}"...'.format(grid_metafile_name))
prediction_io.write_grid_metafile(
grid_point_latitudes_deg=grid_point_latitudes_deg,
grid_point_longitudes_deg=grid_point_longitudes_deg,
netcdf_file_name=grid_metafile_name
)
def _run(prediction_file_name, num_examples, example_dir_name, use_log_scale,
output_dir_name):
"""Plots comparisons between predicted and actual (target) profiles.
This is effectively the main method.
:param prediction_file_name: See documentation at top of file.
:param num_examples: Same.
:param example_dir_name: Same.
:param use_log_scale: Same.
:param output_dir_name: Same.
"""
file_system_utils.mkdir_recursive_if_necessary(
directory_name=output_dir_name)
if num_examples < 1:
num_examples = None
if example_dir_name == '':
example_dir_name = None
print(('Reading predicted and actual (target) profiles from: "{0:s}"...'
).format(prediction_file_name))
prediction_dict = prediction_io.read_file(prediction_file_name)
num_examples_orig = len(prediction_dict[prediction_io.EXAMPLE_IDS_KEY])
if num_examples is not None and num_examples < num_examples_orig:
desired_indices = numpy.linspace(0,
num_examples - 1,
num=num_examples,
dtype=int)
prediction_dict = prediction_io.subset_by_index(
prediction_dict=prediction_dict, desired_indices=desired_indices)
vector_target_matrix = prediction_dict[prediction_io.VECTOR_TARGETS_KEY]
vector_prediction_matrix = (
prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY])
scalar_target_matrix = prediction_dict[prediction_io.SCALAR_TARGETS_KEY]
scalar_prediction_matrix = (
prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY])
model_file_name = prediction_dict[prediction_io.MODEL_FILE_KEY]
model_metafile_name = neural_net.find_metafile(
model_dir_name=os.path.split(model_file_name)[0],
raise_error_if_missing=True)
print(
'Reading model metadata from: "{0:s}"...'.format(model_metafile_name))
model_metadata_dict = neural_net.read_metafile(model_metafile_name)
model_metadata_dict[neural_net.TRAINING_OPTIONS_KEY][
neural_net.HEIGHTS_KEY] = prediction_dict[prediction_io.HEIGHTS_KEY]
# If necessary, convert flux increments to fluxes.
vector_target_matrix, vector_prediction_matrix, model_metadata_dict = (
_fluxes_increments_to_actual(
vector_target_matrix=vector_target_matrix,
vector_prediction_matrix=vector_prediction_matrix,
model_metadata_dict=model_metadata_dict))
# If necessary, convert fluxes to heating rates.
vector_target_matrix, vector_prediction_matrix, model_metadata_dict = (
_fluxes_to_heating_rate(
vector_target_matrix=vector_target_matrix,
vector_prediction_matrix=vector_prediction_matrix,
model_metadata_dict=model_metadata_dict,
prediction_file_name=prediction_file_name,
example_dir_name=example_dir_name))
# If data include both upwelling and downwelling fluxes, remove flux
# increments (they need not be plotted).
vector_target_matrix, vector_prediction_matrix, model_metadata_dict = (
_remove_flux_increments(
vector_target_matrix=vector_target_matrix,
vector_prediction_matrix=vector_prediction_matrix,
model_metadata_dict=model_metadata_dict))
generator_option_dict = model_metadata_dict[
neural_net.TRAINING_OPTIONS_KEY]
vector_target_names = (
generator_option_dict[neural_net.VECTOR_TARGET_NAMES_KEY])
plot_fancy = all(
[t in vector_target_names for t in DEFAULT_VECTOR_TARGET_NAMES])
if plot_fancy:
_plot_comparisons_fancy(
vector_target_matrix=vector_target_matrix,
vector_prediction_matrix=vector_prediction_matrix,
example_id_strings=prediction_dict[prediction_io.EXAMPLE_IDS_KEY],
model_metadata_dict=model_metadata_dict,
use_log_scale=use_log_scale,
output_dir_name=output_dir_name)
else:
title_strings = _get_flux_strings(
scalar_target_matrix=scalar_target_matrix,
scalar_prediction_matrix=scalar_prediction_matrix,
model_metadata_dict=model_metadata_dict)
_plot_comparisons_simple(
vector_target_matrix=vector_target_matrix,
vector_prediction_matrix=vector_prediction_matrix,
example_id_strings=prediction_dict[prediction_io.EXAMPLE_IDS_KEY],
model_metadata_dict=model_metadata_dict,
use_log_scale=use_log_scale,
title_strings=title_strings,
output_dir_name=output_dir_name)
def _run(input_prediction_file_name, num_examples_per_set, output_dir_name):
"""Finds best and worst heating-rate predictions.
This is effectively the main method.
:param input_prediction_file_name: See documentation at top of file.
:param num_examples_per_set: Same.
:param output_dir_name: Same.
"""
error_checking.assert_is_greater(num_examples_per_set, 0)
print('Reading data from: "{0:s}"...'.format(input_prediction_file_name))
prediction_dict = prediction_io.read_file(input_prediction_file_name)
model_file_name = prediction_dict[prediction_io.MODEL_FILE_KEY]
model_metafile_name = neural_net.find_metafile(
model_dir_name=os.path.split(model_file_name)[0])
print(
'Reading model metadata from: "{0:s}"...'.format(model_metafile_name))
model_metadata_dict = neural_net.read_metafile(model_metafile_name)
generator_option_dict = model_metadata_dict[
neural_net.TRAINING_OPTIONS_KEY]
scalar_target_names = (
generator_option_dict[neural_net.SCALAR_TARGET_NAMES_KEY])
down_index = scalar_target_names.index(
example_utils.SHORTWAVE_SURFACE_DOWN_FLUX_NAME)
up_index = scalar_target_names.index(
example_utils.SHORTWAVE_TOA_UP_FLUX_NAME)
targets_w_m02 = (
prediction_dict[prediction_io.SCALAR_TARGETS_KEY][..., down_index] -
prediction_dict[prediction_io.SCALAR_TARGETS_KEY][..., up_index])
predictions_w_m02 = (
prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY][..., down_index]
- prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY][..., up_index])
biases_w_m02 = predictions_w_m02 - targets_w_m02
bias_matrix = numpy.expand_dims(biases_w_m02, axis=1)
print(SEPARATOR_STRING)
high_bias_indices, low_bias_indices, low_abs_error_indices = (
misc_utils.find_best_and_worst_predictions(
bias_matrix=bias_matrix,
absolute_error_matrix=numpy.absolute(bias_matrix),
num_examples_per_set=num_examples_per_set))
print(SEPARATOR_STRING)
high_bias_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=high_bias_indices)
high_bias_file_name = (
'{0:s}/predictions_high-bias.nc'.format(output_dir_name))
print('Writing examples with greatest positive bias to: "{0:s}"...'.format(
high_bias_file_name))
prediction_io.write_file(
netcdf_file_name=high_bias_file_name,
scalar_target_matrix=high_bias_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=high_bias_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=high_bias_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=high_bias_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=high_bias_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=high_bias_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=high_bias_prediction_dict[
prediction_io.MODEL_FILE_KEY])
low_bias_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=low_bias_indices)
low_bias_file_name = (
'{0:s}/predictions_low-bias.nc'.format(output_dir_name))
print('Writing examples with greatest negative bias to: "{0:s}"...'.format(
low_bias_file_name))
prediction_io.write_file(
netcdf_file_name=low_bias_file_name,
scalar_target_matrix=low_bias_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=low_bias_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=low_bias_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=low_bias_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=low_bias_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=low_bias_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=low_bias_prediction_dict[prediction_io.MODEL_FILE_KEY])
low_abs_error_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=low_abs_error_indices)
low_abs_error_file_name = (
'{0:s}/predictions_low-absolute-error.nc'.format(output_dir_name))
print(
'Writing examples with smallest absolute error to: "{0:s}"...'.format(
low_abs_error_file_name))
prediction_io.write_file(
netcdf_file_name=low_abs_error_file_name,
scalar_target_matrix=low_abs_error_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=low_abs_error_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=low_abs_error_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=low_abs_error_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=low_abs_error_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=low_abs_error_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=low_abs_error_prediction_dict[
prediction_io.MODEL_FILE_KEY])
sort_indices = numpy.argsort(-1 * targets_w_m02)
large_net_flux_indices = sort_indices[:num_examples_per_set]
large_net_flux_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=large_net_flux_indices)
large_net_flux_file_name = (
'{0:s}/predictions_large-net-flux.nc'.format(output_dir_name))
print('Writing examples with greatest net flux to: "{0:s}"...'.format(
large_net_flux_file_name))
prediction_io.write_file(
netcdf_file_name=large_net_flux_file_name,
scalar_target_matrix=large_net_flux_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=large_net_flux_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=large_net_flux_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=large_net_flux_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=large_net_flux_prediction_dict[
prediction_io.HEIGHTS_KEY],
example_id_strings=large_net_flux_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=large_net_flux_prediction_dict[
prediction_io.MODEL_FILE_KEY])
sort_indices = numpy.argsort(targets_w_m02)
small_net_flux_indices = sort_indices[:num_examples_per_set]
small_net_flux_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=small_net_flux_indices)
small_net_flux_file_name = (
'{0:s}/predictions_small-net-flux.nc'.format(output_dir_name))
print('Writing examples with smallest net flux to: "{0:s}"...'.format(
small_net_flux_file_name))
prediction_io.write_file(
netcdf_file_name=small_net_flux_file_name,
scalar_target_matrix=small_net_flux_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=small_net_flux_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=small_net_flux_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=small_net_flux_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=small_net_flux_prediction_dict[
prediction_io.HEIGHTS_KEY],
example_id_strings=small_net_flux_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=small_net_flux_prediction_dict[
prediction_io.MODEL_FILE_KEY])
def _run(input_prediction_file_name, average_over_height, scale_by_climo,
num_examples_per_set, output_dir_name):
"""Finds best and worst heating-rate predictions.
This is effectively the main method.
:param input_prediction_file_name: See documentation at top of file.
:param average_over_height: Same.
:param scale_by_climo: Same.
:param num_examples_per_set: Same.
:param output_dir_name: Same.
"""
# TODO(thunderhoser): Maybe allow specific height again (e.g., 15 km).
error_checking.assert_is_greater(num_examples_per_set, 0)
scale_by_climo = scale_by_climo and not average_over_height
print('Reading data from: "{0:s}"...'.format(input_prediction_file_name))
prediction_dict = prediction_io.read_file(input_prediction_file_name)
model_file_name = prediction_dict[prediction_io.MODEL_FILE_KEY]
model_metafile_name = neural_net.find_metafile(
model_dir_name=os.path.split(model_file_name)[0])
print(
'Reading model metadata from: "{0:s}"...'.format(model_metafile_name))
model_metadata_dict = neural_net.read_metafile(model_metafile_name)
generator_option_dict = model_metadata_dict[
neural_net.TRAINING_OPTIONS_KEY]
vector_target_names = (
generator_option_dict[neural_net.VECTOR_TARGET_NAMES_KEY])
hr_index = (vector_target_names.index(
example_utils.SHORTWAVE_HEATING_RATE_NAME))
target_matrix_k_day01 = (
prediction_dict[prediction_io.VECTOR_TARGETS_KEY][..., hr_index])
prediction_matrix_k_day01 = (
prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY][..., hr_index])
bias_matrix = prediction_matrix_k_day01 - target_matrix_k_day01
absolute_error_matrix = numpy.absolute(bias_matrix)
if average_over_height:
bias_matrix = numpy.mean(bias_matrix, axis=1, keepdims=True)
absolute_error_matrix = numpy.mean(absolute_error_matrix,
axis=1,
keepdims=True)
if scale_by_climo:
normalization_file_name = (
generator_option_dict[neural_net.NORMALIZATION_FILE_KEY])
print(('Reading training examples (for climatology) from: "{0:s}"...'
).format(normalization_file_name))
training_example_dict = example_io.read_file(normalization_file_name)
training_example_dict = example_utils.subset_by_field(
example_dict=training_example_dict,
field_names=[example_utils.SHORTWAVE_HEATING_RATE_NAME])
training_example_dict = example_utils.subset_by_height(
example_dict=training_example_dict,
heights_m_agl=generator_option_dict[neural_net.HEIGHTS_KEY])
dummy_example_dict = {
example_utils.SCALAR_PREDICTOR_NAMES_KEY: [],
example_utils.VECTOR_PREDICTOR_NAMES_KEY: [],
example_utils.SCALAR_TARGET_NAMES_KEY: [],
example_utils.VECTOR_TARGET_NAMES_KEY:
[example_utils.SHORTWAVE_HEATING_RATE_NAME],
example_utils.HEIGHTS_KEY:
generator_option_dict[neural_net.HEIGHTS_KEY]
}
mean_training_example_dict = normalization.create_mean_example(
new_example_dict=dummy_example_dict,
training_example_dict=training_example_dict)
climo_matrix_k_day01 = mean_training_example_dict[
example_utils.VECTOR_TARGET_VALS_KEY][..., 0]
bias_matrix = bias_matrix / climo_matrix_k_day01
absolute_error_matrix = absolute_error_matrix / climo_matrix_k_day01
print(SEPARATOR_STRING)
high_bias_indices, low_bias_indices, low_abs_error_indices = (
misc_utils.find_best_and_worst_predictions(
bias_matrix=bias_matrix,
absolute_error_matrix=absolute_error_matrix,
num_examples_per_set=num_examples_per_set))
print(SEPARATOR_STRING)
high_bias_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=high_bias_indices)
high_bias_file_name = (
'{0:s}/predictions_high-bias.nc'.format(output_dir_name))
print('Writing examples with greatest positive bias to: "{0:s}"...'.format(
high_bias_file_name))
prediction_io.write_file(
netcdf_file_name=high_bias_file_name,
scalar_target_matrix=high_bias_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=high_bias_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=high_bias_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=high_bias_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=high_bias_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=high_bias_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=high_bias_prediction_dict[
prediction_io.MODEL_FILE_KEY])
low_bias_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=low_bias_indices)
low_bias_file_name = (
'{0:s}/predictions_low-bias.nc'.format(output_dir_name))
print('Writing examples with greatest negative bias to: "{0:s}"...'.format(
low_bias_file_name))
prediction_io.write_file(
netcdf_file_name=low_bias_file_name,
scalar_target_matrix=low_bias_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=low_bias_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=low_bias_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=low_bias_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=low_bias_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=low_bias_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=low_bias_prediction_dict[prediction_io.MODEL_FILE_KEY])
low_abs_error_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=low_abs_error_indices)
low_abs_error_file_name = (
'{0:s}/predictions_low-absolute-error.nc'.format(output_dir_name))
print(
'Writing examples with smallest absolute error to: "{0:s}"...'.format(
low_abs_error_file_name))
prediction_io.write_file(
netcdf_file_name=low_abs_error_file_name,
scalar_target_matrix=low_abs_error_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=low_abs_error_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=low_abs_error_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=low_abs_error_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=low_abs_error_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=low_abs_error_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=low_abs_error_prediction_dict[
prediction_io.MODEL_FILE_KEY])
if scale_by_climo:
return
if average_over_height:
mean_targets_k_day01 = numpy.mean(target_matrix_k_day01, axis=1)
sort_indices = numpy.argsort(-1 * mean_targets_k_day01)
else:
max_targets_k_day01 = numpy.max(target_matrix_k_day01, axis=1)
sort_indices = numpy.argsort(-1 * max_targets_k_day01)
large_hr_indices = sort_indices[:num_examples_per_set]
large_hr_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=large_hr_indices)
large_hr_file_name = (
'{0:s}/predictions_large-heating-rate.nc'.format(output_dir_name))
print('Writing examples with greatest heating rate to: "{0:s}"...'.format(
large_hr_file_name))
prediction_io.write_file(
netcdf_file_name=large_hr_file_name,
scalar_target_matrix=large_hr_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=large_hr_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=large_hr_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=large_hr_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=large_hr_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=large_hr_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=large_hr_prediction_dict[prediction_io.MODEL_FILE_KEY])
if not average_over_height:
return
mean_targets_k_day01 = numpy.mean(target_matrix_k_day01, axis=1)
sort_indices = numpy.argsort(mean_targets_k_day01)
small_hr_indices = sort_indices[:num_examples_per_set]
small_hr_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=small_hr_indices)
small_hr_file_name = (
'{0:s}/predictions_small-heating-rate.nc'.format(output_dir_name))
print('Writing examples with smallest heating rate to: "{0:s}"...'.format(
small_hr_file_name))
prediction_io.write_file(
netcdf_file_name=small_hr_file_name,
scalar_target_matrix=small_hr_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=small_hr_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=small_hr_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=small_hr_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=small_hr_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=small_hr_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=small_hr_prediction_dict[prediction_io.MODEL_FILE_KEY])
def _run(input_file_name, num_zenith_angle_bins, num_albedo_bins,
output_dir_name):
"""Splits predictions by time of day and time of year.
This is effectively the main method.
:param input_file_name: See documentation at top of file.
:param num_zenith_angle_bins: Same.
:param num_albedo_bins: Same.
:param output_dir_name: Same.
"""
# Process input args.
error_checking.assert_is_geq(num_zenith_angle_bins, 3)
error_checking.assert_is_geq(num_albedo_bins, 3)
edge_zenith_angles_rad = numpy.linspace(MIN_ZENITH_ANGLE_RAD,
MAX_ZENITH_ANGLE_RAD,
num=num_zenith_angle_bins + 1,
dtype=float)
min_zenith_angles_rad = edge_zenith_angles_rad[:-1]
max_zenith_angles_rad = edge_zenith_angles_rad[1:]
edge_albedos = numpy.linspace(0, 1, num=num_albedo_bins + 1, dtype=float)
min_albedos = edge_albedos[:-1]
max_albedos = edge_albedos[1:]
# Read data.
print('Reading data from: "{0:s}"...\n'.format(input_file_name))
prediction_dict = prediction_io.read_file(input_file_name)
# Split by solar zenith angle.
for k in range(num_zenith_angle_bins):
this_prediction_dict = prediction_io.subset_by_zenith_angle(
prediction_dict=copy.deepcopy(prediction_dict),
min_zenith_angle_rad=min_zenith_angles_rad[k],
max_zenith_angle_rad=max_zenith_angles_rad[k])
this_output_file_name = prediction_io.find_file(
directory_name=output_dir_name,
zenith_angle_bin=k,
raise_error_if_missing=False)
print((
'Writing {0:d} examples (with zenith angles {1:.4f}...{2:.4f} rad) '
'to: "{3:s}"...').format(
len(this_prediction_dict[prediction_io.EXAMPLE_IDS_KEY]),
min_zenith_angles_rad[k], max_zenith_angles_rad[k],
this_output_file_name))
prediction_io.write_file(
netcdf_file_name=this_output_file_name,
scalar_target_matrix=this_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=this_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=this_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=this_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=this_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=this_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=this_prediction_dict[prediction_io.MODEL_FILE_KEY])
print('\n')
# Split by albedo.
for k in range(num_albedo_bins):
this_prediction_dict = prediction_io.subset_by_albedo(
prediction_dict=copy.deepcopy(prediction_dict),
min_albedo=min_albedos[k],
max_albedo=max_albedos[k])
this_output_file_name = prediction_io.find_file(
directory_name=output_dir_name,
albedo_bin=k,
raise_error_if_missing=False)
print(('Writing {0:d} examples (with albedos {1:.4f}...{2:.4f}) '
'to: "{3:s}"...').format(
len(this_prediction_dict[prediction_io.EXAMPLE_IDS_KEY]),
min_albedos[k], max_albedos[k], this_output_file_name))
prediction_io.write_file(
netcdf_file_name=this_output_file_name,
scalar_target_matrix=this_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=this_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=this_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=this_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=this_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=this_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=this_prediction_dict[prediction_io.MODEL_FILE_KEY])
print('\n')
# Split by month.
for k in range(1, 13):
this_prediction_dict = prediction_io.subset_by_month(
prediction_dict=copy.deepcopy(prediction_dict), desired_month=k)
this_output_file_name = prediction_io.find_file(
directory_name=output_dir_name,
month=k,
raise_error_if_missing=False)
print('Writing {0:d} examples to: "{1:s}"...'.format(
len(this_prediction_dict[prediction_io.EXAMPLE_IDS_KEY]),
this_output_file_name))
prediction_io.write_file(
netcdf_file_name=this_output_file_name,
scalar_target_matrix=this_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=this_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=this_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=this_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=this_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=this_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=this_prediction_dict[prediction_io.MODEL_FILE_KEY])
def _run(input_file_name, example_dir_name, for_ice, min_path_kg_m02,
output_dir_name):
"""Splits predictions by cloud regime.
This is effectively the main method.
:param input_file_name: See documentation at top of file.
:param example_dir_name: Same.
:param for_ice: Same.
:param min_path_kg_m02: Same.
:param output_dir_name: Same.
"""
print('Reading data from: "{0:s}"...\n'.format(input_file_name))
prediction_dict = prediction_io.read_file(input_file_name)
example_dict = misc_utils.get_raw_examples(
example_file_name='',
num_examples=int(1e12),
example_dir_name=example_dir_name,
example_id_file_name=input_file_name)
print(SEPARATOR_STRING)
cloud_layer_counts = example_utils.find_cloud_layers(
example_dict=example_dict,
min_path_kg_m02=min_path_kg_m02,
for_ice=for_ice)[-1]
unique_cloud_layer_counts, unique_example_counts = numpy.unique(
cloud_layer_counts, return_counts=True)
for i in range(len(unique_cloud_layer_counts)):
print(
('Number of examples with {0:d} cloud layers '
'({1:s}-water path >= {2:.1f} g m^-2) = {3:d}').format(
unique_cloud_layer_counts[i], 'ice' if for_ice else 'liquid',
KG_TO_GRAMS * min_path_kg_m02, unique_example_counts[i]))
print(SEPARATOR_STRING)
num_output_files = len(MIN_LAYERS_BY_FILE)
for k in range(num_output_files):
these_indices = numpy.where(
numpy.logical_and(cloud_layer_counts >= MIN_LAYERS_BY_FILE[k],
cloud_layer_counts <= MAX_LAYERS_BY_FILE[k]))[0]
this_prediction_dict = prediction_io.subset_by_index(
prediction_dict=copy.deepcopy(prediction_dict),
desired_indices=these_indices)
this_output_file_name = '{0:s}/predictions_{1:s}.nc'.format(
output_dir_name, FILE_SUFFIXES[k])
print('Writing {0:d} examples to: "{1:s}"...'.format(
len(this_prediction_dict[prediction_io.EXAMPLE_IDS_KEY]),
this_output_file_name))
prediction_io.write_file(
netcdf_file_name=this_output_file_name,
scalar_target_matrix=this_prediction_dict[
prediction_io.SCALAR_TARGETS_KEY],
vector_target_matrix=this_prediction_dict[
prediction_io.VECTOR_TARGETS_KEY],
scalar_prediction_matrix=this_prediction_dict[
prediction_io.SCALAR_PREDICTIONS_KEY],
vector_prediction_matrix=this_prediction_dict[
prediction_io.VECTOR_PREDICTIONS_KEY],
heights_m_agl=this_prediction_dict[prediction_io.HEIGHTS_KEY],
example_id_strings=this_prediction_dict[
prediction_io.EXAMPLE_IDS_KEY],
model_file_name=this_prediction_dict[prediction_io.MODEL_FILE_KEY])
def _augment_eval_table(result_table_xarray):
"""Augments evaluation table.
Specifically, adds number of examples and skewness for each target variable.
:param result_table_xarray: Table returned by `evaluation.read_file`.
:return: result_table_xarray: Same but with number of examples and skewness
for each target variable.
"""
prediction_file_name = (
result_table_xarray.attrs[evaluation.PREDICTION_FILE_KEY])
print('Reading data from: "{0:s}"...'.format(prediction_file_name))
prediction_dict = prediction_io.read_file(prediction_file_name)
num_examples = len(prediction_dict[prediction_io.EXAMPLE_IDS_KEY])
result_table_xarray.attrs[NUM_EXAMPLES_KEY] = num_examples
scalar_target_matrix = prediction_dict[prediction_io.SCALAR_TARGETS_KEY]
if scalar_target_matrix.size == 0:
scalar_skewness_matrix = numpy.full(0, 0.)
else:
scalar_skewness_matrix = scipy.stats.skew(scalar_target_matrix,
axis=0,
bias=False,
nan_policy='omit')
these_dim = (evaluation.SCALAR_FIELD_DIM, )
result_table_xarray.update(
{SCALAR_SKEWNESS_KEY: (these_dim, scalar_skewness_matrix)})
vector_skewness_matrix = scipy.stats.skew(
prediction_dict[prediction_io.VECTOR_TARGETS_KEY],
axis=0,
bias=False,
nan_policy='omit')
these_dim = (evaluation.HEIGHT_DIM, evaluation.VECTOR_FIELD_DIM)
result_table_xarray.update(
{VECTOR_SKEWNESS_KEY: (these_dim, vector_skewness_matrix)})
try:
_ = result_table_xarray.coords[evaluation.AUX_TARGET_FIELD_DIM].values
except KeyError:
return result_table_xarray
example_dict = {
example_utils.SCALAR_TARGET_NAMES_KEY:
result_table_xarray.coords[evaluation.SCALAR_FIELD_DIM].values,
example_utils.VECTOR_TARGET_NAMES_KEY:
result_table_xarray.coords[evaluation.VECTOR_FIELD_DIM].values,
example_utils.HEIGHTS_KEY:
numpy.round(result_table_xarray.coords[
evaluation.HEIGHT_DIM].values).astype(int)
}
aux_target_matrix = evaluation.get_aux_fields(
prediction_dict=prediction_dict,
example_dict=example_dict)[evaluation.AUX_TARGET_VALS_KEY]
aux_skewness_matrix = scipy.stats.skew(aux_target_matrix,
axis=0,
bias=False,
nan_policy='omit')
these_dim = (evaluation.AUX_TARGET_FIELD_DIM, )
result_table_xarray.update(
{AUX_SKEWNESS_KEY: (these_dim, aux_skewness_matrix)})
return result_table_xarray
def _run(prediction_file_names, separate_by_height, output_dir_name):
"""Trains isotonic-regression model.
This is effectively the main method.
:param prediction_file_names: See documentation at top of file.
:param separate_by_height: Same.
:param output_dir_name: Same.
:raises: ValueError: if predictions in `prediction_file_names` were made
with isotonic regression.
"""
num_files = len(prediction_file_names)
prediction_dicts = [dict()] * num_files
for i in range(num_files):
print('Reading original predictions from: "{0:s}"...'.format(
prediction_file_names[i]))
prediction_dicts[i] = prediction_io.read_file(prediction_file_names[i])
prediction_dict = prediction_io.concat_predictions(prediction_dicts)
if prediction_dict[prediction_io.ISOTONIC_MODEL_FILE_KEY] is not None:
raise ValueError(
'Predictions used for training isotonic regression must be made'
' with base model only (i.e., must not already include isotonic'
' regression).')
orig_vector_prediction_matrix = (
None if prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY].size == 0
else prediction_dict[prediction_io.VECTOR_PREDICTIONS_KEY])
vector_target_matrix = (
None if prediction_dict[prediction_io.VECTOR_TARGETS_KEY].size == 0
else prediction_dict[prediction_io.VECTOR_TARGETS_KEY])
orig_scalar_prediction_matrix = (
None if prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY].size == 0
else prediction_dict[prediction_io.SCALAR_PREDICTIONS_KEY])
scalar_target_matrix = (
None if prediction_dict[prediction_io.SCALAR_TARGETS_KEY].size == 0
else prediction_dict[prediction_io.SCALAR_TARGETS_KEY])
print(SEPARATOR_STRING)
scalar_model_objects, vector_model_object_matrix = (
isotonic_regression.train_models(
orig_vector_prediction_matrix=orig_vector_prediction_matrix,
orig_scalar_prediction_matrix=orig_scalar_prediction_matrix,
vector_target_matrix=vector_target_matrix,
scalar_target_matrix=scalar_target_matrix,
separate_by_height=separate_by_height))
print(SEPARATOR_STRING)
output_file_name = isotonic_regression.find_file(
model_dir_name=output_dir_name, raise_error_if_missing=False)
print('Writing isotonic-regression models to: "{0:s}"...'.format(
output_file_name))
isotonic_regression.write_file(
dill_file_name=output_file_name,
scalar_model_objects=scalar_model_objects,
vector_model_object_matrix=vector_model_object_matrix)