Esempio n. 1
0
def test_latin_sample_seed():
    N, problem = problem_setup()

    sample1 = latin.sample(problem, N, seed=None)
    sample2 = latin.sample(problem, N, seed=123)

    np.testing.assert_equal(np.any(np.not_equal(sample1, sample2)), True)
Esempio n. 2
0
def make_samples_for_row(row,
                         model,
                         fixed_parameters,
                         parameter_bounds={},
                         analysis_type='sobol',
                         N=1000,
                         **kwargs):
    '''
    Supporting function for sample_and_integrate. Do not run.
    row must be a pandas Series
    
    :meta private:
    '''

    param_names = model['params']
    base_value = row[param_names]
    to_permute = [p for p in param_names if p not in fixed_parameters]
    to_keep = [p for p in param_names if p in fixed_parameters]
    if parameter_bounds:
        bounds = np.array([parameter_bounds[p] for p in to_permute])
    else:
        bounds = [[base_value[p] / 10, base_value[p] * 10] for p in to_permute]

    problem = {
        'num_vars': len(to_permute),
        'names': to_permute,
        'bounds': bounds,
    }

    if analysis_type == 'sobol':
        new_values = saltelli.sample(problem, N, **kwargs)
    elif analysis_type == 'fast':
        new_values = fast_sampler.sample(problem, N, **kwargs)
    elif analysis_type == 'delta':
        new_values = latin.sample(problem, N)
    elif analysis_type == 'rbd-fast':
        new_values = latin.sample(problem, N)
    else:
        raise Exception(
            'Could not find analyzer. analysis_type must be sobol, fast, rbd-fast or delta.'
        )

    new_values = pd.DataFrame(new_values, columns=to_permute)

    fixed_parametersped_values = np.repeat(
        base_value[to_keep].values[np.newaxis, :], len(new_values), 0)

    samples = np.concatenate((new_values, fixed_parametersped_values), axis=1)
    samples = pd.DataFrame(samples, columns=to_permute + to_keep)
    samples = samples[param_names]

    return samples, problem
Esempio n. 3
0
    def redraw(self, random_method: str):
        """Redraw the random number with the given method

        :param random_method: the random method to use

        """
        problem = {
            "num_vars": self.num_dim,
            "names": list(range(self.num_dim)),
            "bounds": [[0, 1]] * self.num_dim,
        }
        if random_method == "pseudo_random":
            seq = np.random.random((self.bucket_size, 2))
        elif random_method == "sobol_sequence":
            seq = sobol_sequence.sample(self.bucket_size, 2)
        elif random_method == "saltelli":
            seq = saltelli.sample(problem, self.bucket_size, calc_second_order=False)
        elif random_method == "latin_hypercube":
            seq = latin.sample(problem, self.bucket_size)
        elif random_method == "finite_differences":
            seq = finite_diff.sample(problem, self.bucket_size)
        elif random_method == "fast":
            seq = fast_sampler.sample(problem, self.bucket_size, M=45)
        else:
            raise ValueError(f"Unknown random method {random_method}")
        self.random_draws[random_method] = seq
Esempio n. 4
0
def test_regression_hdmr_case1():
    problem = {
        'num_vars': 5,
        'names': ['x1', 'x2', 'x3', 'x4', 'x5'],
        'bounds': [[0, 1] * 5]
    }
    X = latin.sample(problem, 10000)
    Y = linear_model_1.evaluate(X)
    options = {
        'maxorder': 2,
        'maxiter': 100,
        'm': 2,
        'K': 1,
        'R': 10000,
        'alpha': 0.95,
        'lambdax': 0.01,
        'print_to_console': False
    }
    Si = hdmr.analyze(problem, X, Y, **options)
    assert_allclose(Si['Sa'][0:problem['num_vars']], [0.20] * 5,
                    atol=5e-2,
                    rtol=1e-1)
    assert_allclose(Si['ST'][0:problem['num_vars']], [0.20] * 5,
                    atol=5e-2,
                    rtol=1e-1)
Esempio n. 5
0
def fix_group_ranking(input_path, variable, output_path, samples, values,
                      partial_order, index_product, problem, x_fix,
                      x_fix_adjust, num_pce, seed, sample_range,
                      product_uniform, filename):
    # Calculate the corresponding number of bootstrap with use of group_fix
    x_sample = latin.sample(problem, sample_range, seed=88).T
    np.savetxt(f'{output_path}metric_samples.txt', x_sample)
    # if reduce parameters, change samples
    if (variable.num_vars()) == 11:
        x_sample = adjust_sampling(x_sample, index_product, x_fix)

    conf_uncond, error_dict, pool_res, y_uncond = {}, {}, {}, {}
    rand = np.random.randint(
        0, x_sample.shape[1], size=(500, x_sample.shape[1]))
    ci_bounds = [0.025, 0.975]

    import pickle
    approx_list_all = pickle.load(
        open(f'{output_path}{filename}-approx-list.pkl', "rb"))
    for key, value in partial_order.items():
        print(key, value)
        #pce_list = []
        pce_list = approx_list_all[key]
        num_pce = len(pce_list)
        cv_temp = np.zeros(num_pce)
        y_temp = np.zeros(shape=(num_pce, x_sample.shape[1]))
        _, sample_size = key.split('_')[0], int(key.split('_')[1])
        #from pyapprox.utilities import get_random_k_fold_sample_indices
        
        print(f'------------Training samples: {sample_size}--------------')
        for i in range(num_pce):
            poly = pce_list[i]
            y_temp[i, :] = poly(x_sample).flatten()
            cv_temp[i] = np.sqrt(poly.variance())[0] / poly.mean()[0]
            
        y_uncond[key] = y_temp
        # Note Now this does not use the same cross validation folds
        # as used to build the PCE but this should be ok
        conf_uncond[key] = uncond_cal(y_uncond[key], ci_bounds, rand)
        conf_uncond[key]['cv'] = cv_temp[i].mean()
        conf_uncond[key]['cv_low'], conf_uncond[key]['cv_up'] = \
            np.quantile(cv_temp, ci_bounds)
        error_dict[key], pool_res = group_fix(
            value, pce_list, x_sample, y_uncond[key], x_fix_adjust, rand, {},
            file_exist=True)
    # End for

    # # separate confidence intervals into separate dicts and write results
    save_path = f'{output_path}{product_uniform}/'
    if not os.path.exists(save_path): os.mkdir(save_path)
    # convert the result into dataframe
    key_outer = list(error_dict.keys())
    f_names = list(error_dict[key_outer[0]].keys())
    for ele in f_names:
        dict_measure = {key: error_dict[key][ele] for key in key_outer}
        df = to_df(partial_order, dict_measure)
        df.to_csv(f'{save_path}/{ele}.csv')

    with open(f'{save_path}y_uncond_stats.json', 'w') as fp:
        json.dump(conf_uncond, fp, indent=2)
Esempio n. 6
0
def prepare_sens_analysis(storm_name_list=[]):
    """ Function to prepare the sensitivity analysis for a country.
    
    Arguments:
        *storm_name_list* (list) -- list of storms to include in sensitivity analysis. If kept empty, default storms will be used.
    
    Returns:
        *param_values* (list) -- list of 5000 combinations of parameter values to be used in sensitivity analysis.
        
        *storm_name_list* (list) -- list of storms to include in sensitivity analysis.
    
    """

    # set parameters for sensitivity analysis
    problem = {
        'num_vars': 5,
        'names': ['c2', 'c3', 'c4', 'lu1', 'lu2'],
        'bounds': [[0, 100], [0, 100], [0, 100], [0, 50], [0, 50]]
    }

    param_values = latin.sample(problem, 5000)

    # rescale parameters for vulnerability curves (should add up to 100)
    rescale = param_values[:, :3]
    for i in range(len(rescale)):
        inb = (rescale[i] * 100) / sum(rescale[i])
        param_values[i, :3] = inb

    # select storms to assess
    if len(storm_name_list) == 0:
        storm_name_list = [
            '19991203', '19900125', '20090124', '20070118', '19991226'
        ]

    return param_values, storm_name_list
def sample_parameters(problem: dict, seed: int, method: str):
    if method == "FAST":
        return fast_sampler.sample(problem, seed)
    if method == "sobol":
        return saltelli.sample(problem, seed)
    if (method == "RBD_FAST") or (method == "DMIM"):
        return latin.sample(problem, seed)
Esempio n. 8
0
def test_rbd_to_df():
    params = ['x1', 'x2', 'x3']
    problem = {
        'num_vars':
        3,
        'names':
        params,
        'groups':
        None,
        'bounds': [[-3.14159265359, 3.14159265359],
                   [-3.14159265359, 3.14159265359],
                   [-3.14159265359, 3.14159265359]]
    }

    param_values = latin.sample(problem, 1000)
    Y = Ishigami.evaluate(param_values)
    Si = rbd_fast.analyze(problem, Y, param_values, print_to_console=False)
    Si_df = Si.to_df()

    assert isinstance(Si_df, pd.DataFrame), \
        "RBD Si: Expected DataFrame, got {}".format(type(Si_df))
    assert set(Si_df.index) == set(params), "Incorrect index in DataFrame"

    col_names = set(['S1'])
    assert set(Si_df.columns) == col_names, \
        "Unexpected column names in DataFrame. Expected {}, got {}".format(
            col_names, Si_df.columns)
Esempio n. 9
0
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)
Esempio n. 10
0
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)
Esempio n. 11
0
    def fit(self, X, y):
        """
        Fits the regressor to the data `(X, y)` and performs a sensitivity analysis on the result of the regression.

        :param X: Training data
        :param y: Target values
        :return: `self`
        """
        from numpy import argpartition
        N = len(X[0])
        if (self.domain is None) or (self.probs is None):
            self._avg_fucn(X, y)
        if self.regressor is None:
            from sklearn.svm import SVR
            self.regressor = SVR()
        self.regressor.fit(self.domain, self.probs)
        bounds = [[
            min(self.domain[:, idx]) - self.margin,
            max(self.domain[:, idx]) + self.margin
        ] for idx in range(N)]
        problem = dict(num_vars=N,
                       names=['x%d' % idx for idx in range(N)],
                       bounds=bounds)
        res = []
        if self.method == 'sobol':
            from SALib.sample import saltelli
            from SALib.analyze import sobol
            param_values = saltelli.sample(problem, self.num_smpl)
            y_ = self.regressor.predict(param_values)
            res = sobol.analyze(problem, y_)['ST']
            self.weights_ = res
        elif self.method == 'morris':
            from SALib.sample import morris as mrs
            from SALib.analyze import morris
            param_values = mrs.sample(problem,
                                      self.num_smpl,
                                      num_levels=self.num_levels)
            y_ = self.regressor.predict(param_values)
            res = morris.analyze(problem,
                                 param_values,
                                 y_,
                                 num_levels=self.num_levels)['mu_star']
            self.weights_ = res
        elif self.method == 'delta-mmnt':
            from SALib.sample import latin
            from SALib.analyze import delta
            param_values = latin.sample(problem, self.num_smpl)
            y_ = self.regressor.predict(param_values)
            res = delta.analyze(problem,
                                param_values,
                                y_,
                                num_resamples=self.num_resmpl)['delta']
            self.weights_ = res
        self.top_features_ = argpartition(
            res, -self.n_features_to_select)[-self.n_features_to_select:]
        return self
Esempio n. 12
0
    def test_latin_sample_trivial(self):

        problem = {'num_vars': 1, 'bounds': [[0, 1]], 'names': ['var1']}

        actual = sample(problem, 10, seed=42)
        expected = np.array([[0.8601115], [0.27319939], [0.03745401],
                             [0.60580836], [0.78661761], [0.97080726],
                             [0.35986585], [0.19507143], [0.41560186],
                             [0.51559945]])
        np.testing.assert_allclose(actual, expected)
Esempio n. 13
0
def RBD_FAST_analysis(network, num_samples, prob_def):
    print("Sampling via RBD-FAST...")
    samples = latin.sample(prob_def, num_samples)
    X = samples
    samples = np.split(samples, samples.shape[1], axis=1)
    samples = [s.squeeze() for s in samples]
    values = {n: torch.tensor(s) for n, s in zip(prob_def["names"], samples)}
    print("Running GrFN..")
    Y = network.run(values).numpy()
    print("Analyzing via RBD ...")
    return rbd_fast.analyze(prob_def, Y, X, print_to_console=True)
Esempio n. 14
0
def populate():
    # 'parameters' dictionary stores each line in the model
    par_keys = list(parameters.keys())

    # init problem definiton
    seed = int(opts['seed'])
    levels = int(opts['p_levels'])

    problem = {
        'names': opts['par_name'],
        'num_vars': len(opts['par_name']),
        'bounds': [],
    }

    # define bounds following the model configuration
    for line in range(len(par_keys)):
        if parameters[line][0] == 'par':
            if parameters[line][3] == 'range':
                lower = float(parameters[par_keys[line]][4])
                upper = float(parameters[par_keys[line]][5])
            if parameters[line][3] == 'factor':
                lower = float(parameters[line][2]) * (
                    1 - float(parameters[par_keys[line]][4]))
                upper = float(parameters[line][2]) * (
                    1 + float(parameters[par_keys[line]][5]))
            problem['bounds'].append([lower, upper])

    # create samples to simulate
    if opts['method'] == 'sobol':
        models = saltelli.sample(problem=problem,
                                 N=levels,
                                 calc_second_order=True,
                                 seed=seed)
    elif opts['method'] == 'fast':
        models = fast_sampler.sample(problem=problem, N=levels, seed=seed)
    elif opts['method'] == 'rbd-fast' or opts['method'] == 'delta' or opts[
            'method'] == 'dgsm':
        models = latin.sample(problem=problem, N=levels, seed=seed)
    elif opts['method'] == 'morris':
        models = morris_sample(problem=problem, N=levels)
    elif opts['method'] == 'frac':
        models = ff_sample(problem, seed=seed)
    else:
        error_msg = 'Wrong method name.'
        print(error_msg)
        raise ValueError(error_msg)

    population = {}
    # add samples to population dict
    population['problem', 'samples'] = models
    # add problem definition to population dict
    population['problem', 'definition'] = problem

    return population
    def analyze(self):
        """Initiate the analysis, and stores the result at data directory.

        Generates:
            Analysis result at 'acbm/data/output/delta.txt'.

        """

        X = latin.sample(self.problem, self.n_samples, seed=self.seed_sample)
        Y = ACBM.evaluate(X)
        si = delta.analyze(self.problem, X, Y, seed=self.seed_analyze)
        pickle.dump(si, open(self.path_output + 'delta.txt', 'wb'))
Esempio n. 16
0
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)
Esempio n. 17
0
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)
Esempio n. 18
0
def main(name, c):
    name = name.lower()
    model, par, parameters, bounds, samples_to_take = setups(name)
    problem = {
        'num_vars': len(parameters),
        'names': parameters,
        'bounds': bounds
    }
    params = sample(problem, samples_to_take)

    # Create queues
    done = Queue()
    paramsdiv = []
    p = []
    remaining = 0
    for i in range(0, PROC_NUM):
        x = params.shape[0] / PROC_NUM
        remaining += x - int(x)
        x = int(x)
        y = params[x * i:x *
                   (i + 1), :]  #filling the y with the x parameter sets

        if i == PROC_NUM - 1 and remaining != 0:
            y = np.append(y, params[-int(remaining):, :], axis=0)
        paramsdiv.append(y)
        p.append(
            Process(target=evaluate,
                    args=(paramsdiv[i], model, par, c, done, i)))
        p[i].start()
    print(np.asarray(paramsdiv).shape)

    Ydiv = np.zeros(PROC_NUM).tolist()  #no of processes
    count = 0
    while True:
        temp, no = done.get()
        Ydiv[no] = temp.tolist()
        count += 1
        if count == PROC_NUM:
            break
    Y = []
    for i in range(0, PROC_NUM):
        Y += Ydiv[i]

    Y = np.asarray(Y)
    print(Y.shape)

    #Y = evaluate(params, model, par, c)

    write_file(Y, parameters, name, c, params)
Esempio n. 19
0
    def rbd_fast(self):
        """RBD-FAST sensitivity analysis of the objective function.
        This function estimates the sensitivity with the RBD-FAST method of the
        objective function with changes in the parameters using SALib:
        https://salib.readthedocs.io/en/latest/api.html#rbd-fast-random-balance-designs-fourier-amplitude-sensitivity-test

        Returns:
            dict: sensitivity values of parameters; dict has keys 'S1'
        """
        X, y, problem = self._sensitivity_prep()
        n_sample = 2000
        param_values = latin.sample(problem, n_sample)
        X_s, y_s = self._closest_points(problem, X, y, param_values)
        Si = rbd_fast.analyze(problem, X_s, y_s)
        return Si
Esempio n. 20
0
def test_nonuniform_scale_samples_truncnorm():
    """
    Test the rescaling of samples for truncated normal distribution
    """
    problem = {
        'num_vars': 1,
        'dists': ['truncnorm'],
        'bounds': [[0, 3.14, 2, 1]],
        'names': ['x1']
    }
    actual = latin.sample(problem, 10, seed=42)
    expected = np.array([[2.68693037], [1.34115848], [0.39811064],
                         [2.09477163], [2.49999031], [3.028063], [1.5564238],
                         [1.11686499], [1.68414443], [1.9022482]])
    np.testing.assert_allclose(actual, expected)
Esempio n. 21
0
 def _gen_muestrea(símismo, n, ops):
     if símismo.método == 'sobol':
         return saltelli.sample(problem=símismo.problema, N=n, **ops)
     elif símismo.método == 'fast':
         return fast_sampler.sample(problem=símismo.problema, N=n, **ops)
     elif símismo.método == 'morris':
         return morris_muestra.sample(problem=símismo.problema, N=n, **ops)
     elif símismo.método == 'dmim':
         return latin.sample(problem=símismo.problema, N=n)
     elif símismo.método == 'dgsm':
         return saltelli.sample(problem=símismo.problema, N=n)
     elif símismo.método == 'ff':
         return ff_muestra.sample(problem=símismo.problema)
     else:
         raise ValueError('Método de análisis de sensibilidad "{}" no reconocido.'.format(símismo.método))
Esempio n. 22
0
    def delta(self):
        """Morris Method sensitivity of the objective function.
        This function estimates the sensitivity with the Morris Method of the
        objective function with changes in the parameters using SALib:
        https://salib.readthedocs.io/en/latest/api.html#delta-moment-independent-measure

        Returns:
            dict: sensitivity values of parameters; dict has keys 'delta',
                'delta_conf', 'S1', and 'S1_conf'
        """
        X, y, problem = self._sensitivity_prep()
        n_sample = 2000
        param_values = latin.sample(problem, n_sample)
        X_s, y_s = self._closest_points(problem, X, y, param_values)
        Si = delta.analyze(problem, X_s, y_s)
        return Si
Esempio n. 23
0
def coupled_montecarlo_setup(smps=2, firstTimeStep=166):

    # Get and Save Latin Hypercube Matrix
    problem = get_problem()
    smps_matrix = latin.sample(problem, smps)
    # Normalized matrix (will be re-scaled by phd-model-process)
    saveLHSmatrix(smps_matrix)
    mc_upper = problem['upper']

    for sample_nr in range(1, smps + 1):
        sample_vector = getInputVector(sample_nr - 1, smps_matrix)
        run_coupled_sample(sample_nr,
                           firstTimeStep,
                           sample_vector=sample_vector,
                           mc_upper=mc_upper,
                           couple=True,
                           montecarlo_couple=True)
Esempio n. 24
0
 def redraw(self, random_method):
     problem = {'num_vars': 2, 'names': ['x', 'y'], 'bounds': [[0, 1]] * 2}
     if random_method == 'pseudo_random':
         seq = np.random.random((NUM_DATA_POINTS, 2))
     elif random_method == 'sobol_sequence':
         seq = sobol_sequence.sample(NUM_DATA_POINTS, 2)
     elif random_method == 'saltelli':
         seq = saltelli.sample(problem,
                               NUM_DATA_POINTS,
                               calc_second_order=False)
     elif random_method == 'latin_hypercube':
         seq = latin.sample(problem, NUM_DATA_POINTS)
     elif random_method == 'finite_differences':
         seq = finite_diff.sample(problem, NUM_DATA_POINTS)
     elif random_method == 'fast':
         seq = fast_sampler.sample(problem, NUM_DATA_POINTS, M=45)
     self.random_draws[random_method] = seq
Esempio n. 25
0
def fix_increase_sample(input_path, variable, output_path, samples, values,
                        partial_order, index_product, problem, x_fix, x_fix_adjust, 
                            num_pce, seed, sample_range, product_uniform, filename):
# if reduce parameters, change samples
    key = list(partial_order.keys())[0]
    _, sample_size = key.split('_')
    value = partial_order[key]
    import pickle
    approx_list_all = pickle.load(
        open(f'{output_path}{filename}-approx-list.pkl', "rb"))
    poly_list = [approx_list_all[key][0]]
    conf_uncond, error_dict, pool_res, y_uncond = {}, {}, {}, {}
    ci_bounds = [0.025, 0.975]
    nstart, nstop, nstep = sample_range
    for n in range(nstart, nstop + 1, nstep):
        print(n)
        x_sample = latin.sample(problem, n, seed=88)
        x_sample = x_sample.T
        # if reduce parameters, change samples
        if (variable.num_vars()) == 11:
            x_sample = adjust_sampling(x_sample, index_product, x_fix)
        
        # Calculate the corresponding number of bootstrap with use pf group_fix
        rand = np.random.randint(0, x_sample.shape[1], size=(500, x_sample.shape[1]))
        # add the calculation of y_uncond
        y_uncond_temp = poly_list[0](x_sample).T
        conf_uncond[str(n)] = uncond_cal(y_uncond_temp, ci_bounds, rand)
        conf_uncond[str(n)]['median'] = np.quantile(y_uncond_temp[0][rand], ci_bounds, axis=1).mean(axis=0).mean()
        conf_uncond[str(n)]['mean'] = poly_list[0].mean()[0]
        error_dict[str(n)], pool_res = group_fix(value, poly_list, x_sample, y_uncond_temp, 
                                        x_fix_adjust, rand, {}, file_exist=True)
        # End for

    # separate confidence intervals into separate dicts and write results
    save_path = f'{output_path}{product_uniform}/'
    if not os.path.exists(save_path): os.mkdir(save_path)
    # convert the result into dataframe
    key_outer = list(error_dict.keys())
    f_names = list(error_dict[key_outer[0]].keys())
    for ele in f_names:
        dict_measure = {key: error_dict[key][ele] for key in key_outer}
        df = pd.DataFrame.from_dict(dict_measure)
        df.to_csv(f'{save_path}/{ele}_adaptive.csv')

    df_stats = pd.DataFrame(data=conf_uncond, index=np.arange(nstart, nstop + 1, nstep))
    df_stats.to_csv(f'{save_path}/stats_uncond_adaptive.csv')
Esempio n. 26
0
    def test_latin_sample_two_groups(self):

        problem = {
            'num_vars': 2,
            'bounds': [[0, 1], [0, 1]],
            'names': ['var1', 'var2'],
            'groups': ['group1', 'group2']
        }

        actual = sample(problem, 10, seed=42)
        expected = np.array([[0.17319939,
                              0.85247564], [0.50205845, 0.21559945],
                             [0.4601115, 0.59699099], [0.83042422, 0.71834045],
                             [0.03745401, 0.38661761], [0.7181825, 0.15986585],
                             [0.68324426,
                              0.92912291], [0.30580836, 0.09507143],
                             [0.21560186, 0.47080726], [0.9431945,
                                                        0.62123391]])
        np.testing.assert_allclose(actual, expected)
Esempio n. 27
0
def lhs_uniform_sample(num_vars, num_samples):
    """
    Create uncorrelated uniform samples on the unit interval

    Parameters
    ----------
    num_vars
    num_samples

    Returns
    -------

    """
    samples = lhs.sample(
        {
            'num_vars': num_vars,
            'bounds': [[0, 1] for i in range(num_vars)]
        }, num_samples)

    return samples
Esempio n. 28
0
    def test_latin_sample_no_groups(self):

        problem = {
            'num_vars': 2,
            'bounds': [[0, 1], [0, 1]],
            'names': ['var1', 'var2'],
            'groups': None
        }

        actual = sample(problem, 10, seed=42)
        expected = np.array([[0.86011150,
                              0.15247564], [0.27319939, 0.84560700],
                             [0.03745401,
                              0.73663618], [0.60580836, 0.51394939],
                             [0.78661761,
                              0.46118529], [0.97080726, 0.97851760],
                             [0.35986585,
                              0.03042422], [0.19507143, 0.32912291],
                             [0.41560186, 0.62921446],
                             [0.51559945, 0.24319450]])
        approx(actual, expected)
Esempio n. 29
0
def test_regression_hdmr_ishigami():
    param_file = 'src/SALib/test_functions/params/Ishigami.txt'
    problem = read_param_file(param_file)
    X = latin.sample(problem, 10000)
    Y = Ishigami.evaluate(X)
    options = {
        'maxorder': 2,
        'maxiter': 100,
        'm': 4,
        'K': 1,
        'R': 10000,
        'alpha': 0.95,
        'lambdax': 0.01,
        'print_to_console': False
    }
    Si = hdmr.analyze(problem, X, Y, **options)
    assert_allclose(Si['Sa'][0:problem['num_vars']], [0.31, 0.44, 0.00],
                    atol=5e-2,
                    rtol=1e-1)
    assert_allclose(Si['ST'][0:problem['num_vars']], [0.55, 0.44, 0.24],
                    atol=5e-2,
                    rtol=1e-1)
Esempio n. 30
0
    def sensitivity_analysis(self, N=1000, force=False):
        """Run a RBD-fast sensitivity analysis and return the first order
        indices.

        Keyword Arguments:
            N {int} -- number of sampled used to run the analysis (default: {1000})

        Returns:
            dict -- first order sensitivity indices
        """  # noqa
        if self._expensive and not force:
            raise ValueError("sensitivity analysis should not be done on "
                             "expensive function, but only on metamodel or "
                             "test functions. Use force=True to override that "
                             "behavior")
        X = latin.sample(self._problem, N)
        y = self(X)
        S1 = rbd_fast.analyze(self._problem, y, X)["S1"]
        return dict(sorted([(var, idx)
                            for var, idx
                            in zip(self.inputs, S1)],
                           key=sort_by_values, reverse=True))
Esempio n. 31
0
def sample(**kwargs):
    """
    :param kwargs: dictionary containing the following parameters
    problem_file_path or -prob: path  to a json that contains the problem with parameters and bounds, String
    n_samples or -n: the number of parameter samples that should be returned,
    :return: None
    """
    n_samples = kwargs.get('n_samples')
    problem_file_path = kwargs.get('problem_file_path')
    if kwargs.get('output_file_name'):
        output_file_name = kwargs.get('output_file_name')
    else:
        output_file_name = 'hypercube.json'

    with open(problem_file_path) as json_file:
        problem = json.load(json_file)

    latin_hyper_cube = latin.sample(problem=problem, N=n_samples)
    latin_hyper_cube = latin_hyper_cube.tolist()
    # create list of problems with initial values
    problems = []
    for pars in latin_hyper_cube:
        # transform the necessary parameters into integers
        for idx, p in enumerate(pars):
            if problem['integer'][idx]:
                pars[idx] = round(int(pars[idx]))

        new_problem = copy.deepcopy(problem)
        new_problem['initial'] = pars
        problems.append(new_problem)

    with open(output_file_name, 'w') as f:
        json.dump(problems, f)

    click.echo(
        'Sampling {} samples done, check out the samples here: {}'.format(
            n_samples, output_file_name))
Esempio n. 32
0
def random_sample(args):

    items = args.dimensions
    n = args.n

    f = NamedTemporaryFile(delete=False)

    for i in range(len(items)):
        f.write(str(i) + " 0.501 " + str(items[i] + 0.499) + "\n")

    f.close()

    # Read the parameter range file and generate samples
    problem = read_param_file(f.name)

    # Generate samples
    param_values = latin.sample(problem, n)

    param_rounded = []
    for l in param_values:
        param_rounded.append([int(round(n, 0)) for n in l])

    for i in param_rounded:
        print i
Esempio n. 33
0
def sample_uniforms(model, num_samples=1000, log=[]):

    bounds = []
    names = []
    for name, tuple in model.parameter_distributions.items():
        names.append(name)
        bounds.append(tuple)

    for name, tuple in model.species_distributions.items():
        names.append(name)
        bounds.append(tuple)

    problem = {'num_vars': len(names), 'names': names, 'bounds': bounds}

    problem = salib_problem_to_log_space(problem, log)

    lhc_samples = latin.sample(problem, num_samples)
    lhc_samples = samples_to_normal_space(lhc_samples, problem, log)

    samples = parse_samples(lhc_samples,
                            list(model.parameter_distributions.keys()),
                            list(model.species_distributions.keys()))

    return samples
Esempio n. 34
0
def random_sample(args):
	
	items = args.dimensions
	n = args.n
	
	f = NamedTemporaryFile(delete=False)
	
	for i in range(len(items)):
		f.write(str(i) + " 0.501 " + str(items[i] + 0.499) + "\n")
		
	f.close()

	# Read the parameter range file and generate samples
	problem = read_param_file(f.name)

	# Generate samples
	param_values = latin.sample(problem, n)
	
	param_rounded = []
	for l in param_values:
		param_rounded.append([int(round(n, 0)) for n in l])
	
	for i in param_rounded:
		print i
Esempio n. 35
0
def test_rbd_to_df():
    params = ['x1', 'x2', 'x3']
    problem = {
        'num_vars': 3,
        'names': params,
        'groups': None,
        'bounds': [[-3.14159265359, 3.14159265359],
                   [-3.14159265359, 3.14159265359],
                   [-3.14159265359, 3.14159265359]]
    }

    param_values = latin.sample(problem, 1000)
    Y = Ishigami.evaluate(param_values)
    Si = rbd_fast.analyze(problem, param_values, Y, print_to_console=False)
    Si_df = Si.to_df()

    assert isinstance(Si_df, pd.DataFrame), \
        "RBD Si: Expected DataFrame, got {}".format(type(Si_df))
    assert set(Si_df.index) == set(params), "Incorrect index in DataFrame"

    col_names = set(['S1'])
    assert set(Si_df.columns) == col_names, \
        "Unexpected column names in DataFrame. Expected {}, got {}".format(
            col_names, Si_df.columns)
Esempio n. 36
0
import sys
sys.path.append('../..')

from SALib.analyze import rbd_fast
from SALib.sample import latin
from SALib.test_functions import Ishigami
from SALib.util import read_param_file

# Read the parameter range file and generate samples
problem = read_param_file('../../SALib/test_functions/params/Ishigami.txt')

# Generate samples
param_values = latin.sample(problem, 1000)

# Run the "model" and save the output in a text file
# This will happen offline for external models
Y = Ishigami.evaluate(param_values)

# Perform the sensitivity analysis using the model output
# Specify which column of the output file to analyze (zero-indexed)
Si = rbd_fast.analyze(problem, Y, param_values, print_to_console=False)
# Returns a dictionary with keys 'S1' and 'ST'
# e.g. Si['S1'] contains the first-order index for each parameter, in the
# same order as the parameter file
Esempio n. 37
0
def sa(model, response, policy={}, method="sobol", nsamples=1000, **kwargs):
    if len(model.uncertainties) == 0:
        raise ValueError("no uncertainties defined in model")
    
    problem = { 'num_vars' : len(model.uncertainties),
                'names' : model.uncertainties.keys(),
                'bounds' : [[0.0, 1.0] for u in model.uncertainties],
                'groups' : kwargs.get("groups", None) }

    # estimate the argument N passed to the sampler that produces the requested
    # number of samples
    N = _predict_N(method, nsamples, problem["num_vars"], kwargs)
    
    # generate the samples
    if method == "sobol":
        samples = saltelli.sample(problem, N, **_cleanup_kwargs(saltelli.sample, kwargs))
    elif method == "morris":
        samples = morris_sampler.sample(problem, N, **_cleanup_kwargs(morris_sampler.sample, kwargs))
    elif method == "fast":
        samples = fast_sampler.sample(problem, N, **_cleanup_kwargs(fast_sampler.sample, kwargs))
    elif method == "ff":
        samples = ff_sampler.sample(problem, **_cleanup_kwargs(ff_sampler.sample, kwargs))
    elif method == "dgsm":
        samples = finite_diff.sample(problem, N, **_cleanup_kwargs(finite_diff.sample, kwargs))
    elif method == "delta":
        if "samples" in kwargs:
            samples = kwargs["samples"]
        else:
            samples = latin.sample(problem, N, **_cleanup_kwargs(latin.sample, kwargs))
            
    # convert from samples in [0, 1] to uncertainty domain
    for i, u in enumerate(model.uncertainties):
        samples[:,i] = u.ppf(samples[:,i])
        
    # run the model and collect the responses
    responses = np.empty(samples.shape[0])
    
    for i in range(samples.shape[0]):
        sample = {k : v for k, v in zip(model.uncertainties.keys(), samples[i])}
        responses[i] = evaluate(model, overwrite(sample, policy))[response]
    
    # run the sensitivity analysis method
    if method == "sobol":
        result = sobol.analyze(problem, responses, **_cleanup_kwargs(sobol.analyze, kwargs))
    elif method == "morris":
        result = morris_analyzer.analyze(problem, samples, responses, **_cleanup_kwargs(morris_analyzer.analyze, kwargs))
    elif method == "fast":
        result = fast.analyze(problem, responses, **_cleanup_kwargs(fast.analyze, kwargs))
    elif method == "ff":
        result = ff_analyzer.analyze(problem, samples, responses, **_cleanup_kwargs(ff_analyzer.analyze, kwargs))
    elif method == "dgsm":
        result = dgsm.analyze(problem, samples, responses, **_cleanup_kwargs(dgsm.analyze, kwargs))
    elif method == "delta":
        result = delta.analyze(problem, samples, responses, **_cleanup_kwargs(delta.analyze, kwargs))
         
    # convert the SALib results into a form allowing pretty printing and
    # lookups using the parameter name
    pretty_result = SAResult(result["names"] if "names" in result else problem["names"])
    
    if "S1" in result:
        pretty_result["S1"] = {k : float(v) for k, v in zip(problem["names"], result["S1"])}
    if "S1_conf" in result:
        pretty_result["S1_conf"] = {k : float(v) for k, v in zip(problem["names"], result["S1_conf"])}
    if "ST" in result:
        pretty_result["ST"] = {k : float(v) for k, v in zip(problem["names"], result["ST"])}
    if "ST_conf" in result:
        pretty_result["ST_conf"] = {k : float(v) for k, v in zip(problem["names"], result["ST_conf"])}
    if "S2" in result:
        pretty_result["S2"] = _S2_to_dict(result["S2"], problem)
    if "S2_conf" in result:
        pretty_result["S2_conf"] = _S2_to_dict(result["S2_conf"], problem)
    if "delta" in result:
        pretty_result["delta"] = {k : float(v) for k, v in zip(problem["names"], result["delta"])}
    if "delta_conf" in result:
        pretty_result["delta_conf"] = {k : float(v) for k, v in zip(problem["names"], result["delta_conf"])}
    if "vi" in result:
        pretty_result["vi"] = {k : float(v) for k, v in zip(problem["names"], result["vi"])}
    if "vi_std" in result:
        pretty_result["vi_std"] = {k : float(v) for k, v in zip(problem["names"], result["vi_std"])}
    if "dgsm" in result:
        pretty_result["dgsm"] = {k : float(v) for k, v in zip(problem["names"], result["dgsm"])}
    if "dgsm_conf" in result:
        pretty_result["dgsm_conf"] = {k : float(v) for k, v in zip(problem["names"], result["dgsm_conf"])}
    if "mu" in result:
        pretty_result["mu"] = {k : float(v) for k, v in zip(result["names"], result["mu"])}
    if "mu_star" in result:
        pretty_result["mu_star"] = {k : float(v) for k, v in zip(result["names"], result["mu_star"])}
    if "mu_star_conf" in result:
        pretty_result["mu_star_conf"] = {k : float(v) for k, v in zip(result["names"], result["mu_star_conf"])}
    if "sigma" in result:
        pretty_result["sigma"] = {k : float(v) for k, v in zip(result["names"], result["sigma"])}

    return pretty_result