def setup_samples(N=500, calc_second_order=True):
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = saltelli.sample(problem,
N=N,
calc_second_order=calc_second_order)
return problem, param_values
def test_optimised_trajectories_with_groups():
"""
Tests that the optimisation problem gives
the same answer as the brute force problem
(for small values of `k_choices` and `N`)
with groups
"""
N = 11
param_file = "SALib/tests/test_param_file_w_groups_prime.txt"
problem = read_param_file(param_file)
num_levels = 4
grid_jump = num_levels / 2
k_choices = 4
num_params = problem['num_vars']
groups = problem['groups']
input_sample = sample_groups(problem, N, num_levels, grid_jump)
# From gurobi optimal trajectories
actual = return_max_combo(input_sample, N, num_params, k_choices, groups)
desired = find_optimum_combination(input_sample, N, num_params, k_choices,
groups)
assert_equal(actual, desired)
def test_regression_morris_groups_brute_optim(self, set_seed):
set_seed
param_file = 'src/SALib/test_functions/params/Ishigami_groups.txt'
problem = read_param_file(param_file)
param_values = sample(problem=problem,
N=50,
num_levels=4,
optimal_trajectories=6,
local_optimization=False)
Y = Ishigami.evaluate(param_values)
Si = morris.analyze(problem,
param_values,
Y,
conf_level=0.95,
print_to_console=False,
num_levels=4)
assert_allclose(Si['mu'], [9.786986, np.NaN], atol=0, rtol=1e-5)
assert_allclose(Si['sigma'], [6.453729, np.NaN], atol=0, rtol=1e-5)
assert_allclose(Si['mu_star'], [9.786986, 7.875], atol=0, rtol=1e-5)
def plot_morris_by_leaf_by_boot(df_out, variable='normalized_audpc',
parameter_range_file='param_range_SA.txt',
input_file='morris_input.txt',
nboots=5, ylims=None):
problem = read_param_file(parameter_range_file)
fig, axs = plt.subplots(6, 2, figsize=(15, 30))
colors = iter(['b', 'g', 'r', 'k', 'm', 'c', 'y'])
colors = {b: next(colors) for b in range(nboots)}
for i, ax in enumerate(axs.flat):
lf = i + 1
for boot in np.unique(df_out['i_boot']):
param_values = np.loadtxt(input_file[:-4] + '_boot' + str(boot) + input_file[-4:])
df = df_out[(df_out['i_boot'] == boot) & (df_out['num_leaf_top'] == lf)]
Y = df[variable]
Si_bt = morris.analyze(problem, param_values, Y, grid_jump=5,
num_levels=10, conf_level=0.95,
print_to_console=False)
for ip, param in enumerate(Si_bt['names']):
ax.plot(Si_bt['mu_star'][ip], Si_bt['sigma'][ip],
color=colors[boot], marker='*')
ax.annotate(param, (Si_bt['mu_star'][ip], Si_bt['sigma'][ip]))
if ylims is not None:
ax.set_ylim(ylims)
ax.set_xlim(ylims)
ax.annotate('Leaf %d' % lf, xy=(0.05, 0.85),
xycoords='axes fraction', fontsize=18)
def test_optimised_trajectories_with_groups():
"""
Tests that the optimisation problem gives
the same answer as the brute force problem
(for small values of `k_choices` and `N`)
with groups
"""
N = 11
param_file = "SALib/tests/test_param_file_w_groups_prime.txt"
problem = read_param_file(param_file)
num_levels = 4
grid_jump = num_levels / 2
k_choices = 4
num_params = problem['num_vars']
groups = problem['groups']
input_sample = sample_groups(problem, N, num_levels, grid_jump)
# From gurobi optimal trajectories
actual = return_max_combo(input_sample,
N,
num_params,
k_choices,
groups)
desired = find_optimum_combination(input_sample,
N,
num_params,
k_choices,
groups)
assert_equal(actual, desired)
def test_optimal_sample_with_groups():
'''
Tests that the combinatorial optimisation approach matches
that of the brute force approach
'''
param_file = "SALib/tests/test_param_file_w_groups_prime.txt"
problem = read_param_file(param_file)
N = 10
num_levels = 8
grid_jump = 4
k_choices = 4
num_params = problem['num_vars']
sample = sample_oat(problem,
N,
num_levels,
grid_jump)
actual = return_max_combo(sample,
N,
num_params,
k_choices)
desired = find_optimum_combination(sample,
N,
num_params,
k_choices)
assert_equal(actual, desired)
def generate_spectra(sample_number=10000,
bounds='../assets/prosail_param_bounds.txt',
save_to_npy=False,
spectra_save='../data/spectra.npy',
params_save='../data/params.npy',
params_norm_save='../data/params_norm.npy'):
param_dimension = 15
wavelength_start = 400
wavelength_end = 2500
wavelength_num = wavelength_end - wavelength_start + 1
problem = read_param_file(bounds)
params = saltelli.sample(problem, sample_number)
params_norm = params.copy()
num = sample_number * (param_dimension + 1) * 2
cores = multiprocessing.cpu_count()
pool = multiprocessing.Pool(processes=cores)
spec = pool.map(generate_spectrum, params)
spec = np.array(spec).reshape(num, 2101)
for i in range(num):
p = params[i]
for j in range(param_dimension):
params_norm[i][j] = (p[j] - problem['bounds'][j][0]) / (
problem['bounds'][j][1] - problem['bounds'][j][0])
if save_to_npy:
np.save(spectra_save, spec)
np.save(params_save, params)
return spec, params, params_norm
def test_optimised_trajectories_groups(setup_param_groups_prime):
"""
Tests that the optimisation problem gives
the same answer as the brute force problem
(for small values of `k_choices` and `N`)
with groups
"""
N = 11
param_file = setup_param_groups_prime
problem = read_param_file(param_file)
num_levels = 4
k_choices = 4
num_params = problem['num_vars']
groups = compute_groups_matrix(problem['groups'], num_params)
input_sample = _sample_groups(problem, N, num_levels)
# From gurobi optimal trajectories
strategy = GlobalOptimisation()
actual = strategy.sample(input_sample,
N,
num_params,
k_choices,
groups)
brute_strategy = BruteForce()
desired = brute_strategy.sample(input_sample,
N,
num_params,
k_choices,
groups)
assert_equal(actual, desired)
def test_local_optimised_groups(self,
setup_param_groups_prime):
"""
Tests that the local optimisation problem gives
the same answer as the brute force problem
(for small values of `k_choices` and `N`)
with groups
"""
N = 8
param_file = setup_param_groups_prime
problem = read_param_file(param_file)
num_levels = 4
grid_jump = num_levels / 2
k_choices = 4
num_params = problem['num_vars']
num_groups = len(set(problem['groups']))
input_sample = _sample_groups(problem, N, num_levels, grid_jump)
strategy = LocalOptimisation()
# From local optimal trajectories
actual = strategy.find_local_maximum(input_sample, N, num_params,
k_choices, num_groups)
brute = BruteForce()
desired = brute.brute_force_most_distant(input_sample,
N,
num_params,
k_choices,
num_groups)
assert_equal(actual, desired)
def test_optimal_sample_with_groups(setup_param_groups_prime):
'''
Tests that the combinatorial optimisation approach matches
that of the brute force approach
'''
param_file = setup_param_groups_prime
problem = read_param_file(param_file)
N = 10
num_levels = 8
k_choices = 4
num_params = problem['num_vars']
sample = _sample_oat(problem,
N,
num_levels)
strategy = GlobalOptimisation()
actual = strategy.return_max_combo(sample,
N,
num_params,
k_choices)
brute_strategy = BruteForce()
desired = brute_strategy.brute_force_most_distant(sample,
N,
num_params,
k_choices)
assert_equal(actual, desired)
def test_regression_morris_optimal(self, set_seed):
'''
Tests the use of optimal trajectories with Morris.
Uses brute force approach
Note that the relative tolerance is set to a very high value
(default is 1e-05) due to the coarse nature of the num_levels.
'''
set_seed
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = sample(problem=problem, N=20,
num_levels=4,
optimal_trajectories=9,
local_optimization=True)
Y = Ishigami.evaluate(param_values)
Si = morris.analyze(problem, param_values, Y,
conf_level=0.95, print_to_console=False,
num_levels=4)
assert_allclose(Si['mu_star'],
[9.786986e+00, 7.875000e+00, 1.388621],
atol=0,
rtol=1e-5)
def plot_morris_3_leaves(df_out, leaves=[10, 5, 1],
variable='normalized_audpc',
parameter_range_file='param_range_SA.txt',
input_file='morris_input.txt',
nboots=5, ylims=None,
force_rename={}, axs=None,
annotation_suffix='',
folder='septoria', markers_SA={},
markersize=8, title=None):
plt.rcParams['text.usetex'] = True
problem = read_param_file('./' + folder + '/' + parameter_range_file)
if axs is None:
fig, axs = plt.subplots(1, 3, figsize=(18, 6))
leaves = iter(leaves)
for i, ax in enumerate(axs.flat):
lf = leaves.next()
if ax == axs[-1]:
add_legend = True
else:
add_legend = False
plot_morris_one_leaf(df_out, problem,
leaf=lf, ax=ax,
variable=variable,
input_file=input_file,
nboots=nboots, ylims=ylims,
force_rename=force_rename,
markers_SA=markers_SA,
add_legend=add_legend,
annotation_suffix=annotation_suffix,
folder=folder, markersize=markersize)
# plt.tight_layout()
plt.rcParams['text.usetex'] = True
if title is not None:
fig.savefig(title, bbox_inches='tight')
def test_regression_morris_optimal(self, set_seed):
'''
Tests the use of optimal trajectories with Morris.
Uses brute force approach
Note that the relative tolerance is set to a very high value
(default is 1e-05) due to the coarse nature of the num_levels.
'''
set_seed
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = sample(problem=problem,
N=20,
num_levels=4,
optimal_trajectories=9,
local_optimization=True)
Y = Ishigami.evaluate(param_values)
Si = morris.analyze(problem,
param_values,
Y,
conf_level=0.95,
print_to_console=False,
num_levels=4)
assert_allclose(Si['mu_star'], [9.786986e+00, 7.875000e+00, 1.388621],
atol=0,
rtol=1e-5)
def test_regression_morris_groups_brute_optim(self, set_seed):
set_seed
param_file = 'src/SALib/test_functions/params/Ishigami_groups.txt'
problem = read_param_file(param_file)
param_values = sample(problem=problem, N=50,
num_levels=4,
optimal_trajectories=6,
local_optimization=False)
Y = Ishigami.evaluate(param_values)
Si = morris.analyze(problem, param_values, Y,
conf_level=0.95, print_to_console=False,
num_levels=4)
assert_allclose(Si['mu'], [9.786986, np.NaN],
atol=0, rtol=1e-5)
assert_allclose(Si['sigma'], [6.453729, np.NaN],
atol=0, rtol=1e-5)
assert_allclose(Si['mu_star'], [9.786986, 7.875],
atol=0, rtol=1e-5)
def plot_morris_by_leaf(df_out, variable='normalized_audpc',
parameter_range_file='param_range_SA.txt',
input_file='morris_input.txt',
nboots=5, ylims=None, force_rename={},
markers_SA={}, annotation_suffix='',
folder='septoria'):
plt.rcParams['text.usetex'] = True
problem = read_param_file(parameter_range_file)
fig, axs = plt.subplots(6, 2, figsize=(15, 30))
for i, ax in enumerate(axs.flat):
lf = i + 1
if ax == axs[0][-1]:
add_legend = True
else:
add_legend = False
plot_morris_one_leaf(df_out, problem,
leaf=lf, ax=ax,
variable=variable,
input_file=input_file,
nboots=nboots, ylims=ylims,
force_rename=force_rename,
markers_SA=markers_SA,
add_legend=add_legend,
annotation_suffix=annotation_suffix,
folder=folder)
plt.rcParams['text.usetex'] = False
def plot_morris_by_leaf(df_out,
variable='normalized_audpc',
parameter_range_file='param_range_SA.txt',
input_file='morris_input.txt',
nboots=5,
ylims=None,
force_rename={},
markers_SA={},
annotation_suffix='',
folder='septoria'):
plt.rcParams['text.usetex'] = True
problem = read_param_file(parameter_range_file)
fig, axs = plt.subplots(6, 2, figsize=(15, 30))
for i, ax in enumerate(axs.flat):
lf = i + 1
if ax == axs[0][-1]:
add_legend = True
else:
add_legend = False
plot_morris_one_leaf(df_out,
problem,
leaf=lf,
ax=ax,
variable=variable,
input_file=input_file,
nboots=nboots,
ylims=ylims,
force_rename=force_rename,
markers_SA=markers_SA,
add_legend=add_legend,
annotation_suffix=annotation_suffix,
folder=folder)
plt.rcParams['text.usetex'] = False
def generate_parameter_set(parameters,
scenarios,
parameter_range_file='param_range_SA.txt',
sample_file='morris_input.txt',
num_trajectories=10,
num_levels=10,
grid_jump=5,
optimal_trajectories=None,
nboots=5):
""" Generate the file with samples for the analysis of Morris.
Parameters
----------
parameters: OrderedDict([('name', [min, max])])
Names and variation range of quantitative parameters
scenarios: list[tuple(year, variety)]
Years and varieties of wheat on which SA is repeated
"""
# Reset parameter range file
open(parameter_range_file, 'w').close()
generate_parameter_range_file(parameters=parameters,
filename=parameter_range_file)
# Generate samples
problem = read_param_file(parameter_range_file)
for boot in range(nboots):
param_values = sample(problem,
N=num_trajectories,
num_levels=num_levels,
grid_jump=grid_jump,
optimal_trajectories=optimal_trajectories)
# For Method of Morris, save the parameter values in a file (they are needed in the analysis)
s_file = sample_file[:-4] + '_boot' + str(boot) + sample_file[-4:]
np.savetxt(s_file, param_values, delimiter=' ')
# Repeat samples for scenario
full_params = []
for scen in scenarios:
for i_set, param_set in enumerate(param_values):
full_params += [np.insert(param_set, 0, scen).tolist()]
# Add boot number
full_params = [
np.insert(param_set, 0, boot).tolist()
for i_sample, param_set in enumerate(full_params)
]
# Add indices of sample
full_params = [
np.insert(param_set, 0, i_sample).tolist()
for i_sample, param_set in enumerate(full_params)
]
# Save full parameter values
np.savetxt(s_file[:-4] + '_full' + s_file[-4:],
full_params,
delimiter=' ')
def test_regression_rbd_fast():
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = latin.sample(problem, 10000)
Y = Ishigami.evaluate(param_values)
Si = rbd_fast.analyze(problem, param_values, Y, print_to_console=False)
assert_allclose(Si['S1'], [0.31, 0.44, 0.00], atol=5e-2, rtol=1e-1)
def test_optimal_trajectories_lt_samples(setup_param_file):
parameter_file = setup_param_file
problem = read_param_file(parameter_file)
samples = 10
num_levels = 4
with raises(ValueError):
sample(problem, samples, num_levels, optimal_trajectories=samples)
def test_regression_rbd_fast():
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = latin.sample(problem, 10000)
Y = Ishigami.evaluate(param_values)
Si = rbd_fast.analyze(problem, param_values, Y, print_to_console=False)
assert_allclose(Si['S1'], [0.31, 0.44, 0.00], atol=5e-2, rtol=1e-1)
def cli_action(args):
rd.seed(args.seed)
problem = read_param_file(args.paramfile)
param_values = sample(problem, args.samples, args.levels,
args.k_optimal, args.local)
np.savetxt(args.output, param_values, delimiter=args.delimiter,
fmt='%.' + str(args.precision) + 'e')
def cli_action(args):
problem = read_param_file(args.paramfile)
Y = np.loadtxt(args.model_output_file,
delimiter=args.delimiter, usecols=(args.column,))
X = np.loadtxt(args.model_input_file, delimiter=args.delimiter, ndmin=2)
if len(X.shape) == 1:
X = X.reshape((len(X), 1))
analyze(problem, X, Y, (args.max_order == 2), print_to_console=True,
seed=args.seed)
def sobol_index(input_filename, N, B):
import sys
import numpy as np
import time
sys.path.append('./SALib-master')
from SALib.analyze import sobol
from SALib.util import read_param_file
start = time.time()
Y_names = ['NPV_Abat.txt', 'NPV_Dam.txt']
#Load in data
filename = "SALib/%s" % input_filename
problem = read_param_file(filename, ' ')
S1 = np.zeros((29, 2))
S1_conf = np.zeros((29, 2))
S2 = np.zeros((29, 29, 2))
S2_conf = np.zeros((29, 29, 2))
ST = np.zeros((29, 2))
ST_conf = np.zeros((29, 2))
cnt = 0
for i in range(2):
filename = Y_names[i]
Y = np.loadtxt(filename)
Y = Y[:, 17] #2200
Si = sobol.analyze(problem,
Y,
calc_second_order=True,
conf_level=0.95,
num_resamples=B,
print_to_console=False,
parallel=True,
n_processors=15)
S1[:, cnt] = Si.get("S1")
S1_conf[:, cnt] = Si.get("S1_conf")
S2[:, :, cnt] = Si.get("S2")
S2_conf[:, :, cnt] = Si.get("S2_conf")
ST[:, cnt] = Si.get("ST")
ST_conf[:, cnt] = Si.get("ST_conf")
cnt = cnt + 1
filename = "Dam_%i.txt" % N
np.savez(filename,
S1=S1,
S1_conf=S1_conf,
S2=S2,
S2_conf=S2_conf,
ST=ST,
ST_conf=ST_conf)
end = time.time()
print(end - start)
def test_even_num_levels_no_warning(setup_param_file_with_groups):
parameter_file = setup_param_file_with_groups
problem = read_param_file(parameter_file)
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
# Trigger a warning.
sample(problem, 10, num_levels=4)
# Verify some things
assert len(w) == 0
def test_optimal_trajectories_lt_samples():
parameter_file = setup_param_file()
problem = read_param_file(parameter_file)
samples = 10
num_levels = 4
grid_jump = 2
sample(problem, samples, num_levels, grid_jump, \
optimal_trajectories=samples)
def test_tab_readfile_whitespace(setup_tab_param_file_espace_names):
'''
A tab delimited parameter file with whitespace in the names
'''
filename = setup_tab_param_file_espace_names
pf = read_param_file(filename)
assert_equal(pf['bounds'], [[0, 100], [5, 51]])
assert_equal(pf['num_vars'], 2)
assert_equal(pf['names'], ['Test 1', 'Test 2'])
def test_optimal_trajectories_lt_samples(setup_param_file):
parameter_file = setup_param_file
problem = read_param_file(parameter_file)
samples = 10
num_levels = 4
with raises(ValueError):
sample(problem, samples, num_levels,
optimal_trajectories=samples)
def test_readfile_group_dist(setup_param_file_group_dist):
'''
Tests a parameter file with groups and distributions is read correctly
'''
filename = setup_param_file_group_dist
pf = read_param_file(filename)
assert_equal(pf['bounds'], [[0, 100], [5, 51], [10, 1]])
assert_equal(pf['num_vars'], 3)
assert_equal(pf['names'], ['Test1', 'Test2', 'Test3'])
assert_equal(pf['groups'], ['Group1', 'Group1', 'Group2'])
assert_equal(pf['dists'], ['unif', 'triang', 'norm'])
def test_readfile(setup_function):
'''
Tests a standard parameter file is read correctly
'''
filename = setup_function
pf = read_param_file(filename)
assert_equal(pf['bounds'], [[0, 100], [5, 51]])
assert_equal(pf['num_vars'], 2)
assert_equal(pf['names'], ['Test1', 'Test2'])
def test_optimised_trajectories_without_groups():
"""
Tests that the optimisation problem gives
the same answer as the brute force problem
(for small values of `k_choices` and `N`),
particularly when there are two or more identical
trajectories
"""
N = 6
param_file = "SALib/tests/test_params.txt"
problem = read_param_file(param_file)
num_levels = 4
k_choices = 4
num_params = problem['num_vars']
groups = problem['groups']
# 6 trajectories, with 5th and 6th identical
input_sample = np.array([[ 0.33333333, 0.66666667],
[ 1. ,0.66666667],
[ 1. ,0. ],
[ 0. ,0.33333333],
[ 0. ,1. ],
[ 0.66666667 ,1. ],
[ 0.66666667 ,0.33333333],
[ 0.66666667 ,1. ],
[ 0. ,1. ],
[ 0.66666667 ,1. ],
[ 0.66666667 ,0.33333333],
[ 0. ,0.33333333],
[ 1. ,1. ],
[ 1. ,0.33333333],
[ 0.33333333 ,0.33333333],
[ 1. ,1. ],
[ 1. ,0.33333333],
[ 0.33333333 ,0.33333333]], dtype=np.float32)
print(input_sample)
# From gurobi optimal trajectories
actual = return_max_combo(input_sample,
N,
num_params,
k_choices,
groups)
desired = find_optimum_combination(input_sample,
N,
num_params,
k_choices,
groups)
assert_equal(actual, desired)
def test_group_in_param_file_read(setup_param_file_with_groups):
'''
Tests that groups in a parameter file are read correctly
'''
parameter_file = setup_param_file_with_groups
problem = read_param_file(parameter_file)
groups, group_names = compute_groups_matrix(problem['groups'])
assert_equal(problem['names'], ["Test 1", "Test 2", "Test 3"])
assert_equal(groups, np.array([[1, 0], [1, 0], [0, 1]], dtype=np.int))
assert_equal(group_names, ['Group 1', 'Group 2'])
def test_readfile(setup_function):
'''
Tests a standard parameter file is read correctly
'''
filename = setup_function
pf = read_param_file(filename)
assert_equal(pf['bounds'], [[0, 100], [5, 51]])
assert_equal(pf['num_vars'], 2)
assert_equal(pf['names'], ['Test1', 'Test2'])
def test_readfile_group_dist(setup_param_file_group_dist):
'''
Tests a parameter file with groups and distributions is read correctly
'''
filename = setup_param_file_group_dist
pf = read_param_file(filename)
assert_equal(pf['bounds'], [[0, 100], [5, 51], [10, 1]])
assert_equal(pf['num_vars'], 3)
assert_equal(pf['names'], ['Test1', 'Test2', 'Test3'])
assert_equal(pf['groups'], ['Group1', 'Group1', 'Group2'])
assert_equal(pf['dists'], ['unif', 'triang', 'norm'])
def test_tab_readfile_whitespace(setup_tab_param_file_espace_names):
'''
A tab delimited parameter file with whitespace in the names
'''
filename = setup_tab_param_file_espace_names
pf = read_param_file(filename)
assert_equal(pf['bounds'], [[0, 100], [5, 51]])
assert_equal(pf['num_vars'], 2)
assert_equal(pf['names'], ['Test 1', 'Test 2'])
def test_regression_dgsm():
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = finite_diff.sample(problem, 10000, delta=0.001)
Y = Ishigami.evaluate(param_values)
Si = dgsm.analyze(problem, param_values, Y,
conf_level=0.95, print_to_console=False)
assert_allclose(Si['dgsm'], [2.229, 7.066, 3.180], atol=5e-2, rtol=1e-1)
def test_optimised_trajectories_without_groups(setup_function):
"""
Tests that the optimisation problem gives
the same answer as the brute force problem
(for small values of `k_choices` and `N`),
particularly when there are two or more identical
trajectories
"""
N = 6
param_file = setup_function
problem = read_param_file(param_file)
k_choices = 4
num_params = problem['num_vars']
groups = problem['groups']
# 6 trajectories, with 5th and 6th identical
input_sample = np.array([[0.33333333, 0.66666667],
[1., 0.66666667],
[1., 0.],
[0., 0.33333333],
[0., 1.],
[0.66666667, 1.],
[0.66666667, 0.33333333],
[0.66666667, 1.],
[0., 1.],
[0.66666667, 1.],
[0.66666667, 0.33333333],
[0., 0.33333333],
[1., 1.],
[1., 0.33333333],
[0.33333333, 0.33333333],
[1., 1.],
[1., 0.33333333],
[0.33333333, 0.33333333]], dtype=np.float32)
# print(input_sample)
# From gurobi optimal trajectories
strategy = GlobalOptimisation()
actual = strategy.return_max_combo(input_sample,
N,
num_params,
k_choices)
local_strategy = BruteForce()
desired = local_strategy.brute_force_most_distant(input_sample,
N,
num_params,
k_choices,
groups)
assert_equal(actual, desired)
def test_regression_dgsm():
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = finite_diff.sample(problem, 10000, delta=0.001)
Y = Ishigami.evaluate(param_values)
Si = dgsm.analyze(problem, param_values, Y,
conf_level=0.95, print_to_console=False)
assert_allclose(Si['dgsm'], [2.229, 7.066, 3.180], atol=5e-2, rtol=1e-1)
def test_csv_readfile_with_whitespace():
'''
A comma delimited parameter file with whitespace in the names
'''
filename = setup_csv_param_file_with_whitespace_in_names()
pf = read_param_file(filename)
assert_equal(pf['bounds'], [[0, 100], [5, 51]])
assert_equal(pf['num_vars'], 2)
assert_equal(pf['names'], ['Test 1', 'Test 2'])
def test_optimal_trajectories_lt_10(setup_param_file):
parameter_file = setup_param_file
problem = read_param_file(parameter_file)
samples = 10
num_levels = 4
grid_jump = 2
optimal_trajectories = 11
with raises(ValueError):
sample(problem, samples, num_levels, grid_jump,
optimal_trajectories=optimal_trajectories)
def test_group_in_param_file_read(setup_param_file_with_groups):
'''
Tests that groups in a parameter file are read correctly
'''
parameter_file = setup_param_file_with_groups
problem = read_param_file(parameter_file)
groups, group_names = compute_groups_matrix(
problem['groups'])
assert_equal(problem['names'], ["Test 1", "Test 2", "Test 3"])
assert_equal(groups, np.array([[1, 0], [1, 0], [0, 1]], dtype=np.int))
assert_equal(group_names, ['Group 1', 'Group 2'])
def test_regression_delta():
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = latin.sample(problem, 10000)
Y = Ishigami.evaluate(param_values)
Si = delta.analyze(problem, param_values, Y, num_resamples=10,
conf_level=0.95, print_to_console=True)
assert_allclose(Si['delta'], [0.210, 0.358, 0.155], atol=5e-2, rtol=1e-1)
assert_allclose(Si['S1'], [0.31, 0.44, 0.00], atol=5e-2, rtol=1e-1)
def test_group_in_param_file_read():
'''
Tests that groups in a parameter file are read correctly
'''
parameter_file = setup_param_file_with_groups()
problem = read_param_file(parameter_file)
groups, group_names = compute_groups_matrix(problem['groups'],
problem['num_vars'])
assert_equal(problem['names'], ["Test 1", "Test 2", "Test 3"])
assert_equal(groups, np.matrix('1,0;1,0;0,1', dtype=np.int))
assert_equal(group_names, ['Group 1', 'Group 2'])
def test_csv_readfile_with_whitespace(setup_csv_param_file_space):
'''
A comma delimited parameter file with whitespace in the names
'''
filename = setup_csv_param_file_space
pf = read_param_file(filename)
assert_equal(pf['bounds'], [[0, 100], [5, 51]])
assert_equal(pf['num_vars'], 2)
assert_equal(pf['names'], ['Test 1', 'Test 2'])
def test_regression_delta():
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = latin.sample(problem, 10000)
Y = Ishigami.evaluate(param_values)
Si = delta.analyze(problem, param_values, Y, num_resamples=10,
conf_level=0.95, print_to_console=True)
assert_allclose(Si['delta'], [0.210, 0.358, 0.155], atol=5e-2, rtol=1e-1)
assert_allclose(Si['S1'], [0.31, 0.44, 0.00], atol=5e-2, rtol=1e-1)
def test_regression_sobol_parallel():
param_file = 'SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = saltelli.sample(problem, 10000, calc_second_order=True)
Y = Ishigami.evaluate(param_values)
Si = sobol.analyze(problem, Y,
calc_second_order=True, parallel=True, conf_level=0.95, print_to_console=False)
assert_allclose(Si['S1'], [0.31, 0.44, 0.00], atol=5e-2, rtol=1e-1)
assert_allclose(Si['ST'], [0.55, 0.44, 0.24], atol=5e-2, rtol=1e-1)
assert_allclose([Si['S2'][0][1], Si['S2'][0][2], Si['S2'][1][2]], [0.00, 0.25, 0.00], atol=5e-2, rtol=1e-1)
def test_csv_readfile_comments(setup_csv_param_file_space_comments):
'''
'''
filename = setup_csv_param_file_space_comments
pf = read_param_file(filename)
print(pf['bounds'], pf['num_vars'], pf['names'])
assert_equal(pf['bounds'], [[0, 100], [5, 51]])
assert_equal(pf['num_vars'], 2)
assert_equal(pf['names'], ['Test 1', 'Test 2'])
def test_csv_readfile_comments(setup_csv_param_file_space_comments):
'''
'''
filename = setup_csv_param_file_space_comments
pf = read_param_file(filename)
print(pf['bounds'], pf['num_vars'], pf['names'])
assert_equal(pf['bounds'], [[0, 100], [5, 51]])
assert_equal(pf['num_vars'], 2)
assert_equal(pf['names'], ['Test 1', 'Test 2'])
def test_odd_num_levels_raises_warning(setup_param_file_with_groups):
parameter_file = setup_param_file_with_groups
problem = read_param_file(parameter_file)
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
# Trigger a warning.
sample(problem, 10, num_levels=3)
# Verify some things
assert len(w) == 1
assert issubclass(w[-1].category, UserWarning)
assert "num_levels should be an even number, sample may be biased" in str(
w[-1].message)
def generate_parameter_set(parameters,
scenarios,
parameter_range_file='param_range_SA.txt',
sample_file='morris_input.txt',
num_trajectories=10,
num_levels=10,
grid_jump=5,
optimal_trajectories=None,
nboots=5):
""" Generate the file with samples for the analysis of Morris.
Parameters
----------
parameters: OrderedDict([('name', [min, max])])
Names and variation range of quantitative parameters
scenarios: list[tuple(year, variety)]
Years and varieties of wheat on which SA is repeated
"""
# Reset parameter range file
open(parameter_range_file, 'w').close()
generate_parameter_range_file(parameters=parameters,
filename=parameter_range_file)
# Generate samples
problem = read_param_file(parameter_range_file)
for boot in range(nboots):
param_values = sample(problem, N=num_trajectories,
num_levels=num_levels, grid_jump=grid_jump,
optimal_trajectories=optimal_trajectories)
# For Method of Morris, save the parameter values in a file (they are needed in the analysis)
s_file = sample_file[:-4] + '_boot' + str(boot) + sample_file[-4:]
np.savetxt(s_file, param_values, delimiter=' ')
# Repeat samples for scenario
full_params = []
for scen in scenarios:
for i_set, param_set in enumerate(param_values):
full_params += [np.insert(param_set, 0, scen).tolist()]
# Add boot number
full_params = [np.insert(param_set, 0, boot).tolist()
for i_sample, param_set in enumerate(full_params)]
# Add indices of sample
full_params = [np.insert(param_set, 0, i_sample).tolist()
for i_sample, param_set in enumerate(full_params)]
# Save full parameter values
np.savetxt(s_file[:-4] + '_full' + s_file[-4:],
full_params, delimiter=' ')
def test_regression_sobol_parallel():
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = saltelli.sample(problem, 10000, calc_second_order=True)
Y = Ishigami.evaluate(param_values)
Si = sobol.analyze(problem, Y,
calc_second_order=True, parallel=True,
conf_level=0.95, print_to_console=False)
assert_allclose(Si['S1'], [0.31, 0.44, 0.00], atol=5e-2, rtol=1e-1)
assert_allclose(Si['ST'], [0.55, 0.44, 0.24], atol=5e-2, rtol=1e-1)
assert_allclose([Si['S2'][0][1], Si['S2'][0][2], Si['S2'][1][2]], [
0.00, 0.25, 0.00], atol=5e-2, rtol=1e-1)
def test_regression_morris_groups(self, set_seed):
set_seed
param_file = 'src/SALib/test_functions/params/Ishigami_groups.txt'
problem = read_param_file(param_file)
param_values = sample(problem=problem, N=10000,
num_levels=4,
optimal_trajectories=None)
Y = Ishigami.evaluate(param_values)
Si = morris.analyze(problem, param_values, Y,
conf_level=0.95, print_to_console=False,
num_levels=4)
assert_allclose(Si['mu_star'], [7.610322, 10.197014],
atol=0, rtol=1e-5)
def test_raise_error_if_k_gt_N(setup_function):
"""Check that an error is raised if `k_choices` is greater than
(or equal to) `N`
"""
N = 4
param_file = setup_function
problem = read_param_file(param_file)
num_levels = 4
k_choices = 6
morris_sample = _sample_oat(problem, N, num_levels)
with raises(ValueError):
_compute_optimised_trajectories(problem,
morris_sample,
N,
k_choices,
local_optimization=False)
def test_regression_morris_vanilla(self, set_seed):
"""Note that this is a poor estimate of the Ishigami
function.
"""
set_seed
param_file = 'src/SALib/test_functions/params/Ishigami.txt'
problem = read_param_file(param_file)
param_values = sample(problem, 10000, 4,
optimal_trajectories=None)
Y = Ishigami.evaluate(param_values)
Si = morris.analyze(problem, param_values, Y,
conf_level=0.95, print_to_console=False,
num_levels=4)
assert_allclose(Si['mu_star'], [7.536586, 7.875, 6.308785],
atol=0, rtol=1e-5)
def test_raise_error_if_k_gt_N():
"""
Check that an error is raised if `k_choices` is greater than (or equal to) `N`
"""
N = 4
param_file = "SALib/tests/test_params.txt"
problem = read_param_file(param_file)
num_levels = 4
grid_jump = num_levels / 2
k_choices = 6
morris_sample = sample_oat(problem, N, num_levels, grid_jump)
compute_optimised_trajectories(problem,
morris_sample,
N,
k_choices)
def Create_LHS_parameter_set(nsamples):
from SALib.sample import latin_hypercube
from SALib.util import scale_samples, read_param_file
import random as rd
# Set random seed (does not affect quasi-random Sobol sampling)
seed = 1
np.random.seed(seed)
rd.seed(seed)
#Define parameters and ranges
parameters = ordereddict.OrderedDict()
parameters['log10m'] = [np.log10(0.001),np.log10(0.1)]
parameters['lnTe'] = [np.log(np.exp(-8.0)/3600.0),np.log(np.exp(8.0)/3600.0)]
parameters['log10soil'] = [np.log10(1.0),np.log10(2.00)]
parameters['sdmax'] = [0.1,2.0] #dtopmodel
#Make directory
if os.path.exists('LHS') == False:
os.mkdir('LHS')
#Prepare file with parameter range
fp = open('LHS/parameters.txt','w')
vars = []
for var in parameters:
vars.append(var)
fp.write('%s %f %f\n' % (var,parameters[var][0],parameters[var][1]))
fp.close()
#Read the parameter range file and generate samples
param_file = 'LHS/parameters.txt'
pf = read_param_file(param_file)
#Generate samples (choose method here)
param_values = latin_hypercube.sample(nsamples, pf['num_vars'])
#Samples are given in range [0, 1] by default. Rescale them to your parameter bounds.
scale_samples(param_values, pf['bounds'])
#Save parameters to file
np.savetxt('LHS/LHS_sampling.txt', param_values, delimiter=' ',header=" ".join(vars))
return
