None:\\n mapie = MapieClassifier(method=method)\\n mapie.fit(X_toy, y_toy)\\n check_is_fitted(\\n mapie,\\n [\\n \\\"single_estimator_\\\",\\n \\\"n_features_in_\\\",\\n \\\"n_samples_val_\\\",\\n \\\"scores_\\\"\\n ]\\n )\",\n \"def test_valid_method(method: str) -> None:\\n mapie = MapieRegressor(method=method)\\n mapie.fit(X_toy, y_toy)\\n check_is_fitted(\\n mapie,\\n [\\n \\\"n_features_in_\\\",\\n \\\"single_estimator_\\\",\\n \\\"estimators_\\\",\\n \\\"k_\\\",\\n \\\"residuals_\\\"\\n ]\\n )\",\n \"def simulate(self, observation_matrix, method=\\\"smoother\\\"):\\n if method == \\\"filter\\\":\\n means = self.filtered_state_means\\n covariances = self.filtered_state_covariances\\n else:\\n means = self.smoothed_state_means\\n covariances = self.smoothed_state_covariances\\n simulated_means = []\\n simulated_variances = []\\n for t, _ in enumerate(means):\\n simulated_means.append(np.dot(observation_matrix, means[t]))\\n var = np.diag(np.dot(observation_matrix,\\n np.dot(covariances[t], observation_matrix.T)))\\n # prevent variances to become less than 0\\n simulated_variances.append(np.maximum(var, 0))\\n return (simulated_means, simulated_variances)\",\n \"def _process_method(self, method):\\n return method\",\n \"def mantra_simulation(lineup, module, mode='ST'):\\n\\n def try_optimal_solution(module, n_of_players_with_vote):\\n\\n \\\"\\\"\\\"\\n If an optimal solution exists this function assign it to the\\n variable \\\"final\\\" which is defined inside MANTRA_simulation but not\\n globally. That's why we refers to it later by using \\\"nonlocal\\\".\\n \\\"\\\"\\\"\\n\\n nonlocal all_lineups\\n nonlocal final_field\\n nonlocal malus\\n\\n # For each candidate\\n for candidate in all_lineups:\\n\\n # We create the list where each player in the combination has only\\n # 1 role\\n candidates_single_role = all_lineups_single_role(candidate)\\n\\n # And test each of these combinations\\n for new_cand in candidates_single_role:\\n\\n # If we find a solution we store the result\\n if find_solution(new_cand, module, n_of_players_with_vote):\\n final_field = new_cand\\n break\\n\\n # And stop the iteration over the other condidates\\n if final_field:\\n malus = 0\\n break\\n\\n def try_efficient_solution(module, n_of_players_with_vote):\\n\\n \\\"\\\"\\\"\\n If an optimal solution is not found we look for an efficient one.\\n In case an efficient solution exists we store the lineup and the\\n module.\\n \\\"\\\"\\\"\\n\\n modules_for_efficient_solution = copy.copy(all_modules)\\n modules_for_efficient_solution.remove(module)\\n\\n nonlocal all_lineups\\n nonlocal final_field\\n nonlocal efficient_module\\n nonlocal malus\\n\\n # Iterate over all the candidates\\n for candidate in all_lineups:\\n candidates_single_role = all_lineups_single_role(candidate)\\n for new_cand in candidates_single_role:\\n\\n # And over all the modules\\n for a_module in modules_for_efficient_solution:\\n\\n # If we find a solution we store the result\\n if find_solution(new_cand, a_module,\\n n_of_players_with_vote):\\n final_field = new_cand\\n efficient_module = a_module\\n break\\n\\n # Stop the iteration over the other permutations\\n if final_field:\\n break\\n\\n # Stop the iteration over the other candidates\\n if final_field:\\n malus = 0\\n break\\n\\n def try_adapted_solution(n_of_players_with_vote):\\n\\n \\\"\\\"\\\"\\n If an efficient solution is not found we look for an adapted one.\\n In case it exists we store the lineup, the module, the number of\\n malus assigned and the other modules that are equally valid.\\n \\\"\\\"\\\"\\n\\n modules_for_adapted_solution = copy.copy(all_modules)\\n\\n nonlocal all_lineups\\n nonlocal final_field\\n nonlocal adapted_module\\n nonlocal malus\\n\\n # As for the efficient case we iterate over:\\n\\n # 1. All the candidates\\n for candidate in all_lineups:\\n candidates_single_role = all_lineups_single_role(candidate)\\n\\n # 2. Each candidate transformed in single role\\n for new_cand in candidates_single_role:\\n\\n # 3. All the modules\\n for a_module in modules_for_adapted_solution:\\n\\n n_malus = find_adapted_solution(\\n new_cand, a_module, n_of_players_with_vote)\\n\\n # If a solution for this candidate with this module exists\\n # AND n_malus is decreased, we store the number of malus,\\n # the module and the lineup\\n if n_malus and n_malus < malus:\\n malus = n_malus\\n adapted_module = a_module\\n final_field = new_cand\\n\\n if malus == 1:\\n # In this case we break the loop because 1 is the\\n # minimum number of malus possible so we are not\\n # interested in iterating over the remaining\\n # candidates\\n break\\n\\n if malus == 1:\\n break\\n if malus == 1:\\n break\\n\\n def look_for_solution(module, n_of_players_with_vote):\\n\\n \\\"\\\"\\\"\\n It sequentially applies the three functions to look for the right\\n solution.\\n \\\"\\\"\\\"\\n\\n try_optimal_solution(module, n_of_players_with_vote)\\n if not final_field:\\n try_efficient_solution(module, n_of_players_with_vote)\\n if not final_field:\\n try_adapted_solution(n_of_players_with_vote)\\n\\n def solve_gkeeper():\\n\\n \\\"\\\"\\\"\\n Goal keeper substitution has to be the first thing to solve, if\\n needed. Here we modify field, bench and n_subst depending on whether\\n the gkeepers has vote or not.\\n \\\"\\\"\\\"\\n\\n nonlocal field\\n nonlocal bench\\n nonlocal n_subst\\n\\n # If the goal keeper n the field received a vote we delete all the\\n # remaining goal keepers from the bench\\n if find_gkeeper(field):\\n bench = delete_gkeeper(bench)\\n\\n # If the gkeeper in the field has no vote but the there is at least one\\n # gkeeper in the bench with vote we make the substitution and delete\\n # all the remaining gkeepers from the lineup, if there is any. We\\n # finally decrease the n_subst\\n elif not find_gkeeper(field) and find_gkeeper(bench):\\n gkeeper = find_gkeeper(bench)\\n field.insert(0, gkeeper)\\n bench = delete_gkeeper(bench)\\n n_subst -= 1\\n\\n # If there is no gkeeper with vote neither in the field nor in the\\n # bench than we just decrease the n_subst\\n elif not find_gkeeper(field) and not find_gkeeper(bench):\\n n_subst -= 1\\n\\n def calculation(a_number):\\n\\n \\\"\\\"\\\"\\n This is the function that is recursively applied to find the correct\\n lineup. The input 'a_number' is an integer which represents the\\n number of players (gkeeper excluded) who will partecipate in the\\n lineup calculation. In case the algorithm does not find any solution\\n after the first iteration it repeats the process considering 1\\n substitution and 1 player less.\\n \\\"\\\"\\\"\\n\\n nonlocal field\\n nonlocal bench\\n nonlocal module\\n nonlocal n_subst\\n nonlocal all_lineups\\n\\n all_lineups = valid_lineups(field, bench, n_subst)\\n look_for_solution(module, a_number)\\n\\n if not final_field:\\n n_subst -= 1\\n return calculation(a_number-1)\\n\\n clean_lineup = [(player[0], modify_player_name(player[1]), player[2])\\n for player in lineup]\\n\\n # Select the players with vote and store the number of substitutions needed\\n if mode == 'FG':\\n field, bench = players_with_vote(clean_lineup, 'FG')\\n else:\\n field, bench = players_with_vote(clean_lineup)\\n\\n n_subst = 11 - len(field)\\n\\n # In case no substitutions are needed, no calculation is started. In this\\n # case malus can only be due to errors coming from the fantaplayers when\\n # creating the lineup\\n if not n_subst:\\n malus = 0\\n ref_roles = schemes[module]\\n field[0] = (field[0][0], field[0][1], 'Por')\\n\\n for x in range(10):\\n roles_available = ref_roles[x].split('/')\\n roles_player = field[x + 1][2]\\n roles_shared = list(set(roles_available).intersection(\\n roles_player))\\n if roles_shared:\\n field[x + 1] = (field[x + 1][0], field[x + 1][1],\\n roles_shared[0])\\n else:\\n malus += 1\\n for role in roles_player:\\n temp_roles = malus_roles[role]\\n temp_roles = [role.split('/') for role in temp_roles]\\n temp_roles = [single_role for element in temp_roles for\\n single_role in element]\\n temp_roles = ['W' if role in ('W1', 'W2') else role for\\n role in temp_roles]\\n temp_roles = list(set(temp_roles))\\n roles_shared = list(set(roles_available).intersection(\\n temp_roles))\\n field[x + 1] = (field[x + 1][0], field[x + 1][1],\\n roles_shared[0])\\n break\\n\\n return field, bench, malus\\n\\n # Initialize all the parameters. We chose 10 for malus just because it is\\n # a number high enough and we look for the solution with the lower number\\n # of malus\\n final_field = [] # The final lineup\\n efficient_module = 0 # Valid module in case of eff solution\\n adapted_module = 0 # Valid module in case of adp solution\\n malus = 10 # Number of malus assigned\\n magic_number = 10 # N. of players considered in the lineup\\n all_lineups = 0 # All candidates\\n\\n # We need all the modules to be able to iterate over them in case an\\n # efficient or adapted solution is needed. We also remove the module chosen\\n # by the fantaplayer and then insert it as first element. In this way, this\\n # module will be the first to be checked\\n all_modules = ['343', '3412', '3421', '352', '442', '433',\\n '4312', '4321', '4231', '4411', '4222']\\n all_modules.remove(module)\\n all_modules.insert(0, module)\\n\\n # Set the right magic_number value if n_subst > 3\\n if n_subst > 3:\\n magic_number = 13 - n_subst\\n n_subst = 3\\n\\n # Handle the goal keeper issue\\n solve_gkeeper()\\n if find_gkeeper(field):\\n gkeeper = field[0]\\n field.remove(gkeeper)\\n else:\\n gkeeper = 0\\n\\n calculation(magic_number)\\n\\n if gkeeper:\\n gkeeper = (gkeeper[0], gkeeper[1], gkeeper[2][0])\\n final_field.insert(0, gkeeper)\\n\\n # Create the bench\\n field_names = [player[1] for player in final_field]\\n final_bench = [player for player in clean_lineup[11:] if player[1] not in\\n field_names]\\n\\n return final_field, final_bench, malus, efficient_module, adapted_module\",\n \"def method_info_specialization(self, method: ProtoServiceMethod) -> None:\",\n \"def run(self):\\n # load_data\\n layers = self.load_all_data() # list of tuples (file_name, feature_matrix)\\n\\n # check variable types\\n if len(self.method) == 1:\\n self.method = [self.method[0]] * len(layers)\\n elif len(layers) != len(self.method):\\n raise ValueError(\\\"Number of matrices extracted from input files and number of similarity methods \\\" +\\n \\\"does not correspond\\\")\\n\\n # check missing value parameter\\n if len(self.missing) == 1:\\n self.logger.info(\\\"#Setting all 'missing' parameters to {}\\\".format(self.missing[0]))\\n self.missing = [self.missing[0]] * len(layers)\\n elif len(layers) != len(self.missing):\\n raise ValueError(\\\"Number of matrices extracted from input files and number of given missing parameters \\\" +\\n \\\"does not correspond\\\")\\n\\n # extract sample names\\n all_samples = set()\\n for layer_data in layers:\\n all_samples = all_samples.union({name for name in layer_data[1].columns})\\n self.logger.info(\\\"#Total number of unique samples: {}\\\".format(len(all_samples)))\\n\\n out_arrays = {}\\n adj_matrices = []\\n\\n # create adjacency matrices\\n for i in range(len(layers)):\\n self.logger.info(\\\"#Layer: {}\\\".format(i))\\n layer_data = layers[i][1]\\n\\n # add missing samples layer\\n samples = {name for name in layer_data.columns}\\n for name in all_samples - samples:\\n layer_data[name] = np.nan\\n\\n # sort data frame by sample names\\n layer_data.sort_index(axis=1, inplace=True)\\n\\n # extract feature matrices\\n f = layer_data.values.T\\n self.logger.info(\\\"Feature matrix: ({} samples x {} features)\\\".format(f.shape[0], f.shape[1]))\\n\\n # check if feature matrix values are correct\\n ncat = check_categories(f)\\n if ncat != [0, 1]:\\n standardized = is_standardized(f, axis=0, atol=self.atol)\\n if not standardized[0]:\\n raise ValueError(\\\"Incorrect values in feature matrix. Mean of features in \\\" +\\n \\\"({},{}) \\\".format(round(standardized[1][0], 3), round(standardized[1][1], 3)) +\\n \\\"range. Standard deviation of features in \\\" +\\n \\\"({}, {}) \\\".format(round(standardized[2][0], 3), round(standardized[2][1], 3)) +\\n \\\"range. Please, supply either binary dataset \\\" +\\n \\\"(0 or 1 feature values) or continuous values standardized feature-wise. \\\" +\\n \\\"Alternatively for almost standardized continuous data, \\\" +\\n \\\"increase '-atol' parameter value (currently {}).\\\".format(self.atol))\\n else:\\n self.logger.debug(\\\"Data is correctly standardized\\\")\\n else:\\n self.logger.debug(\\\"Found two unique categories in data: [0, 1]\\\")\\n if self.method[i] != 'cosine':\\n self.logger.info(\\\"Using '{}' similarity for [0, 1] data. \\\".format(self.method[i]) +\\n \\\"Suggested better measure: cosine similarity.\\\")\\n\\n # create adjacency matrix\\n a = feature_to_adjacency(f, missing=self.missing[i], method=self.method[i], n=self.k, alpha=self.alpha)\\n self.logger.info('Adjacency matrix {} created [similarity method: {}]'.format(a.shape, self.method[i]))\\n\\n # plot adjacency matrix\\n plot_path = self.plot_base + \\\"_\\\" + str(i) + \\\".png\\\" if self.plot else self.plot_base\\n plot_heatmap_seaborn(a, title=\\\"Layer {} (source:{})\\\".format(i, layers[i][0]), file_path=plot_path)\\n if self.plot:\\n self.logger.info(\\\"Adjacency matrix plot saved to {}\\\".format(plot_path))\\n\\n # add matrices to output arrays\\n out_arrays[str(i)] = a\\n adj_matrices.append(a)\\n out_arrays[\\\"f\\\" + str(i)] = f\\n\\n # check if there are samples not accessible in any layer\\n missing_samples = []\\n for a in adj_matrices:\\n missing_samples += [i for i in range(a.shape[1]) if np.all(np.isnan(a[:, i]))]\\n\\n samples_to_drop = [sample for sample, val in Counter(missing_samples).items() if val == len(adj_matrices)]\\n if samples_to_drop:\\n # drop inaccessible samples\\n self.logger.info(\\\"Found samples inaccessible in every layer of graph. \\\" +\\n \\\"Try changing '-missing' parameter or inspect your data \\\")\\n sample_names = np.array(sorted(list(all_samples)))[np.array(samples_to_drop)]\\n self.logger.info(\\\"Dropped samples: {}\\\".format(list(sample_names)))\\n updated_out_arrays = {}\\n selector = np.array([x for x in range(len(all_samples)) if x not in samples_to_drop])\\n for i in range(len(out_arrays.keys())):\\n if str(i) not in out_arrays.keys():\\n break\\n updated_out_arrays[str(i)] = out_arrays[str(i)][selector[:, None], selector]\\n updated_out_arrays[\\\"f\\\" + str(i)] = out_arrays[\\\"f\\\" + str(i)][selector, :]\\n\\n # create output file\\n updated_out_arrays[\\\"samples\\\"] = np.array(sorted(list(all_samples)))[selector]\\n save_arrays_to_npz(data=updated_out_arrays, file_path=self.outfile)\\n\\n else:\\n # create output file\\n out_arrays[\\\"samples\\\"] = np.array(sorted(list(all_samples)))\\n save_arrays_to_npz(data=out_arrays, file_path=self.outfile)\\n\\n self.logger.info(\\\"#Output file {} created\\\".format(self.outfile))\",\n \"def _detect_method(self) -> None:\\n if isinstance(self.flm, np.ndarray):\\n _logger.info(\\\"harmonic sum method selected\\\")\\n self.method = \\\"harmonic_sum\\\"\\n elif isinstance(self.f, np.ndarray) and not isinstance(self.mask, np.ndarray):\\n _logger.info(\\\"integrating the whole sphere method selected\\\")\\n self.method = \\\"integrate_sphere\\\"\\n elif isinstance(self.f, np.ndarray):\\n _logger.info(\\\"integrating a region on the sphere method selected\\\")\\n self.method = \\\"integrate_region\\\"\\n else:\\n raise RuntimeError(\\n \\\"need to pass one off harmonic coefficients, real pixels \\\"\\n \\\"or real pixels with a mask\\\",\\n )\",\n \"def sim_meas(self, pauli):\\n return [term for term in self.layer._procspec.model_terms if pauli.simultaneous(term)]\",\n \"def time_analysis(self, method='MEAN'):\\n new_cubelist = []\\n for cube in self.cubelist:\\n new_cubelist.append(self.cube_coordinate_analysis(cube, \\n self.time_coord, \\n method))\\n self.cubelist = iris.cube.CubeList(new_cubelist)\\n self.processes.append('time_analysis')\\n return self.cubelist\",\n \"def test_coherency_regularized():\\r\\n\\r\\n for method in methods:\\r\\n f, c = tsa.coherency_regularized(tseries, 0.05, 1000,\\r\\n csd_method=method)\\r\\n npt.assert_array_almost_equal(c[0, 1], c[1, 0].conjugate())\",\n \"def optimise(\\n cls,\\n species: \\\"Species\\\",\\n method: \\\"Method\\\",\\n n_cores: Optional[int] = None,\\n coords: Optional[OptCoordinates] = None,\\n **kwargs,\\n ) -> None:\",\n \"def receptor_crosstalk(self, method='auto', ret_receptor_activity=False,\\n **kwargs):\\n if method == 'auto':\\n if self.Ns <= self.parameters['brute_force_threshold_Ns']:\\n method = 'brute_force'\\n else:\\n method = 'monte_carlo'\\n \\n if method == 'estimate':\\n # estimate receptor crosstalk directly\\n q_nm = self.receptor_crosstalk_estimate(**kwargs)\\n if ret_receptor_activity:\\n q_n = self.receptor_activity_estimate(**kwargs)\\n \\n else:\\n # calculate receptor crosstalk from the observed probabilities\\n r_n, r_nm = self.receptor_activity(method, ret_correlations=True,\\n **kwargs)\\n q_n = r_n\\n q_nm = r_nm - np.outer(r_n, r_n)\\n if kwargs.get('clip', False):\\n np.clip(q_nm, 0, 1, q_nm)\\n \\n if ret_receptor_activity:\\n return q_n, q_nm\\n else:\\n return q_nm\",\n \"def test_member_method_inputs(self):\\r\\n\\r\\n # test that explicit Method inputs don't use shared storage\\r\\n M = Module()\\r\\n M.x = T.dscalar()\\r\\n M.y = T.dscalar()\\r\\n M.f = Method([M.x], M.x + M.y)\\r\\n M.g = Method([M.y], M.x - M.y)\\r\\n m = M.make()\\r\\n m.y = 77\\r\\n assert m.f(23) == 100\\r\\n assert m.x is None\\r\\n m.x = 1000\\r\\n assert m.g(23) == 977\\r\\n assert m.y == 77\\r\\n assert m.x == 1000\",\n \"def run_methods(self):\\n results = {}\\n methods = self.converter.available_methods[:] # a copy !\\n\\n if self.include_dummy:\\n methods += ['dummy']\\n\\n if self.to_include:\\n methods = [x for x in methods if x in self.to_include]\\n elif self.to_exclude:\\n methods = [x for x in methods if x not in self.to_exclude]\\n\\n for method in methods:\\n print(\\\"\\\\nEvaluating method %s\\\" % method)\\n times = []\\n pb = Progress(self.N)\\n for i in range(self.N):\\n with Timer(times):\\n self.converter(method=method)\\n pb.animate(i+1)\\n results[method] = times\\n self.results = results\",\n \"def inspect(self, method, **options):\\n pass\",\n \"def test_coherence_regularized():\\r\\n for method in methods:\\r\\n f, c = tsa.coherence_regularized(tseries, 0.05, 1000,\\r\\n csd_method=method)\\r\\n npt.assert_array_almost_equal(c[0, 1], c[1, 0])\",\n \"def evaluate_processor_on_corpus(processor: Processor,\\n corpus: ProviderBase,\\n title: Optional[str] = None,\\n set_type: SetType = SetType.DEV) -> Dict[str, float]:\\n\\n if title:\\n print(f\\\"Check metrics for {title}\\\")\\n keywords_evaluate = bool(corpus.purpose() & CorpusPurpose.KEYWORDS)\\n summary_evaluate = bool(corpus.purpose() & CorpusPurpose.SUMMARY)\\n return evaluate_sequence(_make_sequence(processor, corpus, set_type),\\n keywords_evaluate, summary_evaluate)\",\n \"def _gather_metric(method, attribute=None, transform=None):\\n\\n doc = \\\"Extract the {} attribute from the given process object\\\".format\\n if attribute:\\n doc = ( # NOQA\\n \\\"Extract the {}().{} attribute from the given process object\\\".format\\n )\\n\\n def gather_metric(process):\\n \\\"\\\"\\\"Dynamically Generated\\\"\\\"\\\"\\n errmsg = (\\n \\\"Only the 'psutil.Process' interface is supported currently; not {}\\\".format\\n )\\n proc_type = type(process)\\n assert proc_type is psutil.Process, errmsg(proc_type)\\n metric = methodcaller(method) # pylint: disable=redefined-outer-name\\n if attribute is not None:\\n value = attrgetter(attribute)(metric(process))\\n else:\\n value = metric(process)\\n\\n if transform is not None:\\n value = transform(value)\\n\\n return value\\n\\n # XXX: For some reason this was causing trouble for the documentation build process\\n # gather_metric.__doc__ = doc(method, attribute)\\n return gather_metric\",\n \"def scstim(self, method='mean', width=None, tres=None, figsize=(7.5, 6.5)):\\n\\n ## TODO: for each pair of recordings, find common subset of active neurons and\\n ## calculate pairwise corrs for each recording in that pair using just those neurons\\n\\n ## TODO: maybe limit to visually responsive cells\\n\\n uns = get_ipython().user_ns\\n if width == None:\\n width = uns['SCWIDTH']\\n if tres == None:\\n tres = width\\n blankmseqrids = uns['BSRIDS'][self.absname] + uns['MSRIDS'][self.absname]\\n movdriftrids = uns['NSRIDS'][self.absname] + uns['DBRIDS'][self.absname]\\n\\n blankmseqcorrs = []\\n movdriftcorrs = []\\n for rid in (blankmseqrids + movdriftrids):\\n r = self.r[rid]\\n print('%s: %s' % (r.absname, r.name))\\n spikecorr = r.sc(width=width, tres=tres)\\n sc = spikecorr.sct(method=method)[0]\\n sc = sc[0] # pull out the spike correlation values that span all laminae\\n if rid in blankmseqrids:\\n blankmseqcorrs.append(sc)\\n else:\\n movdriftcorrs.append(sc)\\n blankmseqcorrs = np.hstack(blankmseqcorrs)\\n movdriftcorrs = np.hstack(movdriftcorrs)\\n # repeat each element in blankmseqcorrs len(movdriftcorrs) times:\\n x = np.repeat(blankmseqcorrs, len(movdriftcorrs))\\n # tile movdriftcorrs len(blankmseqcorrs) times:\\n y = np.tile(movdriftcorrs, len(blankmseqcorrs))\\n\\n f = pl.figure(figsize=figsize)\\n a = f.add_subplot(111)\\n lim = min([x.min(), y.min(), 0]), max([x.max(), y.max()])\\n a.plot(lim, lim, c='e', ls='--', marker=None) # y=x line\\n a.plot(x, y, 'k.')\\n #a.set_xlim(lim)\\n #a.set_ylim(lim)\\n a.set_xlabel('%s spike correlations: blankscreen and mseq' % method)\\n a.set_ylabel('%s spike correlations: movie and drift bar' % method)\\n titlestr = lastcmd()\\n gcfm().window.setWindowTitle(titlestr)\\n a.set_title(titlestr)\\n f.tight_layout(pad=0.3) # crop figure to contents\\n f.show()\",\n \"def quality_control(self, method = \\\"mv\\\", **kwargs):\\n input_col = \\\"result\\\"\\n if input_col not in self.cols:\\n raise Exception(\\\"There is no result for quality control. \\\"\\n \\\"Pease call get_result() to get results first.\\\")\\n\\n output_col = None\\n if method == \\\"mv\\\":\\n output_col = \\\"mv\\\"\\n self.data[output_col] = self.__mv_col(self.data[input_col], **kwargs)\\n elif method == \\\"em\\\":\\n output_col = \\\"em\\\"\\n self.data[output_col] = self.__em_col(self.data[input_col], **kwargs)\\n\\n if output_col == None:\\n raise Exception(str(method)+\\\" is not a valid input.\\\")\\n\\n if output_col not in self.cols:\\n self.cols.append(output_col)\\n\\n return self\",\n \"def run(method, n):\\n \\n m1,m2 = generate(n)\\n \\n start = time.time()\\n method(m1,m2)\\n end = time.time()\\n \\n exe = end - start\\n \\n return exe\",\n \"def performance_test(Ns=15, Nr=3):\\n num = 2**Ns\\n hs = np.random.random(Ns)\\n model = LibraryBinaryNumeric(Ns, Nr, hs)\\n \\n start = time.time()\\n model.mutual_information_brute_force()\\n time_brute_force = time.time() - start\\n print('Brute force: %g sec' % time_brute_force)\\n \\n start = time.time()\\n model.mutual_information_monte_carlo(num)\\n time_monte_carlo = time.time() - start\\n print('Monte carlo: %g sec' % time_monte_carlo)\",\n \"def summarize_pcoas(master_pcoa, support_pcoas,\\r\\n method='IQR', apply_procrustes=True):\\r\\n if apply_procrustes:\\r\\n # perform procrustes before averaging\\r\\n support_pcoas = [list(sp) for sp in support_pcoas]\\r\\n master_pcoa = list(master_pcoa)\\r\\n for i, pcoa in enumerate(support_pcoas):\\r\\n master_std, pcoa_std, m_squared = procrustes(\\r\\n master_pcoa[1], pcoa[1])\\r\\n support_pcoas[i][1] = pcoa_std\\r\\n master_pcoa[1] = master_std\\r\\n\\r\\n m_matrix = master_pcoa[1]\\r\\n m_eigvals = master_pcoa[2]\\r\\n m_names = master_pcoa[0]\\r\\n jn_flipped_matrices = []\\r\\n all_eigvals = []\\r\\n for rep in support_pcoas:\\r\\n matrix = rep[1]\\r\\n eigvals = rep[2]\\r\\n all_eigvals.append(eigvals)\\r\\n jn_flipped_matrices.append(_flip_vectors(matrix, m_matrix))\\r\\n matrix_average, matrix_low, matrix_high = _compute_jn_pcoa_avg_ranges(\\r\\n jn_flipped_matrices, method)\\r\\n # compute average eigvals\\r\\n all_eigvals_stack = vstack(all_eigvals)\\r\\n eigval_sum = np_sum(all_eigvals_stack, axis=0)\\r\\n eigval_average = eigval_sum / float(len(all_eigvals))\\r\\n return matrix_average, matrix_low, matrix_high, eigval_average, m_names\",\n \"def time_aplmoo_method(method, irange=None, print_energy=False):\\n\\n if(irange is None):\\n irange = range(1, 11)\\n\\n print(\\\"%4s %8s\\\" % (\\\"n\\\", \\\"t\\\"))\\n\\n energies = []\\n for i in irange:\\n n = 2**i\\n\\n # Generate a singular matrix\\n A = scipy.sparse.lil_matrix((n, n))\\n A[:n // 2, :n // 2] = gen_matrix(n // 2) # Upper Left block matrix\\n A = A.tocsc()\\n\\n B = scipy.sparse.lil_matrix((n, n))\\n B[n // 2:, n // 2:] = gen_matrix(n // 2) # Lower Right block matrix\\n B[-1] = 0 # Make the last row all zeros\\n B = B.tocsc()\\n\\n # Generate a rhs that will always have a solution\\n a = A.dot(numpy.ones((n, 1)))\\n b = B.dot(numpy.ones((n, 1)))\\n\\n C = scipy.sparse.identity(n).tocsc()\\n c = 0.2053202792 * numpy.ones((n, 1))\\n\\n startTime = time.time()\\n Z = method([A, B, C], [a, b, c])\\n print(\\\"%4d %.6f\\\" % (n, time.time() - startTime))\\n\\n if(print_energy):\\n energies.append([\\n abs(Z.T.dot(A.dot(Z)) + Z.T.dot(a)),\\n abs(Z.T.dot(B.dot(Z)) + Z.T.dot(b)),\\n abs(Z.T.dot(C.dot(Z)) + Z.T.dot(c))])\\n\\n if(print_energy):\\n print()\\n for i, ie in enumerate(irange):\\n print(\\\"n = %d\\\" % 2**ie)\\n print((\\\"Z.T @ A @ Z + Z.T @ a = %g\\\\nZ.T @ B @ Z + Z.T @ b = %g\\\\n\\\" +\\n \\\"Z.T @ C @ Z + Z.T @ c = %g\\\") % tuple(energies[i]))\",\n \"def process_method_on_list(method_to_run, items):\\n all_items = []\\n if items is not None:\\n if SUPPORTS_POOL:\\n pool = ThreadPool()\\n try:\\n all_items = pool.map(method_to_run, items)\\n except Exception:\\n # catch exception to prevent threadpool running forever\\n log_msg(format_exc(sys.exc_info()))\\n log_msg(\\\"Error in %s\\\" % method_to_run)\\n pool.close()\\n pool.join()\\n else:\\n try:\\n all_items = [method_to_run(item) for item in list(items)]\\n except Exception:\\n log_msg(format_exc(sys.exc_info()))\\n log_msg(\\\"Error in %s with %s\\\" % method_to_run, items)\\n all_items = filter(None, all_items)\\n return all_items\",\n \"def calculate3(pred_ccm, pred_ad, truth_ccm, truth_ad, method=\\\"sym_pseudoV\\\", weights=None, verbose=False, pseudo_counts=True, full_matrix=True, in_mat=2):\\n larger_is_worse_methods = ['sym_pseudoV_nc', 'sym_pseudoV', 'pseudoV_nc', 'pseudoV', \\\"simpleKL_nc\\\", 'simpleKL'] # methods where a larger score is worse\\n\\n \\n pc_pred_ccm, pc_pred_ad, pc_truth_ccm, pc_truth_ad = pred_ccm, pred_ad, truth_ccm, truth_ad\\n y = np.array(pc_pred_ad.shape)[1]\\n nssms = int(np.ceil(0.5 * (2*y + 1) - 0.5 * np.sqrt(4*y + 1)))\\n\\n if isinstance(method, list):\\n res = [calculate3_onemetric(pc_pred_ccm, pc_pred_ad, pc_truth_ccm, pc_truth_ad,\\n method=m, verbose=verbose, in_mat=in_mat) for m in method] # calculate the score for each method\\n\\n # normalize the scores to be between (worst of NCluster score and OneCluster score) and (Truth score)\\n ncluster_ccm, ncluster_ad = add_pseudo_counts(mb.get_ccm('NClusterOneLineage', nssms=nssms), mb.get_ad('NClusterOneLineage', nssms=nssms))\\n ncluster_score = [calculate3_onemetric(ncluster_ccm, ncluster_ad, pc_truth_ccm, pc_truth_ad,\\n method=m, verbose=verbose, full_matrix=full_matrix, in_mat=in_mat) for m in method]\\n del ncluster_ccm, ncluster_ad\\n onecluster_ccm, onecluster_ad = add_pseudo_counts(mb.get_ccm('OneCluster', nssms=nssms), mb.get_ad('OneCluster', nssms=nssms))\\n onecluster_score = [calculate3_onemetric(onecluster_ccm, onecluster_ad, pc_truth_ccm, pc_truth_ad,\\n method=m, verbose=verbose, full_matrix=full_matrix, in_mat=in_mat) for m in method]\\n del onecluster_ccm, onecluster_ad\\n for i in range(len(method)):\\n if method[i] in larger_is_worse_methods: # normalization for methods where a larger score is worse\\n worst_score = max(ncluster_score[i], onecluster_score[i]) # worst of NCluster and OneCluster scores\\n res[i] = 1 - (res[i] / worst_score) # normalize the score\\n else: # normalization for methods where a smaller score is worse\\n worst_score = min(ncluster_score[i], onecluster_score[i])\\n res[i] = (res[i] - worst_score) / (1 - worst_score)\\n\\n\\n if weights is None: # if weights are not specified or if they cannot be normalized then default to equal weights\\n weights = [1] * len(method)\\n elif sum(weights) == 0:\\n Warning('Weights sum to zero so they are invalid, defaulting to equal weights')\\n weights = [1] * len(method)\\n\\n weights = np.array(weights) / float(sum(weights)) # normalize the weights\\n score = sum(np.multiply(res, weights))\\n else:\\n \\n score = calculate3_onemetric(pc_pred_ccm, pc_pred_ad, pc_truth_ccm, pc_truth_ad,\\n method=method, verbose=verbose, full_matrix=full_matrix, in_mat=in_mat)\\n del pc_pred_ccm\\n del pc_pred_ad\\n # normalize the score to be between (worst of NCluster score and OneCluster score) and (Truth score) - similar to above\\n ncluster_ccm, ncluster_ad = add_pseudo_counts(mb.get_ccm('NClusterOneLineage', nssms=nssms), mb.get_ad('NClusterOneLineage', nssms=nssms))\\n ncluster_score = calculate3_onemetric(ncluster_ccm, ncluster_ad, pc_truth_ccm, pc_truth_ad,\\n method=method, verbose=verbose, full_matrix=full_matrix, in_mat=in_mat)\\n del ncluster_ccm, ncluster_ad\\n onecluster_ccm, onecluster_ad = add_pseudo_counts(mb.get_ccm('OneCluster', nssms=nssms), mb.get_ad('OneCluster', nssms=nssms))\\n \\n onecluster_score = calculate3_onemetric(onecluster_ccm, onecluster_ad, pc_truth_ccm, pc_truth_ad,\\n method=method, verbose=verbose, full_matrix=full_matrix, in_mat=in_mat)\\n del onecluster_ccm, onecluster_ad\\n\\n #print score, ncluster_score, onecluster_score\\n if method in larger_is_worse_methods:\\n worst_score = max(ncluster_score, onecluster_score)\\n score = 1 - (score / worst_score)\\n else:\\n worst_score = min(ncluster_score, onecluster_score)\\n score = (score - worst_score) / (1 - worst_score)\\n return score\",\n \"def present_methods(methods, quiet, send_probe):\\n ret_service_count, ret_method_count = 0, 0\\n if not quiet:\\n print_heading(\\\"Methods Found\\\")\\n\\n if len(methods) < 1:\\n writer(\\\"No methods were identified!\\\", FORMAT['WARNING'])\\n return 0, 0\\n\\n service_category = \\\"\\\"\\n for _, method in enumerate(methods):\\n\\n method_string = \\\"{}.{}( {} )\\\".format(\\n method[\\\"serviceProxy\\\"][:-6],\\n method[\\\"methodName\\\"], ', '.join(method[\\\"methodSignature\\\"])\\n ).replace(\\\"( )\\\", \\\"()\\\")\\n\\n if FILTER in method_string:\\n if method[\\\"serviceProxy\\\"] != service_category:\\n writer(f\\\"\\\\n----- {method['serviceProxy'][:-6]} -----\\\\n\\\")\\n ret_service_count += 1\\n\\n service_category = method[\\\"serviceProxy\\\"]\\n\\n writer(method_string, FORMAT['HEADING'] if RPC_MODE else FORMAT['DEFAULT'])\\n ret_method_count += 1\\n\\n if RPC_MODE:\\n present_rpc_method(method, send_probe)\\n\\n if not RPC_MODE:\\n writer()\\n\\n return ret_service_count, ret_method_count\",\n \"def mr_pairs_have_less_mi_exp(filename=None):\\n trials = 500\\n matrix = [[0,0,0,0] for i in range(L)]\\n motif = [random_site(L) for i in range(n)]\\n scale = 0.01 #use this to prevent overflows in anneal\\n scaled_sse = lambda(matrix,motif):sse_optimized(matrix,motif)*scale\\n annealed_system = lambda :anneal(scaled_sse,\\n lambda(matrix,motif):propose(matrix,motif),\\n (matrix,motif),\\n verbose=True,\\n iterations=100000,\\n stopping_crit = 0.1*scale)\\n systems = [annealed_system() for i in xrange(500)]\\n motifs = map(second,systems)\\n ics = map(motif_ic,motifs)\\n control_motifs = [sa_motif_with_desired_ic(ic,0.1,n,L) for ic in verbose_gen(ics)]\\n mis = map(total_motif_mi,motifs)\\n control_mis = map(total_motif_mi,control_motifs)\\n plt.scatter(mis,control_mis)\\n plt.xlabel(\\\"M-R System Mutual Information (bits)\\\")\\n plt.ylabel(\\\"Annealed Motif Mutual Information (bits)\\\")\\n plt.plot([0,5],[0,5])\\n maybesave(filename)\\n #mannwhitneyu(mis,control_mis) -> (47673.0, 1.2864021557444156e-64)\\n return mis,control_mis\",\n \"def time_analysis(self, method='MEAN'):\\n self.cube = self.cube_coordinate_analysis(self.cube, self.time_coord, \\n method)\\n self.processes.append('time_analysis')\\n return self.cube\",\n \"def measure_mp_speedup():\\n modes = [\\n # name, function\\n ('dSMC', ana.d_smc),\\n ('dAMC', ana.d_amc),\\n ('EDF-VD', ana.d_edf_vd),\\n ('pSMC', ana.p_smc),\\n ('pAMC-BB', ana.p_amc_bb),\\n ('pAMC-BB+', ft.partial(ana.p_amc_bb, ignore_hi_mode=True))\\n ]\\n times_seq = {}\\n task_sets_list = pickle.load(open(task_sets_path + 'task_sets_fairgen', 'rb'))\\n start_total_seq = time()\\n for name, func in modes:\\n start_mode_seq = time()\\n rates = []\\n for task_sets in task_sets_list:\\n results = []\\n for task_set in task_sets:\\n results.append(func(task_set))\\n rates.append(100 * np.average(results))\\n stop_mode_seq = time()\\n times_seq[name] = stop_mode_seq - start_mode_seq\\n stop_total_seq = time()\\n times_seq['Overall'] = stop_total_seq - start_total_seq\\n\\n times_par = {}\\n start_total_par = time()\\n pool = mp.Pool()\\n for name, func in modes:\\n start_mode_par = time()\\n rates = []\\n for task_sets in task_sets_list:\\n rates.append(100 * np.average(pool.map(func, task_sets)))\\n stop_mode_par = time()\\n times_par[name] = stop_mode_par - start_mode_par\\n stop_total_par = time()\\n times_par['Overall'] = stop_total_par - start_total_par\\n\\n speedups = {}\\n for name, _ in modes:\\n speedups[name] = times_seq[name] / times_par[name]\\n speedups['Overall'] = times_seq['Overall'] / times_par['Overall']\\n\\n print(\\\"PERFORMANCE MEASUREMENTS\\\")\\n print(\\\"Number of cores: %d\\\" % mp.cpu_count())\\n print(\\\"Scheme: Sequential time / Parallel time / Speedup\\\")\\n for name, _ in modes:\\n print(\\\"%s: %.3fs / %.3fs / %.3f\\\" % (name, times_seq[name], times_par[name], speedups[name]))\\n print(\\\"Overall: %.3fs / %.3fs / %.3f\\\" % (times_seq['Overall'], times_par['Overall'], speedups['Overall']))\",\n \"def __benchmark__(cls):\\n results = []\\n used_argsets = []\\n for args in cls.arguments:\\n used_argsets.append(args)\\n # for each given argument\\n for method in cls.get_methods():\\n # append an empty list for the results with this argument\\n method_results = []\\n # for each repetition\\n for n in xrange(cls.repetitions):\\n # append the results to the list for this argument set\\n trial_results = cls._trial(method, args)\\n method_results.append(trial_results)\\n # append a Result to `results`.\\n results.append(Result(method, args, method_results))\\n return results, used_argsets\",\n \"def perform_calculations(collector):\\n result = {}\\n try:\\n radius, mass = Calculator.calculate_radius_mass(collector)\\n result['radius'] = radius\\n result['mass'] = mass\\n average_density = Calculator.calculate_average_density(radius,\\n mass)\\n result['average_density'] = average_density\\n escape_velocity = Calculator.calculate_escape_velocity(radius,\\n mass)\\n result['escape_velocity'] = escape_velocity\\n earth_similarity_index = Calculator.calculate_esi_index(\\n radius, mass, collector.get_average_temperature())\\n result['earth_similarity_index'] = earth_similarity_index\\n except NoDataError:\\n pass\\n\\n try:\\n avg_atm_molar_mass = Calculator.calculate_molar_mass(collector)\\n except NoDataError:\\n avg_atm_molar_mass = None\\n if avg_atm_molar_mass is not None and avg_atm_molar_mass <= 0:\\n logging.getLogger('Analyzer').debug('Molar mass <= 0: %d',\\n avg_atm_molar_mass)\\n avg_atm_molar_mass = None\\n\\n if avg_atm_molar_mass is not None:\\n result['avg_atm_molar_mass'] = avg_atm_molar_mass\\n avg_molecule_mass = avg_atm_molar_mass / Calculator.A\\n result['avg_molecule_mass'] = avg_molecule_mass\\n specific_gas_const = Calculator.R / avg_atm_molar_mass\\n result['specific_gas_const'] = specific_gas_const\\n\\n try:\\n speed_of_sound = Kundt.speed_of_sound(collector.kundt)\\n result['speed_of_sound'] = speed_of_sound\\n\\n if avg_atm_molar_mass is None:\\n # All further calculations require valid molar mass\\n return result\\n\\n # Since calculate_molar_mass already uses get_average_temperature\\n # and get_ground_pressure, it's safe to use these functions here\\n # without worrying about NoDataError\\n adiabatic_index = Calculator.calculate_adiabatic_index(\\n collector, speed_of_sound, avg_atm_molar_mass)\\n result['adiabatic_index'] = adiabatic_index\\n\\n atmosphere_density = (adiabatic_index *\\n collector.get_ground_pressure() /\\n speed_of_sound ** 2)\\n result['atmosphere_density'] = atmosphere_density\\n\\n refractive_index = (3 * avg_atm_molar_mass *\\n collector.get_ground_pressure() /\\n atmosphere_density / Calculator.R /\\n collector.get_average_temperature() - 2) ** 0.5\\n result['refractive_index'] = refractive_index\\n\\n molar_refractivity = (avg_atm_molar_mass /\\n atmosphere_density *\\n (refractive_index ** 2 - 1) /\\n (refractive_index ** 2 + 2))\\n result['molar_refractivity'] = molar_refractivity\\n\\n atm_speed_of_light = Calculator.C / refractive_index\\n result['atm_speed_of_light'] = atm_speed_of_light\\n except NoDataError:\\n pass\\n\\n return result\",\n \"def __evaluate_performance__(self,\\n types=[\\\"static_winners\\\"],\\n ):\\n # | - __evaluate_performance__\\n\\n # #####################################################################\\n _evaluate_performance__static_winners = \\\\\\n self._evaluate_performance__static_winners\\n meth_static_winners = _evaluate_performance__static_winners\\n # #####################################################################\\n\\n if \\\"static_winners\\\" in types:\\n meth_static_winners()\\n\\n #__|\",\n \"def reduction_error_analysis(rom, fom, reductor, test_mus,\\n basis_sizes=0,\\n estimator=True, condition=False, error_norms=(), error_norm_names=None,\\n estimator_norm_index=0, custom=(),\\n plot=False, plot_custom_logarithmic=True,\\n pool=dummy_pool):\\n\\n assert not error_norms or (fom and reductor)\\n assert error_norm_names is None or len(error_norm_names) == len(error_norms)\\n assert not condition \\\\\\n or isinstance(rom, StationaryModel) and rom.operator.linear\\n\\n logger = getLogger('pymor.algorithms.error')\\n if pool is None or pool is dummy_pool:\\n pool = dummy_pool\\n else:\\n logger.info(f'Using pool of {len(pool)} workers for error analysis')\\n\\n tic = time.time()\\n\\n if isinstance(basis_sizes, Number):\\n if basis_sizes == 1:\\n basis_sizes = [rom.solution_space.dim]\\n else:\\n if basis_sizes == 0:\\n basis_sizes = rom.solution_space.dim + 1\\n basis_sizes = min(rom.solution_space.dim + 1, basis_sizes)\\n basis_sizes = np.linspace(0, rom.solution_space.dim, basis_sizes).astype(int)\\n if error_norm_names is None:\\n error_norm_names = tuple(norm.name for norm in error_norms)\\n\\n norms, estimates, errors, conditions, custom_values = \\\\\\n list(zip(*pool.map(_compute_errors, test_mus, fom=fom, reductor=reductor, estimator=estimator,\\n error_norms=error_norms, condition=condition, custom=custom, basis_sizes=basis_sizes)))\\n print()\\n\\n result = {}\\n result['mus'] = test_mus = np.array(test_mus)\\n result['basis_sizes'] = basis_sizes\\n\\n summary = [('number of samples', str(len(test_mus)))]\\n\\n if error_norms:\\n result['norms'] = norms = np.array(norms)\\n result['max_norms'] = max_norms = np.max(norms, axis=0)\\n result['max_norm_mus'] = max_norm_mus = test_mus[np.argmax(norms, axis=0)]\\n result['errors'] = errors = np.array(errors)\\n result['max_errors'] = max_errors = np.max(errors, axis=0)\\n result['max_error_mus'] = max_error_mus = test_mus[np.argmax(errors, axis=0)]\\n result['rel_errors'] = rel_errors = errors / norms[:, :, np.newaxis]\\n result['max_rel_errors'] = np.max(rel_errors, axis=0)\\n result['max_rel_error_mus'] = test_mus[np.argmax(rel_errors, axis=0)]\\n for name, norm, norm_mu, error, error_mu in zip(error_norm_names,\\n max_norms, max_norm_mus,\\n max_errors[:, -1], max_error_mus[:, -1]):\\n summary.append((f'maximum {name}-norm',\\n f'{norm:.7e} (mu = {error_mu})'))\\n summary.append((f'maximum {name}-error',\\n f'{error:.7e} (mu = {error_mu})'))\\n result['error_norm_names'] = error_norm_names\\n\\n if estimator:\\n result['estimates'] = estimates = np.array(estimates)\\n result['max_estimates'] = max_estimates = np.max(estimates, axis=0)\\n result['max_estimate_mus'] = max_estimate_mus = test_mus[np.argmax(estimates, axis=0)]\\n summary.append(('maximum estimated error',\\n f'{max_estimates[-1]:.7e} (mu = {max_estimate_mus[-1]})'))\\n\\n if estimator and error_norms:\\n result['effectivities'] = effectivities = errors[:, estimator_norm_index, :] / estimates\\n result['max_effectivities'] = max_effectivities = np.max(effectivities, axis=0)\\n result['max_effectivity_mus'] = max_effectivity_mus = test_mus[np.argmax(effectivities, axis=0)]\\n result['min_effectivities'] = min_effectivities = np.min(effectivities, axis=0)\\n result['min_effectivity_mus'] = min_effectivity_mus = test_mus[np.argmin(effectivities, axis=0)]\\n summary.append(('minimum estimator effectivity',\\n f'{min_effectivities[-1]:.7e} (mu = {min_effectivity_mus[-1]})'))\\n summary.append(('maximum estimator effectivity',\\n f'{max_effectivities[-1]:.7e} (mu = {max_effectivity_mus[-1]})'))\\n\\n if condition:\\n result['conditions'] = conditions = np.array(conditions)\\n result['max_conditions'] = max_conditions = np.max(conditions, axis=0)\\n result['max_condition_mus'] = max_condition_mus = test_mus[np.argmax(conditions, axis=0)]\\n summary.append(('maximum system matrix condition',\\n f'{max_conditions[-1]:.7e} (mu = {max_condition_mus[-1]})'))\\n\\n if custom:\\n result['custom_values'] = custom_values = np.array(custom_values)\\n result['max_custom_values'] = max_custom_values = np.max(custom_values, axis=0)\\n result['max_custom_values_mus'] = max_custom_values_mus = test_mus[np.argmax(custom_values, axis=0)]\\n for i, (value, mu) in enumerate(zip(max_custom_values[:, -1], max_custom_values_mus[:, -1])):\\n summary.append((f'maximum custom value {i}',\\n f'{value:.7e} (mu = {mu})'))\\n\\n toc = time.time()\\n result['time'] = toc - tic\\n summary.append(('elapsed time', str(toc - tic)))\\n\\n summary_fields, summary_values = list(zip(*summary))\\n summary_field_width = np.max(list(map(len, summary_fields))) + 2\\n summary_lines = [f' {field+\\\":\\\":{summary_field_width}} {value}'\\n for field, value in zip(summary_fields, summary_values)]\\n summary = 'Stochastic error estimation:\\\\n' + '\\\\n'.join(summary_lines)\\n result['summary'] = summary\\n\\n if plot:\\n import matplotlib.pyplot as plt\\n fig = plt.figure()\\n num_plots = (int(bool(error_norms) or estimator) + int(bool(error_norms) and estimator)\\n + int(condition) + int(bool(custom)))\\n current_plot = 1\\n\\n if bool(error_norms) or estimator:\\n ax = fig.add_subplot(1, num_plots, current_plot)\\n legend = []\\n if error_norms:\\n for name, errors in zip(error_norm_names, max_errors):\\n ax.semilogy(basis_sizes, errors)\\n legend.append(name)\\n if estimator:\\n ax.semilogy(basis_sizes, max_estimates)\\n legend.append('estimator')\\n ax.legend(legend)\\n ax.set_title('maximum errors')\\n current_plot += 1\\n\\n if bool(error_norms) and estimator:\\n ax = fig.add_subplot(1, num_plots, current_plot)\\n ax.semilogy(basis_sizes, min_effectivities)\\n ax.semilogy(basis_sizes, max_effectivities)\\n ax.legend(('min', 'max'))\\n ax.set_title('estimator effectivities')\\n current_plot += 1\\n\\n if condition:\\n ax = fig.add_subplot(1, num_plots, current_plot)\\n ax.semilogy(basis_sizes, max_conditions)\\n ax.set_title('maximum condition')\\n current_plot += 1\\n\\n if custom:\\n ax = fig.add_subplot(1, num_plots, current_plot)\\n legend = []\\n for i, values in enumerate(custom_values):\\n if plot_custom_logarithmic:\\n ax.semilogy(basis_sizes, values)\\n else:\\n ax.plot(basis_sizes, values)\\n legend.append('value ' + str(i))\\n ax.legend(legend)\\n ax.set_title('maximum custom values')\\n current_plot += 1\\n\\n result['figure'] = fig\\n\\n return result\",\n \"def __init__(self, classific_method=\\\"LogisticRegression\\\"):\\n\\t\\tself.classific_method = classific_method\",\n \"def coordinate_analysis(self, coordinate, method='MEAN'):\\n new_cubelist = []\\n for cube in self.cubelist:\\n new_cubelist.append(self.cube_coordinate_analysis(cube, coordinate, method))\\n self.cubelist = iris.cube.CubeList(new_cubelist)\\n self.processes.append('%s_analysis' % coordinate)\\n return self.cubelist\",\n \"def DetermineProcessingSystem(self, problemManager, mineDataManager):\\n\\n self.CalculateProcessingCapacity(problemManager, mineDataManager)\\n \\n #Todo(\\\"determine processing method based on amount and type of ore mined\\\")\\n referenceMetalStr = mineDataManager.theOreBody.type[:2] \\n # first two letters of orebody type is assumed to be reference metal for determining processing grade\\n # eg AuCu -> gold is reference metal, \\n self.processingMethod = referenceMetalStr \\n \\n #processing loss is fixed\\n \\n if(referenceMetalStr == \\\"Au\\\"):\\n self.refiningTake = 0.01\\n elif(referenceMetalStr == \\\"Cu\\\"):\\n self.refiningTake = 0.10\\n elif(referenceMetalStr == \\\"Ni\\\"):\\n self.refiningTake = 0.30\\n elif(referenceMetalStr == \\\"Ag\\\"):\\n self.refiningTake = 0.05\\n elif(referenceMetalStr == \\\"Pb\\\"):\\n self.refiningTake = 0.17\\n \\n \\n self.CalculateProcessingCapex(problemManager, mineDataManager)\\n self.CalculateProcessingOpex(problemManager, mineDataManager)\\n \\n return self\",\n \"def metallicity(method, emsystem):\\n if method == 'PG16':\\n # Requires Hbeta, [OII], [OIII], [NII], [SII]\\n R2 = (emsystem.get_emline('[OII] 3726').attrib['flux'] +\\n emsystem.get_emline('[OII] 3729').attrib['flux']) / emsystem.get_emline('Hbeta').attrib['flux']\\n R3 = (emsystem.get_emline('[OIII] 4959').attrib['flux'] +\\n emsystem.get_emline('[OIII] 5007').attrib['flux']) / emsystem.get_emline('Hbeta').attrib['flux']\\n N2 = (emsystem.get_emline('[NII] 6548').attrib['flux'] +\\n emsystem.get_emline('[NII] 6584').attrib['flux']) / emsystem.get_emline('Hbeta').attrib['flux']\\n S2 = (emsystem.get_emline('[SII] 6716').attrib['flux'] +\\n emsystem.get_emline('[SII] 6731').attrib['flux']) / emsystem.get_emline('Hbeta').attrib['flux']\\n # Proceed\\n if np.log10(N2) < -0.6:\\n r_val = 7.932 + 0.944*np.log10(R3/R2) + 0.695*np.log10(N2) + \\\\\\n ((0.97 - 0.291*np.log10(R3/R2)) - 0.019*np.log10(N2))*np.log10(R2)\\n\\n s_val = 8.072 + 0.789*np.log10(R3/S2) + 0.726*np.log10(N2) + \\\\\\n (1.069 - 0.170*np.log10(R3/S2) +0.022*np.log10(N2))*np.log10(S2)\\n else:\\n r_val = 8.589 + 0.022*np.log10(R3/R2) + 0.399*np.log10(N2) + \\\\\\n (-0.137 + 0.164*np.log10(R3/R2) + 0.589*np.log10(N2))*np.log10(R2)\\n\\n s_val = 8.424 + 0.030*np.log10(R3/S2) + 0.751*np.log10(N2) + \\\\\\n (-0.349 + 0.182*np.log10(R3/S2) +0.508*np.log10(N2))*np.log10(S2)\\n return r_val.decompose().value, s_val.decompose().value\",\n \"def test_omp(self):\\n ex = self.ex\\n j = self.j\\n\\n nreps = random.randint(1, 10)\\n ncalls = random.randint(1, 10)\\n ex.calls = ncalls * [ex.call]\\n ex.nreps = nreps\\n ex.calls_parallel = True\\n\\n cmds = ex.generate_cmds()\\n\\n self.assertEqual(cmds.count([\\\"{omp\\\"]), nreps)\\n self.assertEqual(cmds.count([\\\"}\\\"]), nreps)\\n\\n lensumrange = random.randint(1, 10)\\n ex.sumrange = [j, range(lensumrange)]\\n ex.sumrange_parallel = True\\n\\n cmds = ex.generate_cmds()\\n\\n self.assertEqual(cmds.count([\\\"{omp\\\"]), nreps)\\n self.assertEqual(cmds.count([\\\"}\\\"]), nreps)\",\n \"def identify_outliers(self, methods, params): \\r\\n self.outlier_methods = methods\\r\\n self.outlier_params = params\\r\\n nmethods = len(methods)\\r\\n flagged = np.zeros((nmethods, self.ndetects),np.int32)\\r\\n cross = np.zeros((self.ndetects), np.float64)\\r\\n if 'Potts' in methods:\\r\\n self.turn_angle() \\r\\n self.circular_std_dev()\\r\\n circ_std = self.rec_track.circ_std\\r\\n turn_angle = abs(self.rec_track.turn_angle)\\r\\n turning = 0 # initialize\\r\\n if 'Dry' in methods: # need to do this first\\r\\n ndry = self.outlier_methods.index('Dry')\\r\\n for nd in range(self.ndetects):\\r\\n tr = self.rec_track[nd]\\r\\n if tr.i < 0:\\r\\n flagged[ndry, nd] = True\\r\\n if tr.depth < params[ndry][0]:\\r\\n flagged[ndry, nd] = True\\r\\n ncol = len(self.df_track.columns)\\r\\n self.df_track.insert(ncol, 'Dry', flagged[ndry,:])\\r\\n self.rec_track = self.df_track.to_records()\\r\\n if 'Consecutive' in methods: # need to do this first\\r\\n ncon = self.outlier_methods.index('Consecutive')\\r\\n print(\\\"calling id outliers consecutive\\\")\\r\\n max_vel = self.outlier_params[ncon][0]\\r\\n flagged_con = self.identify_outliers_consecutive(max_vel)\\r\\n for nd in range(self.ndetects):\\r\\n if flagged_con[nd] and not flagged[ndry, nd]:\\r\\n flagged[ncon, nd] = True\\r\\n if 'Iterative' in methods: # need to do this before Poly\\r\\n nit = self.outlier_methods.index('Iterative')\\r\\n max_del_vel = self.outlier_params[nit][0]\\r\\n print(\\\"calling id outliers it\\\")\\r\\n flagged_it = self.identify_outliers_iterative(max_del_vel)\\r\\n for nd in range(self.ndetects):\\r\\n if flagged_it[nd] and not flagged[ndry, nd]:\\r\\n flagged[nit, nd] = True\\r\\n if 'Poly' in methods: # need to do this last\\r\\n # assumes that Dry and Iterative flags have been set\\r\\n nm = self.outlier_methods.index('Poly')\\r\\n if 'Dry' in methods and 'Iterative' in methods:\\r\\n tot_flagged = np.maximum(flagged[nit,:],flagged[ndry,:])\\r\\n not_flagged = np.where(tot_flagged == 0)[0]\\r\\n elif 'Dry' in methods and 'Consecutive' in methods:\\r\\n tot_flagged = np.maximum(flagged[ncon,:],flagged[ndry,:])\\r\\n not_flagged = np.where(tot_flagged == 0)[0]\\r\\n elif 'Dry' in methods:\\r\\n not_flagged = np.where(flagged[ndry,:] == 0)[0]\\r\\n elif 'Iterative' in methods:\\r\\n not_flagged = np.where(flagged[nit,:] == 0)[0]\\r\\n nm = self.outlier_methods.index('Poly')\\r\\n names = params[nm][0]\\r\\n polys = params[nm][1]\\r\\n ipoly = names.index('upstream')\\r\\n poly = polys[ipoly]\\r\\n # find last point in upstream poly\\r\\n last_upstream = -1\\r\\n\\r\\n #for nd in range(self.ndetects):\\r\\n for nd in not_flagged: # only look at potentially valid pts\\r\\n tr = self.rec_track[nd]\\r\\n pt = geometry.Point([tr.X,tr.Y])\\r\\n if pt.intersects(poly):\\r\\n if not flagged[ndry,nd]:\\r\\n last_upstream = nd\\r\\n flagged[nm,0:last_upstream+1] = 1\\r\\n # find first point in downstream poly\\r\\n ipoly = names.index('downstream')\\r\\n poly = polys[ipoly]\\r\\n # find first point in downstream poly\\r\\n first_downstream = self.ndetects+1\\r\\n #for nd in range(self.ndetects):\\r\\n for nd in not_flagged: # only look at potentially valid pts\\r\\n if not flagged[nm,nd]: # not flagged as prior to upstream entry\\r\\n tr = self.rec_track[nd]\\r\\n pt = geometry.Point([tr.X,tr.Y])\\r\\n if pt.intersects(poly):\\r\\n# if not flagged[ndry,nd]:\\r\\n first_downstream = nd\\r\\n break\\r\\n flagged[nm,first_downstream:] = 1\\r\\n # check for long first/last segment but do not iterate\\r\\n max_dist = 25. # hardwire\\r\\n flagged_any = np.max(flagged,axis=0)\\r\\n not_flagged = np.where(flagged_any==0)[0]\\r\\n valid_tr = self.rec_track[not_flagged]\\r\\n if len(valid_tr) > 3:\\r\\n valid_seg = self.make_segments(input_rec_track = valid_tr)\\r\\n if valid_seg.dist[0] > max_dist: \\r\\n nd_orig = valid_tr[0].nd\\r\\n flagged[nm,nd_orig] = 1\\r\\n if valid_seg.dist[-1] > max_dist:\\r\\n nd_orig = valid_tr[-1].nd\\r\\n flagged[nm,nd_orig] = 1\\r\\n\\r\\n for nd in range(1,self.ndetects-1):\\r\\n seg1 = self.rec_seg[nd-1]\\r\\n seg2 = self.rec_seg[nd]\\r\\n tr = self.rec_track[nd]\\r\\n for nm, method in enumerate(methods):\\r\\n if method == 'Tek':\\r\\n if seg1.speed > params[nm][0]:\\r\\n flagged[nm, nd] = 1\\r\\n if method == 'Cross':\\r\\n #cross = abs(seg1.u*seg2.v - seg1.v*seg2.u)\\r\\n # change \\\"cross\\\" to vector difference\\r\\n du = seg1.u - seg2.u\\r\\n dv = seg1.v - seg2.v\\r\\n cross[nd] = np.sqrt(du*du + dv*dv)\\r\\n if cross[nd] > params[nm][0]:\\r\\n if nd > 1:\\r\\n if cross[nd] > cross_last:\\r\\n flagged[nm, nd] = 1\\r\\n flagged[nm, nd-1] = 0 \\r\\n cross_last = cross[nd]\\r\\n if method == 'Potts':\\r\\n ave_circ_std = np.average(circ_std) \\r\\n threshold = params[nm][0]*ave_circ_std\\r\\n if circ_std[nd] > threshold:\\r\\n nd_start = nd\\r\\n turning = 1\\r\\n if (circ_std[nd] < threshold) and (turning == 1):\\r\\n turning = 0\\r\\n #nd_change = int(np.rint((nd_start+nd)/2.0))\\r\\n nd_change = nd_start+np.argmax(turn_angle[nd_start:nd])\\r\\n flagged[nm, nd_change] = 1\\r\\n for nm, method in enumerate(methods):\\r\\n if method == 'Cross':\\r\\n ncol = len(self.df_track.columns)\\r\\n self.df_track.insert(ncol, 'del_vel', cross)\\r\\n if method not in ['Iterative','Dry','Consecutive']: \\r\\n ncol = len(self.df_track.columns)\\r\\n self.df_track.insert(ncol, method, flagged[nm,:])\\r\\n\\r\\n self.rec_track = self.df_track.to_records()\\r\\n\\r\\n return\",\n \"def predict_proba(self, X, method=None):\\n returnArray = []\\n if(method == None):\\n method = self.method\\n if(method == 'classical'):\\n\\n if(self.norm == 'l2'):\\n for x in X:\\n temp= [distance.euclidean(x, data) for data in self.data]\\n indices = np.asarray(temp).argsort()[:self.n_neighbors].astype(int).tolist()\\n labels_of_test = np.asarray(self.labels)[indices]\\n counts = np.bincount(labels_of_test)\\n\\n tempArray= []\\n for i in range(0,len(self.distinct_labels)):\\n tempArray.append(float(counts[self.distinct_labels[i]])/self.n_neighbors)\\n returnArray.append(tempArray)\\n if(self.norm == 'l1'):\\n for x in X:\\n temp= [distance.cityblock(x, data) for data in self.data]\\n indices = np.asarray(temp).argsort()[:self.n_neighbors].astype(int).tolist()\\n labels_of_test = np.asarray(self.labels)[indices]\\n counts = np.bincount(labels_of_test)\\n\\n tempArray= []\\n for i in range(0,len(self.distinct_labels)):\\n tempArray.append(float(counts[self.distinct_labels[i]])/self.n_neighbors)\\n returnArray.append(tempArray)\\n\\n if(method == 'weighted'):\\n for x in X:\\n if(self.norm == 'l2'):\\n temp = [distance.euclidean(x, data) for data in self.data]\\n else:\\n temp = [distance.cityblock(x, data) for data in self.data]\\n indices = np.asarray(temp).argsort()[:self.n_neighbors].astype(int).tolist()\\n labels_of_test = np.asarray(self.labels)[indices]\\n distances_to_indices = []\\n if(self.norm == 'l2'):\\n for currentIndex in range(0,self.n_neighbors):\\n currentDistance = 1/(distance.euclidean(x,self.data[indices[currentIndex]]) + 1e-15)\\n distances_to_indices.append(currentDistance)\\n else:\\n for currentIndex in range(0, self.n_neighbors):\\n currentDistance = 1 / (distance.cityblock(x, self.data[indices[currentIndex]]) + 1e-15)\\n distances_to_indices.append(currentDistance)\\n tempArray = []\\n for i in range(0, len(self.distinct_labels)):\\n currentWeight = 0.0\\n currentDistinctLabel = self.distinct_labels[i]\\n indicesToGetWeights = np.where(labels_of_test == currentDistinctLabel)[0]\\n for itr in indicesToGetWeights:\\n currentWeight += distances_to_indices[itr]\\n tempArray.append(currentWeight)\\n norm = np.linalg.norm(tempArray, ord=1)\\n tempArray/=norm\\n returnArray.append(tempArray)\\n\\n if(method == 'validity'):\\n\\n for x in X:\\n if (self.norm == 'l2'):\\n temp = [distance.euclidean(x, data) for data in self.data]\\n else:\\n temp = [distance.cityblock(x, data) for data in self.data]\\n indices = np.asarray(temp).argsort()[:self.n_neighbors].astype(int).tolist()\\n labels_of_test = np.asarray(self.labels)[indices]\\n distances_to_indices = []\\n if(self.norm == 'l2'):\\n for currentIndex in range(0, self.n_neighbors):\\n currentDistance = self.validity[indices[currentIndex]] / (\\n distance.euclidean(x, self.data[indices[currentIndex]]) + 1e-15)\\n distances_to_indices.append(currentDistance)\\n else:\\n for currentIndex in range(0, self.n_neighbors):\\n currentDistance = self.validity[indices[currentIndex]] / (\\n distance.cityblock(x, self.data[indices[currentIndex]]) + 1e-15)\\n distances_to_indices.append(currentDistance)\\n tempArray = []\\n for i in range(0, len(self.distinct_labels)):\\n currentWeight = 0.0\\n currentDistinctLabel = self.distinct_labels[i]\\n indicesToGetWeights = np.where(labels_of_test == currentDistinctLabel)[0]\\n for itr in indicesToGetWeights:\\n currentWeight += distances_to_indices[itr]\\n tempArray.append(currentWeight)\\n norm = np.linalg.norm(tempArray, ord=1)\\n tempArray /= norm\\n returnArray.append(tempArray)\\n\\n return returnArray\\n\\n pass\",\n \"def compute_statistics(self):\",\n \"def method_interpreter(self):\\n\\n dont_stop_at = [5]\\n\\n if self.run4s:\\n dont_stop_at.append(4)\\n\\n if self.method == \\\"earlystop\\\":\\n if self.total_score >= self.threshold \\\\\\n and (not self.dice_remaining in dont_stop_at):\\n self.continued = False\\n self.stopping_reason = \\\"Earlystop\\\"\\n\\n if self.method == \\\"nrolls\\\":\\n if self.rolls >= self.threshold \\\\\\n and (not self.dice_remaining in dont_stop_at):\\n self.continued = False\\n self.stopping_reason = \\\"Nrolls\\\"\\n\\n #todo compare against curve\",\n \"def _memomethods(cls, base=True, clsmethods=False):\\n if not base:\\n return set(k for k, v in iteritems(cls.__dict__)\\n if isinstance(v, MemoMethod) and\\n (clsmethods or not isinstance(v, MemoClsMethod) ) )\\n else:\\n return set().union(*(\\n subcls._memomethods(False, clsmethods)\\n for subcls in cls.mro() if issubclass(subcls, MemoClass)))\",\n \"def get_operation_obect(self, method):\\n pass\",\n \"def receptor_activity_brute_force(self, ret_correlations=False):\\n S_ni = self.sens_mat\\n Z = 0\\n r_n = np.zeros(self.Nr)\\n if ret_correlations:\\n r_nm = np.zeros((self.Nr, self.Nr))\\n \\n # iterate over all mixtures\\n for c, prob_c in self._iterate_mixtures():\\n # get the activity vector associated with m\\n a_n = (np.dot(S_ni, c) >= 1)\\n Z += prob_c\\n\\n r_n[a_n] += prob_c\\n if ret_correlations:\\n r_nm[np.outer(a_n, a_n)] += prob_c\\n \\n # return the normalized output\\n r_n /= Z\\n if ret_correlations:\\n r_nm /= Z\\n return r_n, r_nm\\n else:\\n return r_n\",\n \"def process(self, **kwargs):\\n self._score_modifier = 0.0\\n\\n # Mass of BH\\n self._Mbh = kwargs[self.key('M1')]\\n # Mass of NS\\n self._Mns = kwargs[self.key('M2')]\\n self._m_tov = kwargs[self.key('Mtov')]\\n self._Rns = kwargs[self.key('radius_ns')]\\n\\n # Soft max/min, proportional to diff^2 and scaled to -100 for 0.1 Msun\\n # 1\\n if self._Mbh < self._m_tov:\\n self._score_modifier -= (100. * (self._m_tov-self._Mbh))**2\\n \\n # 2\\n if self._Mns > self._m_tov:\\n self._score_modifier -= (100. * (self._Mns-self._m_tov))**2\\n\\n # 3\\n if self._Mns < 0.8:\\n self._score_modifier -= (100. * (0.8-self._Mns))**2\\n\\n # 4\\n if self._Rns > 16:\\n self._score_modifier -= (20. * (self._Rns-16))**2\\n\\n if self._Rns < 9:\\n self._score_modifier -= (20. * (9-self._Rns))**2\\n\\n\\n # 5\\n Mcaus = 1/2.82 * C_CGS**2 * self._Rns * KM_CGS / G_CGS / M_SUN_CGS\\n\\n if self._m_tov > Mcaus:\\n self._score_modifier -= (100. * (self._m_tov-Mcaus))**2\\n\\n return {self.key('score_modifier'): self._score_modifier}\",\n \"def outlierdetection(data,method):\\n import numpy as np\\n ##########\\n # 0. Input\\n data = np.array(data)\\n methodname = method['name']\\n rule = method['rule']\\n try:\\n mask = rule['initmask'].copy()\\n if not mask:\\n mask = np.full_like(data,True,dtype=bool)\\n rule['initmask'] = mask.copy()\\n except:\\n mask = np.full_like(data,True,dtype=bool)\\n rule['initmask'] = mask.copy()\\n ##########\\n # 1. Compute\\n if methodname in {'median','sigma'}:\\n minp,maxp = rule['minp'],rule['maxp']\\n niter = rule['niter']\\n for i in range(niter):\\n gooddata = data[mask] # good data\\n ### median or sigma\\n if methodname=='median':\\n median = np.median(gooddata)\\n minbound = minp*median\\n maxbound = maxp*median\\n elif methodname=='sigma':\\n std = np.std(gooddata)\\n median = np.median(gooddata)\\n minbound = median - minp*std\\n maxbound = median + maxp*std\\n ### update mask\\n m = np.argwhere((data >= minbound) & (data <= maxbound)).flatten() # good data\\n mask = np.full_like(data,False,dtype=bool)\\n mask[m] = True\\n print('{0} iter {1}'.format(methodname,i))\\n elif methodname == 'sn':\\n minp = rule['minp']\\n noise = rule['noise']\\n keepneg = rule['keepneg']\\n sn = data / noise\\n if keepneg:\\n sn = np.abs(sn)\\n m = np.argwhere(sn >= minp).flatten()\\n mask = np.full_like(data,False,dtype=bool)\\n mask[m] = True\\n print('{0} complete'.format(methodname))\\n elif methodname == 'sigmalocal':\\n sigma = rule['sigma']\\n noise = rule['noise']\\n keepneg = rule['keepneg']\\n niter = rule['niter']\\n params = rule['params']\\n for i in range(niter):\\n tmpdata = data[mask]\\n tmpmedian = savgol_filter(tmpdata,**params)\\n tmpnoise = noise[mask]\\n ratio = (tmpdata - tmpmedian)/tmpnoise\\n if keepneg:\\n ratio = np.abs(ratio)\\n m = np.argwhere(ratio > sigma).flatten()\\n mask[m] = False\\n print('{0} iter {1}'.format(methodname,i))\\n else:\\n raise ValueError('method {0} does not support'.format(method))\\n ##########\\n # 2. Update with the initial mask and return\\n return mask & rule['initmask']\",\n \"def prim_method(self):\",\n \"def prim_method(self):\",\n \"def area_analysis(self, method='MEAN'):\\n new_cubelist = []\\n for cube in self.cubelist:\\n new_cubelist.append(self.cube_area_analysis(cube, method))\\n self.cubelist = iris.cube.CubeList(new_cubelist)\\n self.processes.append('area_analysis')\\n return self.cubelist\",\n \"def complexity_simulate(\\n duration=10, sampling_rate=1000, method=\\\"ornstein\\\", hurst_exponent=0.5, **kwargs\\n):\\n method = method.lower()\\n if method in [\\\"fractal\\\", \\\"fractional\\\", \\\"hurst\\\", \\\"ornsteinuhlenbeck\\\", \\\"ornstein\\\"]:\\n signal = _complexity_simulate_ornstein(\\n duration=duration, sampling_rate=sampling_rate, hurst_exponent=hurst_exponent, **kwargs\\n )\\n elif method in [\\\"lorenz\\\"]:\\n # x-dimension of Lorenz system\\n signal = _attractor_lorenz(sampling_rate=sampling_rate, duration=duration, **kwargs)[:, 0]\\n elif method in [\\\"mackeyglass\\\"]:\\n signal = _complexity_simulate_mackeyglass(\\n duration=duration, sampling_rate=sampling_rate, **kwargs\\n )\\n else:\\n signal = _complexity_simulate_randomwalk(int(duration * sampling_rate))\\n return signal\",\n \"def run_method(trial, method,\\n cl_ctx=None,\\n queue=None,\\n clear_memoized_objects=False,\\n true_sol_name=\\\"True Solution\\\",\\n comp_sol_name=\\\"Computed Solution\\\", **kwargs):\\n if clear_memoized_objects:\\n global memoized_objects\\n memoized_objects = {}\\n\\n if cl_ctx is None:\\n raise ValueError(\\\"Missing cl_ctx\\\")\\n if queue is None:\\n raise ValueError(\\\"Missing queue\\\")\\n\\n # Get boundary ids\\n scatterer_bdy_id = kwargs['scatterer_bdy_id']\\n outer_bdy_id = kwargs['outer_bdy_id']\\n\\n # Get degree and wave number\\n degree = trial['degree']\\n wave_number = trial['kappa']\\n\\n # Get options prefix and solver parameters, if any\\n options_prefix = kwargs.get('options_prefix', None)\\n solver_parameters = dict(kwargs.get('solver_parameters', None))\\n\\n # Get prepared trial args in kwargs\\n prepared_trial = prepare_trial(trial, true_sol_name, cl_ctx, queue)\\n mesh, fspace, vfspace, true_sol, true_sol_grad_expr = prepared_trial\\n\\n # Create a place to memoize any objects if necessary\\n tuple_trial = trial_to_tuple(trial)\\n memo_key = tuple_trial[:2]\\n if memo_key not in memoized_objects:\\n memoized_objects[memo_key] = {}\\n\\n comp_sol = None\\n\\n # Handle any special kwargs and get computed solution\\n if method == 'pml':\\n # Get required objects\\n pml_max = kwargs['pml_max']\\n pml_min = kwargs['pml_min']\\n\\n # Get optional argumetns\\n pml_type = kwargs.get('pml_type', None)\\n quad_const = kwargs.get('quad_const', None)\\n speed = kwargs.get('speed', None)\\n\\n # Make tensor function space\\n if 'tfspace' not in memoized_objects[memo_key]:\\n memoized_objects[memo_key]['tfspace'] = \\\\\\n TensorFunctionSpace(mesh, 'CG', degree)\\n\\n tfspace = memoized_objects[memo_key]['tfspace']\\n\\n snes, comp_sol = pml(mesh, scatterer_bdy_id, outer_bdy_id, wave_number,\\n options_prefix=options_prefix,\\n solver_parameters=solver_parameters,\\n fspace=fspace, tfspace=tfspace,\\n true_sol_grad_expr=true_sol_grad_expr,\\n pml_type=pml_type, quad_const=quad_const,\\n speed=speed,\\n pml_min=pml_min,\\n pml_max=pml_max,\\n )\\n snes_or_ksp = snes\\n\\n elif method == 'nonlocal':\\n # Build DG spaces if not already built\\n if 'dgfspace' not in memoized_objects[memo_key]:\\n memoized_objects[memo_key]['dgfspace'] = \\\\\\n FunctionSpace(mesh, 'DG', degree)\\n if 'dgvfspace' not in memoized_objects[memo_key]:\\n memoized_objects[memo_key]['dgvfspace'] = \\\\\\n VectorFunctionSpace(mesh, 'DG', degree)\\n\\n dgfspace = memoized_objects[memo_key]['dgfspace']\\n dgvfspace = memoized_objects[memo_key]['dgvfspace']\\n\\n # Get opencl array context\\n from meshmode.array_context import PyOpenCLArrayContext\\n actx = PyOpenCLArrayContext(queue)\\n\\n # Build connection fd -> meshmode if not already built\\n if 'meshmode_src_connection' not in memoized_objects[memo_key]:\\n from meshmode.interop.firedrake import build_connection_from_firedrake\\n memoized_objects[memo_key]['meshmode_src_connection'] = \\\\\\n build_connection_from_firedrake(\\n actx,\\n dgfspace,\\n grp_factory=None,\\n restrict_to_boundary=scatterer_bdy_id)\\n\\n meshmode_src_connection = memoized_objects[memo_key]['meshmode_src_connection']\\n\\n # Set defaults for qbx kwargs\\n qbx_order = kwargs.get('qbx_order', degree+2)\\n fine_order = kwargs.get('fine_order', 4 * degree)\\n fmm_order = kwargs.get('FMM Order', None)\\n fmm_tol = kwargs.get('FMM Tol', None)\\n # make sure got either fmm_order xor fmm_tol\\n if fmm_order is None and fmm_tol is None:\\n raise ValueError(\\\"At least one of 'fmm_order', 'fmm_tol' must not \\\"\\n \\\"be *None*\\\")\\n if fmm_order is not None and fmm_tol is not None:\\n raise ValueError(\\\"At most one of 'fmm_order', 'fmm_tol' must not \\\"\\n \\\"be *None*\\\")\\n # if got fmm_tol, make a level-to-order\\n fmm_level_to_order = None\\n if fmm_tol is not None:\\n if not isinstance(fmm_tol, float):\\n raise TypeError(\\\"fmm_tol of type '%s' is not of type float\\\" % type(fmm_tol))\\n if fmm_tol <= 0.0:\\n raise ValueError(\\\"fmm_tol of '%s' is less than or equal to 0.0\\\" % fmm_tol)\\n from sumpy.expansion.level_to_order import SimpleExpansionOrderFinder \\n fmm_level_to_order = SimpleExpansionOrderFinder(fmm_tol)\\n # Otherwise, make sure we got a valid fmm_order\\n else:\\n if not isinstance(fmm_order, int):\\n if fmm_order != False:\\n raise TypeError(\\\"fmm_order of type '%s' is not of type int\\\" % type(fmm_order))\\n if fmm_order != False and fmm_order < 1:\\n raise ValueError(\\\"fmm_order of '%s' is less than 1\\\" % fmm_order)\\n\\n qbx_kwargs = {'qbx_order': qbx_order,\\n 'fine_order': fine_order,\\n 'fmm_order': fmm_order,\\n 'fmm_level_to_order': fmm_level_to_order,\\n 'fmm_backend': 'fmmlib',\\n }\\n # }}}\\n\\n ksp, comp_sol = nonlocal_integral_eq(\\n mesh, scatterer_bdy_id, outer_bdy_id,\\n wave_number,\\n options_prefix=options_prefix,\\n solver_parameters=solver_parameters,\\n fspace=fspace, vfspace=vfspace,\\n true_sol_grad_expr=true_sol_grad_expr,\\n actx=actx,\\n dgfspace=dgfspace,\\n dgvfspace=dgvfspace,\\n meshmode_src_connection=meshmode_src_connection,\\n qbx_kwargs=qbx_kwargs,\\n )\\n\\n snes_or_ksp = ksp\\n\\n elif method == 'transmission':\\n\\n snes, comp_sol = transmission(mesh, scatterer_bdy_id, outer_bdy_id,\\n wave_number,\\n options_prefix=options_prefix,\\n solver_parameters=solver_parameters,\\n fspace=fspace,\\n true_sol_grad_expr=true_sol_grad_expr,\\n )\\n snes_or_ksp = snes\\n else:\\n raise ValueError(\\\"Invalid method\\\")\\n\\n comp_sol.rename(name=comp_sol_name)\\n return true_sol, comp_sol, snes_or_ksp\",\n \"def __call__(self, num_perms=999):\\r\\n res = super(PartialMantel, self).__call__(num_perms)\\r\\n\\r\\n # Calculate the correlation statistic.\\r\\n corr = lambda rxy, rxz, ryz: (rxy - rxz * ryz) / (sqrt(1 -\\r\\n rxz ** 2) * sqrt(1 - ryz ** 2))\\r\\n # Load initial/placeholder values in the results dictionary.\\r\\n res['method_name'] = 'Partial Mantel'\\r\\n res['mantel_r'] = None\\r\\n res['mantel_p'] = None\\r\\n\\r\\n dm1, dm2, cdm = self.DistanceMatrices\\r\\n dm1_flat = dm1.condensed_form()\\r\\n dm2_flat = dm2.condensed_form()\\r\\n cdm_flat = cdm.condensed_form()\\r\\n\\r\\n # Get the initial r-values before permuting.\\r\\n rval1 = pearson(dm1_flat, dm2_flat)\\r\\n rval2 = pearson(dm1_flat, cdm_flat)\\r\\n rval3 = pearson(dm2_flat, cdm_flat)\\r\\n\\r\\n # Calculate the original test statistic (r-value).\\r\\n orig_stat = corr(rval1, rval2, rval3)\\r\\n\\r\\n # Calculate permuted r-values and p-values, storing them for use in the\\r\\n # calculation of the final statistic.\\r\\n perm_stats = []\\r\\n numerator = 0\\r\\n for i in range(0, num_perms):\\r\\n # Permute the first distance matrix and calculate new r and\\r\\n # p-values.\\r\\n p1 = permute_2d(dm1, permutation(dm1.shape[0]))\\r\\n dm1_perm = DistanceMatrix(p1, dm1.ids)\\r\\n dm1_perm_flat = dm1_perm.condensed_form()\\r\\n rval1 = pearson(dm1_perm_flat, dm2_flat)\\r\\n rval2 = pearson(dm1_perm_flat, cdm_flat)\\r\\n perm_stats.append(corr(rval1, rval2, rval3))\\r\\n\\r\\n if perm_stats[-1] >= orig_stat:\\r\\n numerator += 1\\r\\n # Load the final statistics into the result dictionary.\\r\\n res['mantel_r'] = orig_stat\\r\\n res['mantel_p'] = (numerator + 1) / (num_perms + 1)\\r\\n return res\",\n \"def CalculateProcessingCapacity(self, problemManager, mineDataManager):\\n \\n self.oreProcessed = np.zeros(len(mineDataManager.theMiningSystem.oreMined)) \\n self.processingPower = np.zeros(len(mineDataManager.theMiningSystem.oreMined)) \\n self.processingCapacity = mineDataManager.theMiningSystem.mineOreProductionCapacity # ore is processed at a constant rate\\n carryOver = 0.0\\n for year in range( len(mineDataManager.theMiningSystem.oreMined )-1 ):\\n processedOre = carryOver + mineDataManager.theMiningSystem.oreMined[year]\\n \\n if(processedOre > self.processingCapacity):\\n carryOver = processedOre - self.processingCapacity\\n processedOre = self.processingCapacity\\n else:\\n carryOver = 0.0\\n self.oreProcessed[year] = processedOre\\n \\n self.oreProcessed[-1] = carryOver + mineDataManager.theMiningSystem.oreMined[-1] # final year\\n \\n \\n # convert tonnes processed each year to the number of Mwh based on powerlaw fit\\n self.processingPower = 3.96*(self.oreProcessed )**0.703 # in Mwh\\n \\n referenceMetalStr = mineDataManager.theOreBody.type[:2] \\n # first two letters of orebody type is assumed to be reference metal for determining processing grade\\n # eg AuCu -> gold is reference metal - note that user must select correct method\\n \\n \\n referenceMetalOreConcentration = mineDataManager.theOreBody.metalGrades[referenceMetalStr]\\n\\n self.concentrateMetalConcentration = 1.0\\n \\n # lookup concentrateMetalConcentrations based on reference metal type\\n \\n concentrateConcentrations = {\\\"Au\\\":0.75,\\\"Ag\\\":0.85,\\\"Ni\\\":0.1,\\\"Cu\\\":0.25,\\\"Pb\\\":0.5}\\n \\n # find the minimum amount of concentration needed to bring concentrate to market\\n minConcentrationFactor = 1e64\\n \\n for metal,metalOreGrade in mineDataManager.theOreBody.metalGrades.iteritems():\\n if metal in concentrateConcentrations:\\n concentrateGrade = concentrateConcentrations[metal]\\n concFactor = concentrateGrade/(metalOreGrade/(1.0+ mineDataManager.theMiningSystem.dilution) +1e-64)\\n if concFactor < 1.0:\\n concFactor = 1.0\\n #print \\\"concFactor\\\", metal, concFactor, metalOreGrade, concentrateGrade\\n if(concFactor < minConcentrationFactor ):\\n minConcentrationFactor = concFactor\\n self.concentrateMetalConcentration = concentrateGrade\\n \\n # concentrate is calculated based on estimate of mineral content\\n self.concentrateProduced = (1.0 - self.processingLoss) \\\\\\n *np.array(mineDataManager.theMiningSystem.oreMined)/minConcentrationFactor \\n \\n \\n return self.processingCapacity\",\n \"def random_behavior(self, method=\\\"norm\\\"):\\n if method==\\\"norm\\\":\\n X = np.random.rand(self.N, self.Q, self.M)\\n X = X / X.sum(axis=2).repeat(self.M).reshape(self.N, self.Q,\\n self.M)\\n elif method == \\\"diff\\\":\\n X = np.random.rand(self.N, self.Q, self.M-1)\\n X = np.concatenate((np.zeros((self.N, self.Q, 1)),\\n np.sort(X, axis=-1),\\n np.ones((self.N, self.Q, 1))), axis=-1)\\n X = X[:, :, 1:] - X[:, :, :-1]\\n return X\",\n \"def scsistim(self, method='mean', width=None, tres=None, timeaverage=False,\\n plottime=False, s=5, figsize=(7.5, 6.5)):\\n ## TODO: maybe limit to visually responsive cells\\n ## TODO: add linear regression of si vs log(sc)\\n\\n uns = get_ipython().user_ns\\n if width == None:\\n width = uns['LFPSIWIDTH']\\n if tres == None:\\n tres = width\\n bsrids = uns['BSRIDS'][self.absname]\\n msrids = uns['MSRIDS'][self.absname]\\n mvrids = uns['NSRIDS'][self.absname]\\n dbrids = uns['DBRIDS'][self.absname]\\n rids = sorted(bsrids + msrids + mvrids + dbrids) # do everything in rid order\\n print('blankscreen: %r' % [self.r[rid].name for rid in bsrids])\\n print('mseq: %r' % [self.r[rid].name for rid in msrids])\\n print('movie: %r' % [self.r[rid].name for rid in mvrids])\\n print('driftbar: %r' % [self.r[rid].name for rid in dbrids])\\n isect = core.intersect1d([msrids, bsrids, mvrids, dbrids])\\n if len(isect) != 0:\\n raise RuntimeError(\\\"some rids were classified into more than one type: %r\\\" % isect)\\n\\n scs, sis, c = [], [], []\\n for rid in rids:\\n r = self.r[rid]\\n print('%s: %s' % (r.absname, r.name))\\n spikecorr = r.sc(width=width, tres=tres)\\n \\\"\\\"\\\"\\n TODO: not sure if this is the right way to do this. A different set of neurons for\\n each recording are chosen, then mean sc(t) across all pairs for each recording is\\n found, and pooled across recordings. This pooling is maybe a bit dodgy. Is it\\n valid to pool sc(t) values across recordings when the included neurons are\\n different for each recording? The alternative is to deal only with neurons which\\n exceed MINTHRESH track-wide, but the problem with that is that for much of the\\n time, such neurons are completely silent, and therefore don't deserve to be\\n included in sc calculations for those durations.\\n \\\"\\\"\\\"\\n sc, si = spikecorr.si(method=method, plot=False) # calls sc.sct() and sc.si()\\n sc = sc[0] # pull out the spike correlation values that span all laminae\\n if timeaverage:\\n # average across all time values of sc and si to get a single coordinate\\n # per recording\\n sc = sc.mean()\\n si = si.mean()\\n scs.append(sc)\\n sis.append(si)\\n if rid in bsrids: color = 'e'\\n elif rid in msrids: color = 'k'\\n elif rid in mvrids: color = 'r'\\n elif rid in dbrids: color = 'b'\\n else: raise ValueError(\\\"unclassified recording: %r\\\" % r.name)\\n c.append(np.tile(color, len(sc)))\\n scs = np.hstack(scs)\\n sis = np.hstack(sis)\\n c = np.hstack(c)\\n \\n f = pl.figure(figsize=figsize)\\n a = f.add_subplot(111)\\n if plottime: # underplot lines connecting points adjacent in time\\n a.plot(scs, sis, 'e--')\\n a.scatter(scs, sis, c=c, edgecolors='none', s=s)\\n a.set_ylim(0, 1)\\n a.set_xlabel('%s spike correlations' % method)\\n a.set_ylabel('synchrony index')\\n titlestr = lastcmd()\\n gcfm().window.setWindowTitle(titlestr)\\n a.set_title(titlestr)\\n # make proxy line artists for legend:\\n bs = mpl.lines.Line2D([1], [1], color='white', marker='o', mfc='e', mec='e')\\n ms = mpl.lines.Line2D([1], [1], color='white', marker='o', mfc='k', mec='k')\\n mv = mpl.lines.Line2D([1], [1], color='white', marker='o', mfc='r', mec='r')\\n db = mpl.lines.Line2D([1], [1], color='white', marker='o', mfc='b', mec='b')\\n # add legend:\\n a.legend([bs, ms, mv, db],\\n ['blank screen', 'mseq', 'movie', 'drift bar'],\\n numpoints=1, loc='lower right',\\n handlelength=1, handletextpad=0.5, labelspacing=0.1)\\n f.tight_layout(pad=0.3) # crop figure to contents\\n return scs, sis, c\",\n \"def nmi(y_pred, y_true, average_method='geometric'):\\n return metrics.normalized_mutual_info_score(y_true, y_pred, average_method=average_method)\",\n \"def timeit(method):\\n log = LogMixin()\\n\\n def timed(*args, **kw):\\n ts = time.time()\\n result = method(*args, **kw)\\n te = time.time()\\n\\n log.logger.info(f'''{method.__qualname__} took\\n {round(te - ts, 3)}s seconds''')\\n\\n return result\\n\\n timed.__name__ = method.__name__\\n timed.__doc__ = method.__doc__\\n\\n return timed\",\n \"def measureMotorSpecsOne(self,distance):\\n #self.dataQueue=queue.Queue()\\n #controlQueue=queue.Queue()\\n returnQueue1=queue.Queue()\\n #returnQueue2=queue.Queue()\\n \\n t1=threading.Thread(target=self.updaterTest,args=(distance,returnQueue1,))\\n #t2=threading.Thread(target=self.xMotorTest,args=(distance,returnQueue1,))\\n #t3=threading.Thread(target=self.yMotorTest,args=(distance,returnQueue2,))\\n t1.start()\\n t1.join()\\n #t2.start()\\n #t3.start()\\n while returnQueue1.empty():# and returnQueue2.empty():\\n pass\\n\\n\\n speed1=distance/returnQueue1.get()\\n #speed2=distance/returnQueue2.get()\\n return speed1#,speed2\",\n \"def calculate_all_metrcis(self):\\n self.calculate_gc_metrcis()\\n self.calculate_sam_metrics()\\n self.calculate_classification_metrics()\\n self.calculate_losses()\",\n \"def test_coherence():\\r\\n\\r\\n for method in methods:\\r\\n f, c = tsa.coherence(tseries, csd_method=method)\\r\\n npt.assert_array_almost_equal(c[0, 1], c[1, 0])\\r\\n npt.assert_array_almost_equal(c[0, 0], np.ones(f.shape))\",\n \"def main():\\n run_simulation(spectral=False, ml=False, num_procs=1)\\n run_simulation(spectral=True, ml=False, num_procs=1)\\n run_simulation(spectral=False, ml=True, num_procs=1)\\n run_simulation(spectral=True, ml=True, num_procs=1)\\n run_simulation(spectral=False, ml=True, num_procs=10)\\n run_simulation(spectral=True, ml=True, num_procs=10)\",\n \"def analyzeImage(path, res, method='cleantests', MoDirt='mo', \\n Mask=0, autoMaskEdges=False, stdDir='standards/', verbose=False):\\n img = fun.loadImg(path)\\n MoDirt = fun.checkMoDirt(MoDirt)\\n \\n if Mask==0:\\n mask = np.ones(img.shape)\\n elif type(Mask)==np.ndarray and Mask.shape == img.shape:\\n mask = Mask.copy()\\n else:\\n raise Exception\\n # Uses my OLD maskEdges function to mask off the dark area around a foil if \\n # specified. \\n if autoMaskEdges:\\n maskedImg, mask = fun.maskEdge(img)\\n retData = {}\\n \\n # MOLYBDENUM ANALYSIS ======================================================\\n if MoDirt == 'mo':\\n # Method used by cleantests ––––––––––––––––––––––––––––––––––––\\n if method.lower() in ['cleantests','smallfoils', 'cleantest']:\\n (PtArea, \\n FoilArea, \\n MolyArea, \\n MolyMass, \\n threshed) = Monalysis(img, res,verbose=verbose)\\n \\n PercPt = 100*PtArea/FoilArea\\n poster = fun.makePoster(img)\\n \\n # Method used by bigfoils –––––––––––––––––––––––––––––––––––––\\n elif method.lower() in ['bigfoils','big','bigscans','no border']:\\n stats, picts = ImgAnalysis(img, mask, res, MoDirt=MoDirt,returnSizes=False)\\n (PtArea,\\n FoilArea,\\n PercPt) = stats\\n MolyArea = FoilArea-PtArea\\n MolyMass = MolyArea*.3*10.2 #moly mass in micrograms\\n (threshed, poster) = picts\\n \\n # Method Used by Histogram Analysis (newmethod) ––––––––––––––––––––\\n elif method.lower() in ['newmethod', 'histograms', 'histo', 'histogram']:\\n stats, picts = analyzeByHisto (img, res, \\n Mask=mask, verbose=verbose,\\n MoDirt=MoDirt, returnPoster=True,\\n returnData=False,returnSizes=False)\\n (PtArea,\\n PercPt,\\n FoilArea) = stats\\n \\n MolyArea = FoilArea-PtArea\\n MolyMass = MolyArea*.3*10.2 #moly mass in micrograms\\n \\n (threshed, poster) = picts\\n \\n # STANDARD ANALYSIS –––––––––––––––––––––––––––––––––––––––––––\\n elif method.lower() in ['standards','standard','std','stds']:\\n poster = fun.posterfy(img)\\n imgName = os.path.splitext(os.path.split(path)[1])[0]\\n PtMapPath = os.path.join(stdDir, 'all_plat/')+imgName+'.png'\\n if os.path.exists(PtMapPath):\\n threshed = fun.loadImg(PtMapPath)\\n PtArea = meas.calcExposedPt(threshed, res, getAreaInSquaremm=True)\\n PixFoil = np.sum(mask.astype(np.bool_))\\n FoilArea = round(PixFoil*res*10**-6, 4)\\n MolyArea = FoilArea-PtArea\\n MolyMass = MolyArea*.3*10.2 #moly mass in micrograms\\n if FoilArea == 0:\\n PercPt = 0\\n else:\\n PercPt = round(float(PtArea)/float(FoilArea)*100,2)\\n else:\\n print \\\"Not a standard: \\\" + imgName\\n print \\\" File path does not Exist: \\\" + PtMapPath\\n retData = blankDataDict(MoDirt)\\n threshed = blankImg(img.shape)\\n return retData, (threshed, poster)\\n \\n # UNMATCHED METHOD ––––––––––––––––––––––––––––––––––––––––––––\\n else:\\n raise Exception(\\\"\\\"\\\"The specified method is not available: {0} \\\\n\\n Method should be one of the following: \\\\n\\n 'cleantests','bigfoils','histogram','standard'.\\n \\\"\\\"\\\".format(str(method)))\\n \\n # Prepare Return Data Dictionary ---------------------------------------\\n retData = {'Pt Area (mm^2)':round(PtArea,4),\\n 'Foil Area (mm^2)':round(FoilArea,2),\\n 'Moly Area (mm^2)':round(MolyArea,3),\\n 'Mass Molybdenum (micrograms)':round(MolyMass,3),\\n '% Exposed Pt':round(PercPt,3)}\\n \\n # DIRT ANALYSIS ============================================================\\n elif MoDirt == 'dirt':\\n \\n # Method used by cleantests ––––––––––––––––––––––––––––––––––––\\n if method.lower() in ['cleantests','smallfoils', 'cleantest','ct','foils']:\\n (DirtNum,\\n DirtArea,\\n threshed,\\n DirtSizes) = dirtnalysis (img, res, MaskEdges=True, retSizes=True)\\n \\n poster = fun.makePoster(img)\\n \\n # Method used by bigfoils –––––––––––––––––––––––––––––––––––––\\n elif method.lower() in ['bigfoils','big','bigscans','no border']:\\n stats, picts = ImgAnalysis(img, mask, res, \\n MoDirt=MoDirt,returnSizes=True)\\n (DirtNum,\\n DirtArea,\\n AreaFoil,\\n Perc,\\n DirtSizes) = stats\\n \\n (threshed, poster) = picts\\n \\n # Method Used by Histogram Analysis (newmethod) ––––––––––––––––––––\\n elif method.lower() in ['newmethod', 'histograms', 'histo', 'histogram']:\\n stats, picts = analyzeByHisto (img, res, \\n Mask=mask, verbose=verbose,\\n MoDirt=MoDirt, returnPoster=True,\\n returnData=False,returnSizes=True)\\n (DirtNum,\\n DirtArea,\\n DirtSizes,\\n AreaFoil) = stats\\n \\n \\n (threshed, poster) = picts\\n \\n # STANDARD ANALYSIS –––––––––––––––––––––––––––––––––––––––––––\\n elif method.lower() in ['standards','standard','std','stds']:\\n poster = fun.posterfy(img)\\n imgName = os.path.splitext(os.path.split(path)[1])[0]\\n DirtMapPath = os.path.join(stdDir, 'all_dirt/')+imgName+'.png'\\n if os.path.exists(DirtMapPath):\\n threshed = fun.loadImg(DirtMapPath)\\n (DirtArea, \\n DirtNum,\\n DirtSizes,\\n labeled) = meas.calcDirt(threshed,\\n res, \\n returnSizes=True,\\n returnLabelled=True, \\n getAreaInSquaremm=True) \\n else:\\n print \\\"Not a standard: \\\" + imgName\\n print \\\" File path does not Exist: \\\" + DirtMapPath\\n retData = blankDataDict(MoDirt)\\n threshed = blankImg(img.shape)\\n return retData, (threshed, poster)\\n \\n # UNMATCHED METHOD ––––––––––––––––––––––––––––––––––––––––––––\\n else:\\n raise Exception(\\\"\\\"\\\"The specified method is not available: {0} \\\\n\\n Method should be one of the following: \\\\n\\n 'cleantests','bigfoils','histogram','standard'.\\n \\\"\\\"\\\".format(str(method)))\\n \\n # Prepare Return Data Dictionary ---------------------------------------\\n (MeanSize, \\n MaxSize, \\n percOver100) = meas.getDirtSizeData(DirtSizes, res)\\n \\n retData = {'Dirt Count':DirtNum,\\n 'Dirt Area (mm^2)':round(DirtArea, 5),\\n 'Mean Particle Area (micron^2)':round(MeanSize,1),\\n 'Max Particle Area (micron^2)':round(MaxSize,1),\\n '% Dirt Particles over 100micron diameter':round(percOver100,3)}\\n \\n # Return results\\n retPicts = (threshed,poster)\\n \\n return retData, retPicts\",\n \"def propagator(self, t, method='SOS'):\\n\\n\\n # construct total liouvillian\\n if self.R is None:\\n raise TypeError('Redfield tensor is not computed. Please call redfield_tensor()')\\n\\n\\n if method == 'EOM':\\n\\n U = expm(self.R, t)\\n\\n # store the Green's function for future use G(t) = -1j * (t>0) * U(t)\\n # G = np.zeros((self.dim**2, self.dim**2, len(t)), dtype=complex)\\n # for n in range(len(t)):\\n # G[:,:, n] = -1j * U[n].toarray()\\n\\n # G = -1j * np.dstack(U)\\n\\n U = [_.toarray() for _ in U]\\n\\n self.U = np.dstack(U)\\n\\n elif method in ['eseries', 'SOS']:\\n\\n evals1, U1 = eig(self.R.toarray())\\n\\n U2 = scipy.linalg.inv(U1)\\n\\n E = np.exp(evals1[:,np.newaxis] * t[np.newaxis,:])\\n # self.U = np.einsum('aj, jk, jb -> abk', U1, E, U2)\\n self.U = oe.contract('aj, jk, jb -> abk', U1, E, U2)\\n\\n self.G = -1j * self.U\\n\\n return self.U\",\n \"def evaluate(self,\\n results,\\n metric='mIoU',\\n logger=None,\\n efficient_test=False,\\n **kwargs):\\n if isinstance(metric, str):\\n metric = [metric]\\n allowed_metrics = ['mIoU', 'mIoUv1', 'mIoUv2','mAP']\\n if not set(metric).issubset(set(allowed_metrics)):\\n raise KeyError('metric {} is not supported'.format(metric))\\n tp = torch.cat([res[0][None, ...] for res in results], dim=0) #N*C\\n fp = torch.cat([res[1][None, ...] for res in results], dim=0) #N*C\\n fn = torch.cat([res[2][None, ...] for res in results], dim=0) #N*C\\n valids = torch.cat([res[3][None,...] for res in results],dim=0) #N*C\\n for met in metric:\\n if met=='mIoU':\\n ious = tp.sum(0).float()/(tp.sum(0)+fp.sum(0)+fn.sum(0)).float()\\n print_log('\\\\nper class results (iou):', logger)\\n for cid in range(len(self.CLASSES)):\\n print_log('%.04f:%s tp:%d fp:%d fn:%d' % (ious[cid], self.CLASSES[cid], tp.sum(0)[cid],fp.sum(0)[cid],fn.sum(0)[cid]), logger)\\n print_log('%s: %.04f' % (met, ious.mean()), logger)\\n elif met == 'mIoUv1':\\n ious = tp.float() / (tp + fp + fn).float()\\n print_log('\\\\nper class results (iou):', logger)\\n miou, valid_class = 0, 0\\n for cid in range(len(self.CLASSES)):\\n iou_c = ious[:, cid][valids[:, cid]]\\n if iou_c.shape[0] > 0:\\n iou_c = iou_c.mean()\\n miou += iou_c\\n valid_class += 1\\n else:\\n iou_c = -1\\n print_log('%.04f:%s' % (iou_c, self.CLASSES[cid]), logger)\\n print_log('%s: %.04f' % (met, miou / valid_class), logger)\\n elif met == 'mIoUv2':\\n ious = tp.sum(-1).float() / (tp.sum(-1) + fp.sum(-1) + fn.sum(-1)).float()\\n print_log('\\\\n%s: %.04f' % (met, ious.mean()), logger)\\n elif met == 'mAP':\\n ious = tp.sum(0).float()/(tp.sum(0)+fp.sum(0)).float()\\n print_log('\\\\nper class results (iou):', logger)\\n for cid in range(len(self.CLASSES)):\\n print_log('%.04f:%s tp:%d fp:%d' % (ious[cid], self.CLASSES[cid], tp.sum(0)[cid],fp.sum(0)[cid]), logger)\\n print_log('%s: %.04f' % (met, ious.mean()), logger)\\n else:\\n assert False, 'nuknown metric type %s'%metric\",\n \"def measure(self, recommender):\\n similarity = 0\\n interactions = recommender.interactions\\n if interactions.size == 0:\\n self.observe(None) # no interactions yet\\n return\\n\\n if self.interaction_hist is None:\\n self.interaction_hist = np.copy(interactions).reshape((-1, 1))\\n else:\\n self.interaction_hist = np.hstack(\\n [self.interaction_hist, interactions.reshape((-1, 1))]\\n )\\n for pair in self.pairs:\\n itemset_1 = set(self.interaction_hist[pair[0], :])\\n itemset_2 = set(self.interaction_hist[pair[1], :])\\n common = len(itemset_1.intersection(itemset_2))\\n union = len(itemset_1.union(itemset_2))\\n similarity += common / union / len(self.pairs)\\n self.observe(similarity)\",\n \"def conditionDecodings(data, rois, ncvs=100, effects=False, motorOutput=False,confusion=False, decoder='similarity', nproc=5):\\n \\n ncond = data.shape[1] # two motor outputs\\n nSubjs = data.shape[2]\\n\\n nsamples = nSubjs * ncond\\n stats = np.zeros((len(rois),nsamples))\\n rmatches = np.zeros((len(rois),))\\n rmismatches = np.zeros((len(rois),))\\n\\n # Label array for supervised learning\\n labels = np.tile(range(ncond),nSubjs)\\n subjarray = np.repeat(range(nSubjs),ncond)\\n\\n # Run SVM classifications on network-level activation patterns across subjects\\n confusion_mats = []\\n roicount = 0\\n for roi in rois:\\n roi_ind = np.where(glasser2==roi+1)[0]\\n nfeatures = len(roi_ind)\\n roi_ind.shape = (len(roi_ind),1) \\n\\n svm_mat = np.zeros((nsamples,roi_ind.shape[0]))\\n samplecount = 0\\n for scount in range(nSubjs):\\n roidata = np.squeeze(data[roi_ind,:,scount])\\n svm_mat[samplecount:(samplecount+ncond),:] = roidata.T\\n\\n samplecount += ncond\\n\\n # Spatially demean matrix across features\\n# samplemean = np.mean(svm_mat,axis=1)\\n# samplemean.shape = (len(samplemean),1)\\n# svm_mat = svm_mat - samplemean\\n \\n scores, rmatch, rmismatch, confusion_mat = randomSplitLOOBaselineCV(ncvs, svm_mat, labels, subjarray, \\n motorOutput=motorOutput, decoder=decoder, nproc=nproc)\\n stats[roicount,:] = scores\\n rmatches[roicount] = np.mean(rmatch)\\n rmismatches[roicount] = np.mean(rmismatch)\\n confusion_mats.append(confusion_mat)\\n roicount += 1\\n \\n if effects and confusion:\\n return stats, rmatch, rmismatch, confusion_mats\\n if effects and not confusion:\\n return stats, rmatch, rmismatch\\n if confusion and not effects:\\n return stats, confusion_mats\\n else:\\n return stats\",\n \"def _check_aggregation_method(self, method):\\n if method not in {self._MEAN, self._MEDIAN, self._WEIGHTED_MEAN}:\\n raise ValueError(\\n f\\\"Invalid aggregation_method: {method}.\\\\n\\\"\\n f\\\"Valid options are: {(self._MEAN, self._MEDIAN, self._WEIGHTED_MEAN)}\\\"\\n )\",\n \"def automf(self, method:str='trimf', **kwargs) -> dict:\\n if self.linguistic_terms is None:\\n raise ValueError('Linguistic terms are not defined!')\\n elif self.universe is None:\\n raise ValueError('Universe of discourse is not defined!')\\n \\n membership = MembershipStore.get(method)()\\n\\n return membership.membershipFunction(linguistic_terms=self.linguistic_terms, \\n universe=self.universe, params = kwargs)\",\n \"def _do_estimate(recommendation_type: str, pipfile: Pipfile) -> None:\",\n \"def simulation_method(simulate_method):\\n\\n def decorated_simulate_method(self):\\n self._start_simulation()\\n result = simulate_method(self)\\n self._end_simulation()\\n self.data = result\\n return result\\n\\n return decorated_simulate_method\",\n \"def results_muscles(self):\\n\\n angle = self.res[:, 0]\\n\\n m1_state = self.res[:, 2:4]\\n m2_state = self.res[:, 4:6]\\n\\n # Initializing the muscles results dictionary\\n res_muscles = {'muscle1': np.empty(\\n (len(angle), 7)), 'muscle2': np.empty((len(angle), 7))}\\n\\n # Get the muscle objects\\n m1 = self.sys.muscle_sys.Muscle1\\n m2 = self.sys.muscle_sys.Muscle2\\n\\n # Iterate over the states to re compute the paramters\\n for i, angle_ in enumerate(angle):\\n\\n delta_length = self.sys.muscle_sys.delta_length_from_angle(angle_)\\n\\n # Muscle 1\\n res_muscles['muscle1'][i, :] = m1.ode_result(\\n m1_state[i, 0], m1_state[i, 1], delta_length[0])\\n # Muscle 2\\n res_muscles['muscle2'][i, :] = m2.ode_result(\\n m2_state[i, 0], m2_state[i, 1], delta_length[1])\\n\\n return res_muscles\",\n \"def gbids(self, method=\\\"median\\\", pattr=None, **kwargs):\\n import gblearn.selection as sel\\n from functools import partial\\n methmap = {\\n \\\"median\\\": sel.median,\\n \\\"cna\\\": partial(sel.cna_max, coord=0),\\n\\t \\\"cna_z\\\": partial(sel.cna_max, coord=2)\\n }\\n if method in methmap:\\n extra = getattr(self, pattr) if pattr is not None else None\\n return methmap[method](self.xyz, extra, types=self.types, **kwargs)\",\n \"def measure(self, recommender):\",\n \"def test_compare_categories_numeric_variables(self):\\r\\n for method in self.num_methods:\\r\\n compare_categories(self.dm1_fp, self.map1_fp, method,\\r\\n self.num_categories, self.num_perms, self.test_dir)\\r\\n results_fp = join(self.test_dir, '%s_results.txt' % method)\\r\\n self.files_to_remove.append(results_fp)\\r\\n results_f = open(results_fp, 'U')\\r\\n results = results_f.readlines()\\r\\n results_f.close()\\r\\n self.assertTrue(len(results) > 0)\",\n \"def photocurrent_density(self, port='Substrate_bottom', method='flux'):\\n\\n if method not in ('flux', 'integral'):\\n msg = 'Invalid method {} for computing photocurrent density'.format(method)\\n raise ValueError(msg)\\n\\n print(self.grouped_against)\\n if not tuple(self.grouped_against) == ('Simulation', 'params', 'frequency'):\\n raise ValueError('Can only compute photocurrent density when '\\n 'grouped against frequency')\\n\\n\\n base = os.path.expandvars(self.sims[0].conf['General']['results_dir'])\\n period = self.sims[0].conf['Simulation']['params']['array_period']\\n self.log.info('Computing photocurrent density for group at %s', base)\\n jph_vals = np.zeros(self.num_sims)\\n freqs = np.zeros(self.num_sims)\\n for i, sim in enumerate(self.sims):\\n freq = sim.conf['Simulation']['params']['frequency']\\n freqs[i] = freq\\n # Assuming the sims have been grouped by frequency, sum over all of\\n # them\\n for i, sim in enumerate(self.sims):\\n # freq = sim.conf['Simulation']['params']['frequency']\\n # freqs[i] = freq\\n E_photon = consts.h * freq\\n if method == 'flux':\\n # arr = sim.data['transmission_data']\\n # _, ref, trans, absorb = arr[arr.port == port.encode('utf-8')][0]\\n # incident_power = get_incident_power(sim)\\n # jph_vals[i] = incident_power * absorb / E_photon\\n try:\\n abs_arr = sim.data['abs_per_layer']\\n except KeyError:\\n abs_arr = sim.absorption_per_layer()\\n absorbed_power = np.sum(abs_arr['flux_method'])\\n jph_vals[i] = absorbed_power / (E_photon*period**2)\\n else:\\n try:\\n abs_arr = sim.data['abs_per_layer']\\n except KeyError:\\n abs_arr = sim.absorption_per_layer()\\n absorbed_power = np.sum(abs_arr['int_method'])\\n jph_vals[i] = absorbed_power / (E_photon*period**2)\\n sim.clear_data()\\n # factor of 1/10 to convert A*m^-2 to mA*cm^-2\\n Jph = .1 * consts.e * np.sum(jph_vals)\\n outf = os.path.join(base, 'jph_{}.dat'.format(method))\\n with open(outf, 'w') as out:\\n out.write('%f\\\\n' % Jph)\\n self.log.info('Jph = %f', Jph)\\n return Jph\",\n \"def test_react_parallel(self):\\n import rmgpy.rmg.main\\n rmgpy.rmg.main.maxproc = 2\\n procnum = 2\\n\\n spc_a = Species().from_smiles('[OH]')\\n spcs = [Species().from_smiles('CC'), Species().from_smiles('[CH3]')]\\n spc_tuples = [((spc_a, spc), ['H_Abstraction']) for spc in spcs]\\n\\n reaction_list = list(itertools.chain.from_iterable(react(spc_tuples, procnum)))\\n self.assertIsNotNone(reaction_list)\\n self.assertEqual(len(reaction_list), 3)\\n self.assertTrue(all([isinstance(rxn, TemplateReaction) for rxn in reaction_list]))\\n\\n # Reset module level maxproc back to default\\n rmgpy.rmg.main.maxproc = 1\",\n \"def _action(self, method, profile, verbose=False):\\n small_profile = self.profile()\\n\\n if verbose:\\n print('Computing the kernel using the profile:')\\n print(small_profile)\\n\\n algebra = self.base_ring()\\n finite_algebra = algebra.__class__(algebra.prime(), profile=small_profile)\\n\\n fp_result = method(\\n self.change_ring(finite_algebra),\\n verbose=verbose)\\n\\n return fp_result.change_ring(self.base_ring())\",\n \"def required_resources_for_method(method, uses_pretrained_r_net):\\n if method == 'ppo_plus_eco':\\n # We need to rent 2 GPUs, because with this amount of RAM, GCP won't allow\\n # us to rent only one.\\n return (105472, 16, 2)\\n if method == 'ppo_plus_ec' and not uses_pretrained_r_net:\\n return (52224, 12, 1)\\n return (32768, 12, 1)\",\n \"def timeit(method):\\n\\n def timed(*args, **kw):\\n start_time = time.time()\\n result = method(*args, **kw)\\n end_time = time.time()\\n\\n exce_time = end_time - start_time\\n\\n return result, exce_time\\n\\n return timed # here the memberfunction timed will be called\",\n \"def timecall(method, **kwargs):\\r\\n repeat = 1\\r\\n if 'repeat' in kwargs:\\r\\n repeat = kwargs['repeat']\\r\\n def wrapper(*args, **kwargs):\\r\\n durations = []\\r\\n for iteration in range(1, repeat + 1):\\r\\n start = time.time()\\r\\n result = method(*args, **kwargs)\\r\\n durations.append(time.time() - start)\\r\\n print(\\\"{:d}/{:d}: {:.2f}s\\\".format(iteration, repeat, durations[-1]))\\r\\n average = sum(durations) / len(durations)\\r\\n print(\\\"Average: {:.2f}s\\\\n\\\".format(average))\\r\\n duration = average\\r\\n return (duration, result)\\r\\n return wrapper\",\n \"def mass(self):\\n\\t\\traise NotImplementedError\",\n \"def test_process_info(self, mocked_get, mocked_check):\\n from supvisors.rpcinterface import RPCInterface\\n # create RPC instance\\n rpc = RPCInterface(self.supervisor)\\n # test first RPC call with process namespec\\n self.assertEqual([{'name': 'proc'}], rpc.get_process_info('appli:proc'))\\n self.assertEqual([call()], mocked_check.call_args_list)\\n self.assertEqual([call('appli:proc')], mocked_get.call_args_list)\\n # reset patches\\n mocked_check.reset_mock()\\n mocked_get.reset_mock()\\n # test second RPC call with group namespec\\n self.assertEqual([{'name': 'proc_1'}, {'name': 'proc_2'}],\\n rpc.get_process_info('appli:*'))\\n self.assertEqual([call()], mocked_check.call_args_list)\\n self.assertEqual([call('appli:*')], mocked_get.call_args_list)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6172455","0.5696483","0.55845743","0.5454974","0.5411215","0.5398892","0.53274125","0.5234939","0.5197039","0.5172683","0.51339173","0.50398976","0.4996997","0.4983228","0.49595007","0.49515915","0.49353585","0.49350932","0.49265435","0.49167734","0.48881906","0.488084","0.4868348","0.48617855","0.48394793","0.47974652","0.47874483","0.47783047","0.4767731","0.4764834","0.47551394","0.4745907","0.47397912","0.4731541","0.47279304","0.47214007","0.47109917","0.47047892","0.46782625","0.467774","0.46697357","0.46690682","0.46310344","0.46257752","0.4616566","0.4608775","0.46074018","0.4600575","0.4596563","0.45950353","0.45793122","0.45730937","0.4568297","0.45542368","0.4538141","0.45379186","0.45300457","0.45253116","0.45249856","0.4512702","0.44985747","0.4495535","0.44948724","0.44867656","0.4480291","0.4480291","0.44766495","0.44761357","0.44731152","0.44724134","0.44669387","0.44627416","0.44581196","0.4455943","0.4449136","0.44472486","0.4446692","0.44457817","0.44430602","0.44405934","0.44388866","0.44372007","0.44303074","0.4422924","0.4421805","0.4401612","0.43965566","0.43946946","0.4393867","0.4393131","0.43875203","0.43872097","0.43865237","0.43847507","0.43816572","0.43816254","0.4374139","0.4373598","0.43730223","0.4366466"],"string":"[\n \"0.6172455\",\n \"0.5696483\",\n \"0.55845743\",\n \"0.5454974\",\n \"0.5411215\",\n \"0.5398892\",\n \"0.53274125\",\n \"0.5234939\",\n \"0.5197039\",\n \"0.5172683\",\n \"0.51339173\",\n \"0.50398976\",\n \"0.4996997\",\n \"0.4983228\",\n \"0.49595007\",\n \"0.49515915\",\n \"0.49353585\",\n \"0.49350932\",\n \"0.49265435\",\n \"0.49167734\",\n \"0.48881906\",\n \"0.488084\",\n \"0.4868348\",\n \"0.48617855\",\n \"0.48394793\",\n \"0.47974652\",\n \"0.47874483\",\n \"0.47783047\",\n \"0.4767731\",\n \"0.4764834\",\n \"0.47551394\",\n \"0.4745907\",\n \"0.47397912\",\n \"0.4731541\",\n \"0.47279304\",\n \"0.47214007\",\n \"0.47109917\",\n \"0.47047892\",\n \"0.46782625\",\n \"0.467774\",\n \"0.46697357\",\n \"0.46690682\",\n \"0.46310344\",\n \"0.46257752\",\n \"0.4616566\",\n \"0.4608775\",\n \"0.46074018\",\n \"0.4600575\",\n \"0.4596563\",\n \"0.45950353\",\n \"0.45793122\",\n \"0.45730937\",\n \"0.4568297\",\n \"0.45542368\",\n \"0.4538141\",\n \"0.45379186\",\n \"0.45300457\",\n \"0.45253116\",\n \"0.45249856\",\n \"0.4512702\",\n \"0.44985747\",\n \"0.4495535\",\n \"0.44948724\",\n \"0.44867656\",\n \"0.4480291\",\n \"0.4480291\",\n \"0.44766495\",\n \"0.44761357\",\n \"0.44731152\",\n \"0.44724134\",\n \"0.44669387\",\n \"0.44627416\",\n \"0.44581196\",\n \"0.4455943\",\n \"0.4449136\",\n \"0.44472486\",\n \"0.4446692\",\n \"0.44457817\",\n \"0.44430602\",\n \"0.44405934\",\n \"0.44388866\",\n \"0.44372007\",\n \"0.44303074\",\n \"0.4422924\",\n \"0.4421805\",\n \"0.4401612\",\n \"0.43965566\",\n \"0.43946946\",\n \"0.4393867\",\n \"0.4393131\",\n \"0.43875203\",\n \"0.43872097\",\n \"0.43865237\",\n \"0.43847507\",\n \"0.43816572\",\n \"0.43816254\",\n \"0.4374139\",\n \"0.4373598\",\n \"0.43730223\",\n \"0.4366466\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72649634"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":10486,"cells":{"query":{"kind":"string","value":"optimizes the current library to maximize the result of the target function. By default, the function returns the best value and the associated interaction matrix as result. `direction` is either 'min' or 'max' and determines whether a minimum or a maximum is sought. `steps` determines how many optimization steps we try `ret_info` determines whether extra information is returned from the optimization `args` is a dictionary of additional arguments that is passed to the target function `method` determines the method used for optimization. Supported are"},"document":{"kind":"string","value":"def optimize_library(self, target, method='descent', direction='max',\n **kwargs):\n if method == 'descent':\n return self.optimize_library_descent(target, direction, **kwargs)\n elif method == 'descent_multiple' or method == 'descent-multiple':\n return self.optimize_library_descent_multiple(target, direction,\n **kwargs)\n elif method == 'anneal':\n return self.optimize_library_anneal(target, direction, **kwargs)\n \n else:\n raise ValueError('Unknown optimization method `%s`' % method)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def optimize_library_descent(self, target, direction='max', steps=100,\n multiprocessing=False, ret_info=False,\n args=None):\n # get the target function to call\n target_function = getattr(self, target)\n if args is not None:\n target_function = functools.partial(target_function, **args)\n\n # initialize the optimizer\n value = target_function()\n value_best, state_best = value, self.sens_mat.copy()\n \n if ret_info:\n # store extra information\n start_time = time.time()\n info = {'values': {}}\n values_count = self.parameters['optimizer_values_count']\n values_step = max(1, steps // values_count)\n \n if multiprocessing:\n # run the calculations in multiple processes\n pool_size = self.get_number_of_cores()\n pool = mp.Pool(processes=pool_size)\n if ret_info:\n values_step = max(1, values_step // pool_size)\n \n # iterate for given number of steps\n for step in range(int(steps) // pool_size):\n joblist = []\n init_arguments = self.init_arguments\n for _ in range(pool_size):\n # modify the current state and add it to the job list\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n params = init_arguments['parameters'] \n params['sensitivity_matrix'] = self.sens_mat\n params['initialize_state']['sensitivity'] = 'exact'\n \n joblist.append((copy.deepcopy(init_arguments), target))\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # run all the jobs\n results = pool.map(_run_job, joblist)\n \n # find the best result \n if direction == 'max':\n res_best = np.argmax(results)\n if results[res_best] > value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n elif direction == 'min':\n res_best = np.argmin(results)\n if results[res_best] < value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n else:\n raise ValueError('Unsupported direction `%s`' % direction)\n \n if ret_info and step % values_step == 0:\n info['values'][step * pool_size] = results[res_best]\n \n else:\n # run the calculations in this process\n for step in range(int(steps)):\n # modify the current state\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # get the value of the new state\n value = target_function()\n \n improved = ((direction == 'max' and value > value_best) or\n (direction == 'min' and value < value_best))\n if improved:\n # save the state as the new best value\n value_best, state_best = value, self.sens_mat.copy()\n else:\n # undo last change\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n if ret_info and step % values_step == 0:\n info['values'][step] = value_best\n\n # sort the best state and store it in the current object\n state_best = self.sort_sensitivity_matrix(state_best)\n self.sens_mat = state_best.copy()\n\n if ret_info:\n info['total_time'] = time.time() - start_time \n info['states_considered'] = steps\n info['performance'] = steps / info['total_time']\n return value_best, state_best, info\n else:\n return value_best, state_best","def optimize_library_anneal(self, target, direction='max', steps=100,\n ret_info=False, args=None):\n # lazy import\n from .optimizer import ReceptorOptimizerAnnealer # @UnresolvedImport\n \n # prepare the class that manages the simulated annealing\n annealer = ReceptorOptimizerAnnealer(self, target, direction, args,\n ret_info=ret_info)\n annealer.steps = int(steps)\n annealer.Tmax = self.parameters['anneal_Tmax']\n annealer.Tmin = self.parameters['anneal_Tmin']\n if self.parameters['verbosity'] == 0:\n annealer.updates = 0\n\n # do the optimization\n MI, state = annealer.optimize()\n\n # sort the best state and store it in the current object\n state = self.sort_sensitivity_matrix(state)\n self.sens_mat = state.copy()\n \n if ret_info:\n return MI, state, annealer.info\n else:\n return MI, state","def optimize_library_descent_multiple(self, target, direction='max',\n trials=4, multiprocessing=False,\n ret_error=False, **kwargs):\n \n # pass some parameters down to the optimization function to call\n kwargs['target'] = target\n kwargs['direction'] = direction\n \n # initialize the list of jobs with an optimization job starting from the\n # current interaction matrix\n joblist = [(self.init_arguments, 'optimize_library_descent', kwargs)]\n sens_mat = self.sens_mat #< store matrix to restore it later\n\n # set the ensemble of sensitivity matrices to try\n self.choose_sensitivity_matrix(density='auto')\n self.parameters['initialize_state']['sensitivity'] = 'ensemble'\n\n # add additional jobs with random initial interaction matrices\n init_arguments = self.init_arguments\n for _ in range(trials - 1):\n joblist.append((copy.deepcopy(init_arguments),\n 'optimize_library_descent', kwargs))\n \n # restore interaction matrix of this object\n self.sens_mat = sens_mat\n \n if multiprocessing:\n # calculate all results in parallel\n pool = mp.Pool(processes=self.get_number_of_cores())\n result_iter = pool.imap_unordered(_run_job, joblist)\n \n else:\n # create a generator over which we iterate later\n result_iter = (_run_job(job) for job in joblist)\n \n # find the best result by iterating over all results\n result_best, values = None, []\n for result in result_iter:\n values.append(result[0])\n # check whether this run improved the result\n if result_best is None:\n result_best = result\n elif ((direction == 'max' and result[0] > result_best[0]) or\n (direction == 'min' and result[0] < result_best[0])):\n result_best = result\n \n # sort the best state and store it in the current object\n state = self.sort_sensitivity_matrix(result_best[1])\n self.sens_mat = state.copy()\n\n if ret_error:\n # replace the best value by a tuple of the best value and its error\n value_best = result_best[0]\n value_err = np.abs(value_best - np.median(values))\n result_best = ((value_best, value_err), ) + result_best[1:]\n return result_best","def Optimise(LogLikelihood,par,func_args,fixed=None,type='max',method='NM',maxiter=10000, maxfun=10000, verbose=True):\n \n if fixed==None:\n var_par = np.copy(par)\n #otherwise construct the parameter vector from var_par and fixed_par_val\n else:\n par = np.array(par)\n fixed = np.array(fixed) #ensure fixed is a np array\n #assign parameters to normal param vector\n fixed_par = par[np.where(fixed==True)]\n var_par = par[np.where(fixed!=True)]\n \n #set the algorithm to use - CG and P not working (at least not well)\n add_kwords = {'verbose':verbose}\n if method == 'NM':\n Algorithm = NelderMead\n add_kwords = {'maxiter':maxiter, 'maxfun':maxfun,'verbose':verbose}\n elif method == 'CG':\n print \"warning: CG method didn't work properly during testing\"\n Algorithm = ConjugateGradient\n elif method == 'P':\n print \"warning: Powell algorithm didn't work properly during testing\"\n Algorithm = Powell\n else:\n print \"error: optimisation function not found\"\n return par\n \n #set the optimisation function to pos or neg for the fmin funcitons\n if type == 'max': OptFunc = NegFixedPar_func\n elif type == 'min': OptFunc = FixedPar_func\n else:\n print \"error: %s not a valid option\" % type\n return par\n \n #call the optimser with the appropriate function\n fitted_par = Algorithm(OptFunc, var_par, (LogLikelihood,func_args,fixed,fixed_par), \\\n **add_kwords)\n \n #now return the params in the correct order...\n if fixed==None:\n return_par = fitted_par\n else:\n return_par = np.copy(par) \n return_par[np.where(fixed!=True)] = fitted_par\n \n return return_par","def maximize(self,x0,method='fmin',**kwargs):\n return self._optimize(x0,'max',method,**kwargs)","def produce_max(self, *args, **kwargs):\n raise NotImplementedError('This interaction has no produce_max method yet!')","def opt_wrapper(m, **kwargs):\r\n m.optimize(**kwargs)\r\n return m.optimization_runs[-1]","def opt_wrapper(m, **kwargs):\n m.optimize(**kwargs)\n return m.optimization_runs[-1]","def Optimization(*args, **kwargs):\n from warnings import warn\n\n warn(\n \"Optimization has been renamed to OptimizationResult and will be removed as soon as v0.13.0\", DeprecationWarning\n )\n return OptimizationResult(*args, **kwargs)","def getMaximum(self, arguments, maximum):\n\n self.sequence.append({\"type\": \"findingMaximum\", \"coords\": arguments})\n\n self.sequence.append({\"type\": \"foundMaximum\", \"coord\": maximum})","def __call__(self, origin, state, **kwargs):\n fun = kwargs['function']\n d = state['direction']/np.linalg.norm(state['direction'])\n # filter directions that are too large\n if self.filter:\n ndabs_log = -np.log10(np.abs(d))\n mean_log = np.mean(ndabs_log)\n #print \"\\n ** MEAN =\", mean_log\n direction = (ndabs_log > mean_log-1.5).astype(int)*d\n else:\n direction = d\n state['direction'] = direction\n## for pos, d in enumerate(direction):\n## use_dir = self.use_dirs[pos]\n## if use_dir * d < 0:\n## # directions don't match so don't move in this direction\n## direction[pos] = 0\n maxStepSize = self.maxStepSize\n if np.isscalar(maxStepSize):\n stepSize = maxStepSize\n else:\n stepfacs = np.zeros(self.dim)\n for d in range(self.dim):\n # explicit loop so as to catch any ZeroDivisionErrors\n try:\n stepfacs[d] = abs(maxStepSize[d] / direction[d])\n except ZeroDivisionError:\n # Direction is orthogonal to this parameter direction,\n # so ensure won't choose this as the minimum step size\n stepfacs[d] = Inf\n # Stop stepping with giant sizes if direction vector has strong\n # separation of scales\n stepSize = min(stepfacs)\n# print \"direction = \", direction\n# print \"step = \", step\n i = 1\n old_value = state['old_value']\n not_done = True\n# print \"** TEMP: Hardwiring step size to be 0.0005\"\n# stepSize = 0.0005\n init_step = stepSize\n while not_done:\n print(\"\\nLinestep: i =\", i, \"step size =\", stepSize, \"direction =\\n\", end='')\n print(direction)\n p = origin + i * stepSize * direction\n print(\"Testing p = \", p)\n new_value = fun(p)\n if new_value < old_value:\n i += 1\n old_value = new_value\n else:\n if i == 1:\n # don't shrink step size to be less than 1/maxReduceFac of initial\n if stepSize*self.maxReduceFac < init_step:\n not_done = False\n p = origin + (i-1) * stepSize * direction\n else:\n stepSize /= self.stepMod\n else:\n # had found a working step but it's no longer stepping to lower residuals\n not_done = False\n p = origin + (i-1) * stepSize * direction\n state['alpha_step'] = stepSize\n return p","def max_(*args, **kwargs):\n ...","def optimize(self):\n \n if self.verbose:\n print('Starting grid search with bounds: [' + \\\n ';'.join(['%5g to %5g']*len(self.steps))%tuple([(self.steps[i][0], self.steps[i][-1]) for i in range(len(self.steps))]) +']')\n\n for params in self._get_next_point():\n self.transform.set_params(params)\n\n v, _ = self.measure.value_and_derivatives(self.transform)\n\n if v < self.best_value:\n self.best_value = v\n self.best_params = params\n# print('New best value %2.4f at ('%v, ', '.join(['%8.3f']*len(params))%tuple(params), ')')\n\n self.value_history.append(v)\n self.last_value = v\n self.iteration += 1\n\n if self.report_freq > 0 and (self.iteration % self.report_freq == 0) and self.report_func is not None:\n self.report_func(self)\n\n # Set the best transform\n self.transform.set_params(self.best_params)\n self.last_value = self.best_value\n return self.best_value","def maximum(x, y):\r\n # see decorator for function body\r","def MAXED(N, sigma2, R, f_def, params):\n\n # pull out algorithm-specific parameters\n Omega = params['Omega']\n\n # create the function that we will maximize, Z\n def Z(lam, N, sigma2, R, f_def, Omega):\n \"\"\"A function, the maximization of which is equivalent to the\n maximization of \"\"\"\n\n A = - np.sum(f_def * np.exp(- np.sum((lam * R.T).T, axis=0)))\n B = - (Omega * np.sum(lam**2 * sigma2))**(0.5)\n C = - np.sum(N * lam)\n\n # negate because it's a minimization\n return - (A + B + C)\n\n # create a lambda\n lam = np.ones(len(N))\n\n # apply the simulated annealing to the Z\n mk = {'args': (N, sigma2, R, f_def, Omega)}\n lam = basinhopping(Z, lam, minimizer_kwargs=mk).x\n\n # back out the spectrum values from the lam\n return f_def * np.exp(-np.sum((lam * R.T).T, axis=0))","def _optimize(self,x0,type,method,**kwargs):\n from scipy.optimize import fmin,fmin_powell\n\n if type == 'min':\n g=lambda x:self(x)\n elif type == 'max':\n g=lambda xs:-1*self(x)\n elif type == 'root':\n g=lambda x:np.abs(self(x))\n elif type == 'val':\n val = kwargs.pop('valtofind')\n g=lambda x:np.abs(self(x)-val)\n elif type == 'saddle':\n raise NotImplementedError\n else:\n raise ValueError('Unrecognized optimization type')\n\n if method == 'fmin':\n res = fmin(g,x0,**kwargs)\n elif method == 'fmin_powell':\n res = fmin_powell(g,x0,**kwargs)\n else:\n raise ValueError('Unrecognized method')\n\n self.lastOpt = res\n return res[0]","def process_solve_kwargs(**kwargs):\n\n tol = kwargs.get('tol', DEFAULT_TOL)\n maxiter = kwargs.get('maxiter', MAX_ITER)\n Ainv = kwargs.get('Ainv', None)\n verbose = kwargs.get('verbose', False)\n\n if VERBOSE:\n print(\"tol:\", tol)\n print(\"maxiter:\", maxiter)\n print(\"Ainv:\", Ainv)\n\n return tol, int(maxiter), Ainv, verbose","def expectimax_move(game, method='score'):\n\n if method == 'score':\n def val(g):\n return g[1]\n elif method == 'empty':\n val = empty_squares\n elif method == 'gradient':\n val = gradient_value\n else:\n print('Invalid method given to expectimax function')\n exit(1)\n\n _, move = expectimax(game, 2, val)\n return move","def best_metric(\n self, return_step: bool = False\n ) -> Union[\n None,\n float,\n Tuple[float, int],\n Tuple[None, None],\n Dict[str, Union[float, None]],\n Tuple[Dict[str, Union[float, None]], Dict[str, Union[int, None]]],\n ]:\n res = self.compute_all()\n if isinstance(res, list):\n rank_zero_warn(\n \"Encounted nested structure. You are probably using a metric collection inside a metric collection, or\"\n \" a metric wrapper inside a metric collection, which is not supported by `.best_metric()` method.\"\n \"Returning `None` instead. Please consider \"\n )\n if return_step:\n return None, None\n return None\n\n if isinstance(self._base_metric, Metric):\n fn = torch.max if self.maximize else torch.min\n try:\n value, idx = fn(res, 0)\n if return_step:\n return value.item(), idx.item()\n return value.item()\n except (ValueError, RuntimeError) as error:\n rank_zero_warn(\n f\"Encountered the following error when trying to get the best metric: {error}\"\n \"this is probably due to the 'best' not being defined for this metric.\"\n \"Returning `None` instead.\",\n UserWarning,\n )\n if return_step:\n return None, None\n return None\n\n else: # this is a metric collection\n maximize = self.maximize if isinstance(self.maximize, list) else len(res) * [self.maximize]\n value, idx = {}, {}\n for i, (k, v) in enumerate(res.items()):\n try:\n fn = torch.max if maximize[i] else torch.min\n out = fn(v, 0)\n value[k], idx[k] = out[0].item(), out[1].item()\n except (ValueError, RuntimeError) as error: # noqa: PERF203 # todo\n rank_zero_warn(\n f\"Encountered the following error when trying to get the best metric for metric {k}:\"\n f\"{error} this is probably due to the 'best' not being defined for this metric.\"\n \"Returning `None` instead.\",\n UserWarning,\n )\n value[k], idx[k] = None, None\n\n if return_step:\n return value, idx\n return value","def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\n return x_best, -y_best","def run_migrad(self, fitarg, **kwargs):\n self.fitarg = fitarg\n kwargs['up'] = 1.\n\n\n logging.debug(self._par_names)\n logging.debug(self.__wrap_likelihood(list(fitarg['pinit'].values())))\n\n if kwargs['scipy']:\n self._res = op.minimize(self.__wrap_likelihood,\n list(fitarg['pinit'].values()),\n bounds=list(fitarg['limits'].values()),\n method='TNC',\n #method='Powell',\n options={'maxiter': kwargs['ncall']} #'xtol': 1e-20, 'eps' : 1e-20, 'disp': True}\n #tol=None, callback=None,\n #options={'disp': False, 'minfev': 0, 'scale': None,\n #'rescale': -1, 'offset': None, 'gtol': -1,\n #'eps': 1e-08, 'eta': -1, 'maxiter': kwargs['ncall'],\n #'maxCGit': -1, 'mesg_num': None, 'ftol': -1, 'xtol': -1, 'stepmx': 0,\n #'accuracy': 0}\n )\n logging.info(self._res)\n for i, k in enumerate(self._par_names):\n fitarg[k] = self._res.x[i]\n\n logging.debug(fitarg)\n\n cmd_string = \"lambda {0}: self.__calcLikelihood({0})\".format(\n (\", \".join(self._par_names), \", \".join(self._par_names)))\n\n string_args = \", \".join(self._par_names)\n global f # needs to be global for eval to find it\n f = lambda *args: self.__calc_likelihood(*args)\n\n cmd_string = \"lambda %s: f(%s)\" % (string_args, string_args)\n logging.debug(cmd_string)\n\n # work around so that the parameters get names for minuit\n self._minimize_f = eval(cmd_string, globals(), locals())\n self._minimize_f.errordef = minuit.Minuit.LEAST_SQUARES\n\n self._m = minuit.Minuit(self._minimize_f,\n #list(fitarg['pinit'].values()),\n **fitarg['pinit'],\n #names=self._par_names\n )\n# print_level=kwargs['verbosity'],\n# errordef=kwargs['up'],\n# pedantic=kwargs['pedantic'],\n #**fitarg)\n\n for p in self._par_names:\n self._m.fixed[p] = fitarg['fix'][p]\n self._m.limits[p] = fitarg['limits'][p]\n self._m.errors[p] = fitarg['error'][p]\n\n self._m.tol = kwargs['tol']\n self._m.strategy = kwargs['strategy']\n\n logging.debug(\"tol {0:.2e}, strategy: {1:n}\".format(\n self._m.tol, self._m.strategy.strategy))\n\n self._m.migrad(ncall=kwargs['ncall']) #, precision = kwargs['precision'])","def best_move(game, method='score'):\n board, score = game\n\n if method == 'score':\n def val(g):\n return g[1]\n elif method == 'empty':\n val = empty_squares\n elif method == 'gradient':\n val = gradient_value\n else:\n print('Invalid method given to best_move function')\n exit(1)\n\n if score < 10000:\n depth = 4\n elif score < 20000:\n depth = 5\n elif score < 30000:\n depth = 7\n else:\n depth = 7\n\n moves = possible_moves(board)\n\n # dict with score for each move\n move_score = dict(zip(moves, [0] * len(moves)))\n\n # search for max score for each move\n for move in moves:\n move_score[move] += max_score_search(move_made(game, move), depth, val)\n\n move = max(move_score, key=move_score.get)\n return move","def _call_maximum(vecObj, vec2):\n res = vecObj.maximum(vec2)\n return res","def _random_max_wrap(*args):\n _, opt_pt = random_maximise(*args)\n return opt_pt","def solve(self, **kwargs) -> OptimizationResult:\n raise NotImplementedError","def custom_method(*args, **kwargs):\n return objective_return","def custom_method(*args, **kwargs):\n return objective_return","def nn_ga_optimise_from_args(func_caller, worker_manager, max_capital, mode, mutation_op,\n crossover_op=None, options=None, reporter='default'):\n if options is None:\n reporter = get_reporter(reporter)\n options = load_options(ga_opt_args, reporter=reporter)\n options.mode = mode\n return (NNGAOptimiser(func_caller, worker_manager, mutation_op, crossover_op,\n options, reporter)).optimise(max_capital)","def test_maximax():\n f = np.asarray([\n [0.99, 1.0, 0.5],\n [0.69, 0.6, 0.6]])\n R = common_metrics.maximax(f, maximise=True)\n expected = np.asarray(\n [1.0, 0.69])\n assert np.allclose(R, expected)\n R = common_metrics.maximax(f, maximise=False)\n expected = np.asarray(\n [-0.5, -0.6])\n assert np.allclose(R, expected)","def optimize(self, max_iters=1e3, messages=False, use_counter=False,\\\n factr=1e7, pgtol=1e-05):\n logger.debug('Beginning MLE to optimize hyperparams. grad_method=%s'\\\n % self.grad_method)\n\n # setup the optimization\n try:\n x0 = self._transform_parameters(self.parameters)\n assert np.all(np.isfinite(x0))\n except:\n logger.error('Transformation failed for initial values. '\\\n + 'Ensure constraints are met or the value is not too small.')\n raise\n\n # filter out the fixed parameters\n free = np.logical_not(self._fixed_indicies)\n x0 = x0[free]\n\n # setup the counter\n if use_counter:\n self._counter = solver_counter(disp=True)\n else:\n self._counter = None\n\n # run the optimization\n try:\n x_opt, f_opt, opt = fmin_l_bfgs_b(func=self._objective_grad, x0=x0,\\\n factr=factr, pgtol=pgtol, maxiter=max_iters, disp=messages)\n except (KeyboardInterrupt,IndexError):\n logger.info('Keyboard interrupt raised. Cleaning up...')\n if self._counter is not None and self._counter.backup is not None:\n self.parameters = self._counter.backup[1]\n logger.info('will return best parameter set with'\\\n + 'log-likelihood = %.4g' % self._counter.backup[0])\n else:\n logger.info('Function Evals: %d. Exit status: %s' % (f_opt, opt['warnflag']))\n # extract the optimal value and set the parameters to this\n transformed_parameters = self._previous_parameters \n transformed_parameters[free] = x_opt\n self.parameters = self._untransform_parameters(transformed_parameters)\n return opt","def poll(target, step, args=(), kwargs=None, timeout=None, max_tries=None, check_success=is_truthy,\n step_function=step_constant, ignore_exceptions=(), poll_forever=False, collect_values=None, *a, **k):\n\n logging.info('Starting Polling')\n\n assert (timeout is not None or max_tries is not None) or poll_forever, \\\n ('You did not specify a maximum number of tries or a timeout. Without either of these set, the polling '\n 'function will poll forever. If this is the behavior you want, pass \"poll_forever=True\"')\n\n assert not ((timeout is not None or max_tries is not None) and poll_forever), \\\n 'You cannot specify both the option to poll_forever and max_tries/timeout.'\n\n kwargs = kwargs or dict()\n values = collect_values or Queue()\n\n max_time = Time.time() + timeout if timeout else None\n tries = 0\n logging.debug('Max Time: ' + str(max_time))\n logging.debug('Max Tries: ' + str(max_tries))\n\n last_item = None\n while True:\n\n if max_tries is not None and tries >= max_tries:\n raise MaxCallException(values, last_item)\n\n try:\n logging.debug('Arguments: ' + str(args))\n val = target(*args, **kwargs)\n logging.debug('Results from Target running: ' + str(val))\n last_item = val\n logging.info('Try #:' + str(tries))\n DisplayMessage('Try #:' + str(tries))\n except ignore_exceptions as e:\n logging.error(str(e))\n last_item = e\n else:\n # Condition passes, this is the only \"successful\" exit from the polling function\n if check_target_success(val):\n return val\n\n logging.debug('last result from poll: ' + str(last_item))\n # Condition passes, this is the only \"successful\" exit from the polling function\n if check_target_success(val):\n return val\n else:\n values.put(last_item)\n tries += 1\n # Check the time after to make sure the poll function is called at least once\n if max_time is not None and Time.time() >= max_time:\n # raise TimeoutException(values, last_item)\n logging.info('Time out reached.')\n logging.info('Checking status of job: ' + val)\n logging.info('Job will now sleep for an additional: ' + step)\n logging.debug('Step value: ' + str(step))\n Time.sleep(step)\n step = step_function(step)","def adaptive_scan(detectors, target_field, motor, start, stop,\n min_step, max_step, target_delta, backstep,\n threshold=0.8, *, md=None):\n _md = {'detectors': [det.name for det in detectors],\n 'motors': [motor.name],\n 'plan_args': {'detectors': list(map(repr, detectors)),\n 'motor': repr(motor),\n 'start': start,\n 'stop': stop,\n 'min_step': min_step,\n 'max_step': max_step,\n 'target_delta': target_delta,\n 'backstep': backstep,\n 'threshold': threshold},\n 'plan_name': 'adaptive_scan',\n }\n _md.update(md or {})\n\n @stage_decorator(list(detectors) + [motor])\n @run_decorator(md=_md)\n def adaptive_core():\n next_pos = start\n step = (max_step - min_step) / 2\n past_I = None\n cur_I = None\n cur_det = {}\n while next_pos < stop:\n yield Msg('checkpoint')\n yield Msg('set', motor, next_pos, group='A')\n yield Msg('wait', None, 'A')\n yield Msg('create', None, name='primary')\n for det in detectors:\n yield Msg('trigger', det, group='B')\n yield Msg('wait', None, 'B')\n for det in separate_devices(detectors + [motor]):\n cur_det = yield Msg('read', det)\n if cur_det is not None and target_field in cur_det:\n cur_I = cur_det[target_field]['value']\n yield Msg('save')\n\n # special case first first loop\n if past_I is None:\n past_I = cur_I\n next_pos += step\n continue\n\n dI = np.abs(cur_I - past_I)\n\n slope = dI / step\n if slope:\n new_step = np.clip(target_delta / slope, min_step, max_step)\n else:\n new_step = np.min([step * 1.1, max_step])\n\n # if we over stepped, go back and try again\n if backstep and (new_step < step * threshold):\n next_pos -= step\n step = new_step\n else:\n past_I = cur_I\n step = 0.2 * new_step + 0.8 * step\n next_pos += step\n\n return (yield from adaptive_core())","def mod_space_opt(\n *,\n space,\n dryness_method,\n fuel_build_up_method,\n include_temperature,\n discrete_params,\n defaults=None,\n basinhopping_options=None,\n minimizer_options=None,\n mode=\"basinhopping\",\n x0=None,\n):\n to_optimise = gen_to_optimise(\n fail_func=fail_func,\n success_func=success_func,\n # Init (data) params.\n dryness_method=dryness_method,\n fuel_build_up_method=fuel_build_up_method,\n include_temperature=include_temperature,\n _uncached_data=False,\n **discrete_params,\n )\n\n defaults_dict = defaults if defaults is not None else {}\n\n def to_optimise_with_discrete(x):\n return to_optimise(\n **space.inv_map_float_to_0_1(dict(zip(space.continuous_param_names, x))),\n **defaults_dict,\n )\n\n def basinhopping_callback(x, f, accept):\n # NOTE: Parameters recorded here are authoritative, since hyperopt will not\n # properly report values modified as in e.g. `mod_quniform`.\n values = {\n **space.inv_map_float_to_0_1(dict(zip(space.continuous_param_names, x))),\n **discrete_params,\n **defaults_dict,\n }\n values[\"dryness_method\"] = dryness_method\n values[\"fuel_build_up_method\"] = fuel_build_up_method\n values[\"include_temperature\"] = include_temperature\n\n minimizer_options_dict = minimizer_options if minimizer_options is not None else {}\n basinhopping_options_dict = (\n basinhopping_options if basinhopping_options is not None else {}\n )\n\n if x0 is None:\n x0 = space.continuous_x0_mid\n\n if mode == \"basinhopping\":\n res = basinhopping(\n to_optimise_with_discrete,\n x0=x0,\n seed=0,\n callback=basinhopping_callback,\n take_step=BoundedSteps(\n stepsize=0.3, rng=np.random.default_rng(0), verbose=True\n ),\n **{\n \"disp\": True,\n \"minimizer_kwargs\": dict(\n method=\"L-BFGS-B\",\n jac=None,\n bounds=[(0, 1)] * len(space.continuous_param_names),\n options={\n \"maxiter\": 60,\n \"ftol\": 1e-5,\n \"eps\": 1e-3,\n **minimizer_options_dict,\n },\n ),\n \"T\": 0.05,\n \"niter\": 100,\n \"niter_success\": 15,\n **basinhopping_options_dict,\n },\n )\n elif mode == \"minimize\":\n res = minimize(\n to_optimise_with_discrete,\n x0=x0,\n method=\"L-BFGS-B\",\n jac=None,\n bounds=[(0, 1)] * len(space.continuous_param_names),\n options={\n \"maxiter\": 60,\n \"ftol\": 1e-5,\n \"eps\": 1e-3,\n **minimizer_options_dict,\n },\n )\n else:\n raise ValueError\n\n return res","def fit(self, start_params=None, method='newton', maxiter=100,\n full_output=True, disp=True, fargs=(), callback=None, retall=False,\n skip_hessian=False, **kwargs):\n Hinv = None # JP error if full_output=0, Hinv not defined\n\n start_params = self._get_start_params(start_params)\n\n # TODO: separate args from nonarg taking score and hessian, ie.,\n # user-supplied and numerically evaluated estimate frprime doesn't take\n # args in most (any?) of the optimize function\n\n nobs = self.endog.shape[0]\n # f = lambda params, *args: -self.loglike(params, *args) / nobs\n\n def f(params, *args):\n return -self.loglike(params, *args) / nobs\n\n if method == 'newton':\n # TODO: why are score and hess positive?\n def score(params, *args):\n return self.score(params, *args) / nobs\n\n def hess(params, *args):\n return self.hessian(params, *args) / nobs\n else:\n def score(params, *args):\n return -self.score(params, *args) / nobs\n\n def hess(params, *args):\n return -self.hessian(params, *args) / nobs\n\n warn_convergence = kwargs.pop('warn_convergence', True)\n optimizer = Optimizer()\n xopt, retvals, optim_settings = optimizer._fit(f, score, start_params,\n fargs, kwargs,\n hessian=hess,\n method=method,\n disp=disp,\n maxiter=maxiter,\n callback=callback,\n retall=retall,\n full_output=full_output)\n\n # NOTE: this is for fit_regularized and should be generalized\n cov_params_func = kwargs.setdefault('cov_params_func', None)\n if cov_params_func:\n Hinv = cov_params_func(self, xopt, retvals)\n elif method == 'newton' and full_output:\n Hinv = np.linalg.inv(-retvals['Hessian']) / nobs\n # TODO: try/except for non-invertible hessian?\n elif not skip_hessian:\n H = -1 * self.hessian(xopt)\n invertible = False\n if np.all(np.isfinite(H)):\n eigvals, eigvecs = np.linalg.eigh(H)\n if np.min(eigvals) > 0:\n invertible = True\n\n if invertible:\n Hinv = eigvecs.dot(np.diag(1.0 / eigvals)).dot(eigvecs.T)\n Hinv = np.asfortranarray((Hinv + Hinv.T) / 2.0)\n else:\n warnings.warn('Inverting hessian failed, no bse or cov_params '\n 'available', HessianInversionWarning)\n Hinv = None\n\n if 'cov_type' in kwargs:\n cov_kwds = kwargs.get('cov_kwds', {})\n kwds = {'cov_type': kwargs['cov_type'], 'cov_kwds': cov_kwds}\n else:\n kwds = {}\n if 'use_t' in kwargs:\n kwds['use_t'] = kwargs['use_t']\n # TODO: add Hessian approximation and change the above if needed\n mlefit = LikelihoodModelResults(self, xopt, Hinv, scale=1., **kwds)\n\n # TODO: hardcode scale?\n if isinstance(retvals, dict):\n mlefit.mle_retvals = retvals\n if warn_convergence and not retvals['converged']:\n warnings.warn(\"Maximum Likelihood optimization failed to \"\n \"converge. Check mle_retvals\",\n ConvergenceWarning)\n\n mlefit.mle_settings = optim_settings\n return mlefit","def _call_max(vecObj):\n res = vecObj.max()\n return res","def optimize(start, stop, step):\n #Go through every angle\n rot_angle_list = np.arange(start, stop, step)\n fitness_list = []\n best_angles_list = []\n for (i, rot_angle) in enumerate(rot_angle_list):\n (fitness, best_angles) = self._angle_fitness(rot_angle, initial_R, ending_vec, starting_vec)\n fitness_list.append(fitness)\n best_angles_list.append(best_angles)\n #Find the best result\n best_index = np.argmin(fitness_list)\n best_rot_angle = rot_angle_list[best_index]\n best_angles = best_angles_list[best_index]\n return (best_rot_angle, best_angles)","def run_method(trial, method,\n cl_ctx=None,\n queue=None,\n clear_memoized_objects=False,\n true_sol_name=\"True Solution\",\n comp_sol_name=\"Computed Solution\", **kwargs):\n if clear_memoized_objects:\n global memoized_objects\n memoized_objects = {}\n\n if cl_ctx is None:\n raise ValueError(\"Missing cl_ctx\")\n if queue is None:\n raise ValueError(\"Missing queue\")\n\n # Get boundary ids\n scatterer_bdy_id = kwargs['scatterer_bdy_id']\n outer_bdy_id = kwargs['outer_bdy_id']\n\n # Get degree and wave number\n degree = trial['degree']\n wave_number = trial['kappa']\n\n # Get options prefix and solver parameters, if any\n options_prefix = kwargs.get('options_prefix', None)\n solver_parameters = dict(kwargs.get('solver_parameters', None))\n\n # Get prepared trial args in kwargs\n prepared_trial = prepare_trial(trial, true_sol_name, cl_ctx, queue)\n mesh, fspace, vfspace, true_sol, true_sol_grad_expr = prepared_trial\n\n # Create a place to memoize any objects if necessary\n tuple_trial = trial_to_tuple(trial)\n memo_key = tuple_trial[:2]\n if memo_key not in memoized_objects:\n memoized_objects[memo_key] = {}\n\n comp_sol = None\n\n # Handle any special kwargs and get computed solution\n if method == 'pml':\n # Get required objects\n pml_max = kwargs['pml_max']\n pml_min = kwargs['pml_min']\n\n # Get optional argumetns\n pml_type = kwargs.get('pml_type', None)\n quad_const = kwargs.get('quad_const', None)\n speed = kwargs.get('speed', None)\n\n # Make tensor function space\n if 'tfspace' not in memoized_objects[memo_key]:\n memoized_objects[memo_key]['tfspace'] = \\\n TensorFunctionSpace(mesh, 'CG', degree)\n\n tfspace = memoized_objects[memo_key]['tfspace']\n\n snes, comp_sol = pml(mesh, scatterer_bdy_id, outer_bdy_id, wave_number,\n options_prefix=options_prefix,\n solver_parameters=solver_parameters,\n fspace=fspace, tfspace=tfspace,\n true_sol_grad_expr=true_sol_grad_expr,\n pml_type=pml_type, quad_const=quad_const,\n speed=speed,\n pml_min=pml_min,\n pml_max=pml_max,\n )\n snes_or_ksp = snes\n\n elif method == 'nonlocal':\n # Build DG spaces if not already built\n if 'dgfspace' not in memoized_objects[memo_key]:\n memoized_objects[memo_key]['dgfspace'] = \\\n FunctionSpace(mesh, 'DG', degree)\n if 'dgvfspace' not in memoized_objects[memo_key]:\n memoized_objects[memo_key]['dgvfspace'] = \\\n VectorFunctionSpace(mesh, 'DG', degree)\n\n dgfspace = memoized_objects[memo_key]['dgfspace']\n dgvfspace = memoized_objects[memo_key]['dgvfspace']\n\n # Get opencl array context\n from meshmode.array_context import PyOpenCLArrayContext\n actx = PyOpenCLArrayContext(queue)\n\n # Build connection fd -> meshmode if not already built\n if 'meshmode_src_connection' not in memoized_objects[memo_key]:\n from meshmode.interop.firedrake import build_connection_from_firedrake\n memoized_objects[memo_key]['meshmode_src_connection'] = \\\n build_connection_from_firedrake(\n actx,\n dgfspace,\n grp_factory=None,\n restrict_to_boundary=scatterer_bdy_id)\n\n meshmode_src_connection = memoized_objects[memo_key]['meshmode_src_connection']\n\n # Set defaults for qbx kwargs\n qbx_order = kwargs.get('qbx_order', degree+2)\n fine_order = kwargs.get('fine_order', 4 * degree)\n fmm_order = kwargs.get('FMM Order', None)\n fmm_tol = kwargs.get('FMM Tol', None)\n # make sure got either fmm_order xor fmm_tol\n if fmm_order is None and fmm_tol is None:\n raise ValueError(\"At least one of 'fmm_order', 'fmm_tol' must not \"\n \"be *None*\")\n if fmm_order is not None and fmm_tol is not None:\n raise ValueError(\"At most one of 'fmm_order', 'fmm_tol' must not \"\n \"be *None*\")\n # if got fmm_tol, make a level-to-order\n fmm_level_to_order = None\n if fmm_tol is not None:\n if not isinstance(fmm_tol, float):\n raise TypeError(\"fmm_tol of type '%s' is not of type float\" % type(fmm_tol))\n if fmm_tol <= 0.0:\n raise ValueError(\"fmm_tol of '%s' is less than or equal to 0.0\" % fmm_tol)\n from sumpy.expansion.level_to_order import SimpleExpansionOrderFinder \n fmm_level_to_order = SimpleExpansionOrderFinder(fmm_tol)\n # Otherwise, make sure we got a valid fmm_order\n else:\n if not isinstance(fmm_order, int):\n if fmm_order != False:\n raise TypeError(\"fmm_order of type '%s' is not of type int\" % type(fmm_order))\n if fmm_order != False and fmm_order < 1:\n raise ValueError(\"fmm_order of '%s' is less than 1\" % fmm_order)\n\n qbx_kwargs = {'qbx_order': qbx_order,\n 'fine_order': fine_order,\n 'fmm_order': fmm_order,\n 'fmm_level_to_order': fmm_level_to_order,\n 'fmm_backend': 'fmmlib',\n }\n # }}}\n\n ksp, comp_sol = nonlocal_integral_eq(\n mesh, scatterer_bdy_id, outer_bdy_id,\n wave_number,\n options_prefix=options_prefix,\n solver_parameters=solver_parameters,\n fspace=fspace, vfspace=vfspace,\n true_sol_grad_expr=true_sol_grad_expr,\n actx=actx,\n dgfspace=dgfspace,\n dgvfspace=dgvfspace,\n meshmode_src_connection=meshmode_src_connection,\n qbx_kwargs=qbx_kwargs,\n )\n\n snes_or_ksp = ksp\n\n elif method == 'transmission':\n\n snes, comp_sol = transmission(mesh, scatterer_bdy_id, outer_bdy_id,\n wave_number,\n options_prefix=options_prefix,\n solver_parameters=solver_parameters,\n fspace=fspace,\n true_sol_grad_expr=true_sol_grad_expr,\n )\n snes_or_ksp = snes\n else:\n raise ValueError(\"Invalid method\")\n\n comp_sol.rename(name=comp_sol_name)\n return true_sol, comp_sol, snes_or_ksp","def optimize(self, objective_sense=None, **kwargs):\n\n if objective_sense:\n self.objective.direction = objective_sense\n\n try:\n # self._hidden_optimize_call(kwargs)\n Model.optimize(self, **kwargs)\n solution = self.get_solution()\n self.solution = solution\n return solution\n except SolverError as SE:\n status = self.solver.status\n self.logger.error(SE)\n self.logger.warning('Solver status: {}'.format(status))\n raise (SE)","def step_func_cat(X, args, Y, info, Ytarget, err, tols, iter, maxIter):\n [XF, ZF, L, EA, W, CB, WL, WEA, L_EA, CB_EA] = args[\"cat\"]\n\n # if abs( err[1] + ZF ) < 0.0001:\n # breakpoint()\n\n [alpha_min, alpha0, alphaR] = args[\n \"step\"\n ] # get minimum alpha, initial alpha, and alpha reduction rate from passed arguments\n\n # J = info['jacobian']\n # dX = -np.matmul(np.linalg.inv(J), err)\n dX = -np.matmul(info[\"stiffnessB\"], err)\n\n # ! Reduce dHF by factor (between 1 at I = 1 and 0 at I = MaxIter) that reduces linearly with iteration count\n # to ensure that we converge on a solution even in the case were we obtain a nonconvergent cycle about the\n # correct solution (this happens, for example, if we jump to quickly between a taut and slack catenary)\n\n alpha = 1.0 # M<<<<<<<< np.max([alpha_min, alpha0*(1.0 - alphaR*iter/maxIter)])\n\n # exponential approach alpha = alpha0 * np.exp( iter/maxIter * np.log(alpha_min/alpha0 ) )\n\n dX[0] = dX[0] * alpha # dHF*( 1.0 - Tol*I )\n dX[1] = dX[1] * alpha # dVF*( 1.0 - Tol*I )\n\n # To avoid an ill-conditioned situation, make sure HF does not go less than or equal to zero by having a lower limit of Tol*HF\n # [NOTE: the value of dHF = ( Tol - 1.0 )*HF comes from: HF = HF + dHF = Tol*HF when dHF = ( Tol - 1.0 )*HF]\n # dX[0] = max( dX[0], ( tol - 1.0 )*info['HF']);\n\n # To avoid an ill-conditioned situation, make sure HF does not get too close to zero, by forcing HF >= tols[0]\n # if info['HF'] + dX[0] <= tol*abs(info['VF']+dX[1]):\n # if info['HF'] + dX[0] <= tols[0]\n if X[0] + dX[0] <= tols[0]:\n # dX[0] = tol*abs(info['VF']+dX[1]) - info['HF']\n # dX[0] = tols[0] - info['HF']\n dX[0] = tols[0] - X[0]\n\n # To avoid an ill-conditioned situation where the line is nearly all on the seabed but the solver gets stuck,\n # if np.abs(err[1] + ZF)/ZF < tol:\n # breakpoint()\n # deltaHFVF = info['HF'] - info['VF']\n # dX[0] = dX[0] - 0.5*deltaHFVF\n # dX[1] = dX[1] + 0.5*deltaHFVF\n\n # prevent silly situation where a line with weight and positive ZF considers a negative VF\n if info[\"ProfileType\"] == 2:\n if X[1] + dX[1] <= tols[1]: # if vertical force is within tolerance of being zero/negative\n VFtarget = (L - info[\"LBot\"]) * W # set next VF value to be the weight of portion of line that's suspended\n dX[1] = VFtarget - X[1]\n\n return dX # returns dX (step to make)","def optimise_fn(self, x):\n\n success = self._set_material_parameters(x)\n if not success:\n return self._bad_metric()\n\n # some iterations are repeated so cache the results to avoid unnecessary iterations\n cached_result_key = tuple(x)\n metric_value = self.cached_results.get(cached_result_key)\n\n if metric_value is None:\n print('--> Optimiser: {}'.format(self.material_model))\n\n sim_result = fs.run_simulation(stoma_cfg=self.stoma_cfg,\n from_optimiser=True)\n\n # when the simulation fails we want a non-constant measure for the optimiser to use\n metric_value = sim_result.metric_value if sim_result.success else self._bad_metric()\n\n self.cached_results[cached_result_key] = metric_value\n\n print('--> Optimiser: {} - metric={}'.format(self.material_model, metric_value))\n else:\n print('--> Optimiser: {} - metric={} (cached result)'.format(self.material_model, metric_value))\n\n return metric_value","def my_max(*args):\n def sorter(sequence):\n \"\"\"\n This function find max in given sequence of simple numbers\n \"\"\"\n def bubble_sort(a):\n \"\"\"\n This function sort the list\n \"\"\"\n for i in reversed(range(len(a))):\n for j in range(1, i + 1):\n if a[j-1] > a[j]:\n a[j], a[j-1] = a[j-1], a[j]\n return a\n\n listed_seq = list(sequence)\n for number in listed_seq:\n if not isinstance(number, int):\n raise ValueError(\"Can't find max, wrong data format\")\n return bubble_sort(listed_seq)[-1]\n\n if not args:\n raise ValueError(\"Can't find max, no data given\")\n if len(args) == 1:\n thing = args[0]\n if isinstance(thing, (list, tuple)):\n return sorter(thing)\n if isinstance(thing, int):\n return thing\n raise ValueError(\"Can't find max, wrong data format\")\n return sorter(args)","def maximize(self):\n raise NotImplementedError","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n # AlphaBetaAgent.callsCount = 0\n # If the game state is lost or win then just return the evaluation value\n if gameState.isLose() or gameState.isWin():\n return self.evaluationFunction(gameState)\n\n # This part is almost the same with MinimaxAgent other than two additional parameters of alpha and beta values\n # by recursion calls in MiniMax tree to make a decision\n # alpha = the best choice of the highest values we have found so far along the path for MAX.\n # (initializes -9999999)\n # beta = the best choice of the lowest values we have found so far along the path for MIN.\n # (initializes +9999999)\n\n finalDirection = self.maxValueAlphaBeta(gameState, self.depth * gameState.getNumAgents(), gameState.getNumAgents(), 0, -9999999, 9999999)\n # print(\"Number of Calls: \", AlphaBetaAgent.callsCount)\n return finalDirection[1]\n\n # The helper function to remove STOP action to improve efficiency\n def removeStop(self, legalMoves):\n stopDirection = Directions.STOP\n if stopDirection in legalMoves:\n legalMoves.remove(stopDirection)\n\n # The maxValue method for PacMan whose agent index is zero\n def maxValueAlphaBeta(self, gameState, depth, numOfAgents, agentIndex, alpha, beta):\n # AlphaBetaAgent.callsCount += 1\n legalMoves = gameState.getLegalActions(agentIndex)\n self.removeStop(legalMoves)\n # The next states, either passed in to getAction or generated via GameState.generateSuccessor\n nextStates = [gameState.generateSuccessor(agentIndex, action) for action in legalMoves]\n if depth == 0 or len(nextStates) == 0:\n return (self.evaluationFunction(gameState), Directions.STOP)\n\n maxValue = -9999999\n action = legalMoves[0]\n moveIndex = 0\n chooseMax = []\n\n # There are only one case to call minValue from Pacman perspective\n for nextState in nextStates:\n res = self.minValueAlphaBeta(nextState, depth-1, numOfAgents-2, numOfAgents, (agentIndex+1)%numOfAgents, alpha, beta)\n chooseMax.append(res)\n if res > maxValue:\n maxValue = res\n action = legalMoves[moveIndex]\n # Check \"cut-off\" condition\n if res > alpha: # If alpha is smaller than the current Max value\n alpha = res # Then replace alpha with the current Max value\n if alpha >= beta: # When alpha value is larger than beta value\n return (alpha, action) # beta cut-off\n moveIndex = moveIndex + 1\n return (maxValue, action)","def run_step_blackbox_optimizer(config,\n current_input,\n blackbox_optimizer,\n proposed_perturbations,\n finished_dnas,\n results,\n logging_data=None):\n core_hyperparameters = blackbox_optimizer.get_hyperparameters()\n function_values = [0.0] * len(proposed_perturbations)\n rewards_for_controller = []\n perturbations = proposed_perturbations\n evaluation_stats = []\n current_value_exact = 0.0\n current_value_exact_counter = 0\n\n for i in range(len(results)):\n rewards_for_controller.append(results[i]['function_value'])\n tag = results[i]['tag']\n index = 0\n if tag > 0:\n if config.est_type == 'antithetic':\n index = (tag - 1) * 2\n function_values[index] += results[i]['function_value']\n else:\n index = tag - 1\n function_values[index] += results[i]['function_value']\n if tag < 0:\n index = (-tag - 1) * 2 + 1\n function_values[index] += results[i]['function_value']\n if tag == 0:\n current_value_exact += results[i]['function_value']\n current_value_exact_counter += 1\n current_value_exact /= float(current_value_exact_counter)\n\n for result in results:\n evaluation_stat = list(result['evaluation_stat'])\n evaluation_stats.append(evaluation_stat)\n\n function_values_reshaped = np.array(function_values)\n perturbations_reshaped = np.array(perturbations)\n\n logging.info('LIST OF FUNCTION VALUES')\n logging.info(function_values_reshaped)\n\n logging.info('MAX VALUE SEEN CURRENTLY')\n logging.info(np.max(function_values_reshaped))\n\n logging.info('MEAN OF VALUES')\n logging.info(np.mean(function_values_reshaped))\n\n if logging_data is not None:\n iteration = logging_data['iteration']\n best_value = logging_data['best_value']\n iteration = logging_data['iteration']\n best_input = logging_data['best_input']\n best_core_hyperparameters = logging_data['best_core_hyperparameters']\n optimizer_state = blackbox_optimizer.get_state()\n\n if current_value_exact > best_value[0]:\n best_value[0] = current_value_exact\n best_input = current_input\n best_core_hyperparameters = core_hyperparameters\n\n # Writing logs.\n if iteration % config.log_frequency == 0:\n util.log_row(config.params_file, current_input)\n util.log_row(config.best_params_file, best_input)\n util.log_row(config.best_core_hyperparameters_file,\n best_core_hyperparameters)\n util.log_row(config.best_value_file, best_value)\n util.log_row(config.optimizer_internal_state_file, optimizer_state)\n util.log_row(config.current_values_list_file, [current_value_exact])\n util.log_row(config.best_values_list_file, [best_value[0]])\n util.log_row(config.fvalues_file, function_values_reshaped)\n util.log_row(config.iteration_file, [iteration])\n\n print('Current exact value estimate:')\n print(current_value_exact)\n sys.stdout.flush()\n\n new_current_input = blackbox_optimizer.run_step(perturbations_reshaped,\n function_values_reshaped,\n current_input,\n current_value_exact)\n config.controller.collect_rewards_and_train(rewards_for_controller,\n finished_dnas)\n\n evaluation_stats_reduced = [sum(x) for x in zip(*evaluation_stats)]\n blackbox_optimizer.update_state(evaluation_stats_reduced)\n\n return [True, new_current_input]","def _optimize_f(self,x0,type,method,**kwargs):\n from scipy.optimize import fmin,fmin_powell\n\n if type == 'min':\n g=lambda *args,**kwargs:self.f(*args,**kwargs)\n elif type == 'max':\n g=lambda *args,**kwargs:-1*self.f(*args,**kwargs)\n elif type == 'root':\n g=lambda *args,**kwargs:np.abs(self.f(*args,**kwargs))\n elif type == 'val':\n val = kwargs.pop('valtofind')\n g=lambda *args,**kwargs:np.abs(self.f(*args,**kwargs)-val)\n elif type == 'saddle':\n raise NotImplementedError\n else:\n raise ValueError('Unrecognized optimization type')\n\n if method == 'fmin':\n res = fmin(g,x0,tuple(self.parvals),**kwargs)\n elif method == 'fmin_powell':\n res = fmin_powell(g,x0,tuple(self.parvals),**kwargs)\n else:\n raise ValueError('Unrecognized method')\n\n self.lastOpt = res\n return res[0]","def maxlikelihood(self):\n\n chi2 = lambda *args: -2 * lnlikelihood.lnlike(*args) \n # print('***DEBUGGING*** chi2 = ', chi2)\n # print('***DEBUGGING*** self.theta_guess = ', self.theta_guess)\n # print('***DEBUGGING*** self.transinfo = ', self.transinfo)\n # print('***DEBUGGING*** self.wave_b = ', self.wave_b)\n # print('***DEBUGGING*** self.flux_b = ', self.flux_b)\n # print('***DEBUGGING*** self.err_b = ', self.err_b)\n # print('***DEBUGGING*** self.wave_r = ', self.wave_r)\n # print('***DEBUGGING*** self.flux_r = ', self.flux_r)\n # print('***DEBUGGING*** self.err_r = ', self.err_r)\n # print('***DEBUGGING*** self.velres = ', self.velres)\n result = op.minimize(chi2, self.theta_guess,\n args=(self.transinfo, self.wave_b, self.flux_b, self.err_b,\n self.wave_r, self.flux_r, self.err_r, self.velres))\n\n self.theta_ml = result[\"x\"]","def optimiseOne(paramOption, row, extractdata, start, stop, step):\n stockname = row[0]\n exclAttribs = row[1]\n bestNu = row[2]\n\n tryParam = start\n bestParam = tryParam\n (trialError, trialCorrelation, trailAttrCsv) = common.lsCalcModel(\n stockname, exclAttribs, common.cv, extractdata, bestNu, \"{0} {1}\".format(paramOption, tryParam))\n\n print \"Starting correlation={0}, with param={1}\".format(trialCorrelation, bestParam)\n bestCorrelation = trialCorrelation\n\n tryParam = start + step\n while tryParam < stop:\n print \"Trial {0}={1}\".format(paramOption, tryParam)\n (trialError, trialCorrelation, trailAttrCsv) = common.lsCalcModel(\n stockname, exclAttribs, common.cv, extractdata, tryParam)\n print \"Result: correlation={0} for trial Nu={1} with current bestCorrelation={2}\".\\\n format(trialCorrelation, tryParam, bestCorrelation)\n if trialCorrelation >= bestCorrelation:\n bestCorrelation = trialCorrelation\n bestParam = tryParam\n print \"Found better or same correlation=\" + str(bestCorrelation) + \" with Nu={0}\".format(bestParam)\n else:\n print \"Not better. Best parameter value = {0} with correlation={1}\".format(bestParam, bestCorrelation)\n break\n\n tryParam = tryParam + step\n\n return (bestParam, bestCorrelation)","def maximum(x1, x2, *args, **kwargs):\n raise NotImplementedError","def test_optimalagentfinder () :\n def valNetwork (s) : \n s = s.float()\n v = reduce(model.withReluDropout, model.v[:-1], s)\n v = model.v[-1](v)\n return v\n acrobotBases = acrobotRewardBases(np.pi / 8, np.pi / 8)\n fn = random.sample(acrobotBases, k=1).pop()\n agent = findOptimalAgent(fn)\n model = agent.model\n toExternal = lambda x, y : toExternalStateRep([x, y, 0, 0])\n valFn = reduce(compose, [float, valNetwork, torch.tensor, toExternal])\n RFn = compose(fn, toExternal)\n xRange = np.arange(-np.pi, np.pi, 0.1)\n yRange = np.arange(-np.pi, np.pi, 0.1)\n plotFunction(RFn, xRange, yRange, 'theta1', 'theta2', 'R')\n plotFunction(valFn, xRange, yRange, 'theta1', 'theta2', 'V')","def _maximize(self, board, possible_actions, depth_limit, alpha, beta):\r\n pass","def solve(self, example_name, max_iter = 100, is_check_stop = True, maximum_line_search = 10):\n logger.debug(\"[+ +] Initial Obj.Val.: %.5e\"%(self.get_obj_fun_value()))\n start_time = tm.time()\n for i in range(max_iter):\n if i == 1: # skip the compiling time \n start_time = tm.time()\n iter_start_time = tm.time()\n self.backward_pass()\n backward_time = tm.time()\n obj, isStop = self.forward_pass(max_line_search=maximum_line_search)\n forward_time = tm.time()\n logger.debug(\"[+ +] Iter.No.%3d BWTime:%.3e FWTime:%.3e Obj.Val.:%.5e\"%(\n i, backward_time-iter_start_time,forward_time-backward_time,obj))\n result_path = os.path.join(\"logs\", example_name, str(i) +\".mat\")\n io.savemat(result_path,{\"trajectory\": self.get_traj()})\n if isStop and is_check_stop:\n break\n end_time = tm.time()\n logger.debug(\"[+ +] Completed! All Time:%.5e\"%(end_time-start_time))","def optimise(\n cls,\n species: \"Species\",\n method: \"Method\",\n n_cores: Optional[int] = None,\n coords: Optional[OptCoordinates] = None,\n **kwargs,\n ) -> None:","def _objective(self, trial, X, y, weights=None, split=None):\n\n # Generate even weights if none\n if weights is None:\n weights = pd.Series(np.ones(len(y)), index=y.index)\n else:\n weights = pd.Series(weights, index=y.index)\n\n # Execute trial function\n try:\n res = eval(self.function)\n except:\n raise RuntimeError(f\"Optuna execution error: {self.function}\")\n\n # If indicator result is tuple, select the one of interest\n if isinstance(res, tuple):\n res = res[self.idx]\n\n # Ensure result is a dataframe with same index as X\n res = pd.DataFrame(res, index=X.index)\n\n # If indicator result is dataframe, select the one of interest\n if len(res.columns) > 1:\n res = pd.DataFrame(res.iloc[:, self.idx])\n\n # y may be a subset of X, so reduce result to y and convert to series\n res_y = res.reindex(y.index).iloc[:, 0].replace([np.inf, -np.inf], np.nan)\n\n # Save all trial results for pruning and reporting\n # Only the best trial will eventually be saved to limit storage requirements\n self.res_y.append(res_y) # Save results\n\n # Indicator result may be all NANs based on parameter set\n # Return FALSE and alert\n if np.isnan(res_y).sum() / len(res_y) > .95: # Most or all NANs\n self.res_y_corr.append(np.zeros(len(y)))\n if split is not None:\n return tuple([False] * (len(split) - 1))\n else:\n return False\n\n # Obtain correlation for entire dataset\n if self.spearman:\n corr = _weighted_spearman(np.array(y), np.array(res_y), np.array(weights))\n else:\n corr = _weighted_pearson(np.array(y), np.array(res_y), np.array(weights))\n\n # Save correlation for res_y\n self.res_y_corr.append(corr)\n\n # Multi-objective optimization\n # Obtain correlation to target for each split for Optuna to maximize\n if split is not None:\n mo = []\n for i, e in enumerate(split):\n if i == 0:\n s = e\n continue\n\n # y could be a subset of X, use index of X to filter y\n idx = X[s:e].index\n\n # Filter y based on X split\n y_se = np.array(y[y.index.isin(idx)]).astype('float64')\n\n # Filter y predictions based on X split\n res_y_se = np.array(res_y[res_y.index.isin(idx)]).astype('float64')\n\n # Filter weights based on X split\n weights_se = np.array(weights[weights.index.isin(idx)]).astype('float64')\n\n if np.isnan(res_y_se).sum() / len(res_y_se) > .95:\n return tuple([False]*(len(split)-1))\n\n if self.spearman:\n mo.append(_weighted_spearman(y_se, res_y_se, weights_se))\n else:\n mo.append(_weighted_pearson(y_se, res_y_se, weights_se))\n s = e\n return tuple(mo)\n\n # Single objective optimization return corr for entire dataset\n else:\n return corr","def downhill(F, xStart, args=None, side=0.1, ftol=1.0e-6, xtol=1.0e-6, maxiter=1000, maxfunc=1000, maxiternochange=10):\n # TODO: check the types of the input ???\n\n # print \"Entering downhill\"\n n = len(xStart)\n x = np.zeros((n+1, n), dtype=float) #point null matrix, n+1 rows, n columns\n f = np.zeros(n+1, dtype=float) # null vector, n+1 columns\n p_count = 0 # counter for detecting a plateau\n f_count = 0 # counter for the number of function call\n f_best_count = 0 # counter for the number of iterations in which the best solution does not change\n f_best_prev = 0.0 # holds the best value from the previous iteration\n epsilon = 0.001 # tolerance for considering two values as equal\n # max_iter_no_change = 10 # maximum number of accepted iterations with no change in the optimal solution\n precision = 2\n round_map = partial(round, ndigits=precision) # partial function for rounding purposes\n\n # initial simplex\n x[0] = xStart\n for i in xrange(1, n+1):\n x[i] = xStart\n x[i,i-1] = xStart[i-1] + side\n\n # print \"Evaluate the starting points\"\n # compute the value of F at the vertices of the simplex\n for i in xrange(n+1):\n f[i] = F(x[i], args)\n # p_count += 1\n\n # main loop\n # print \"Start iterating\"\n for k in xrange(maxiter):\n\n # check the number of function calls\n if f_count > maxfunc:\n print \"Stopping criteria: maximum number of function calls\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXFUNCALL'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXFUNCALL'}\n\n # find the best and worst vertex (consider a minimization problem)\n iLo = np.argmin(f) # best vertex\n iHi = np.argmax(f) # worst vertex\n\n # print k,\" \", f[iLo]\n #\n # if f[iLo] < -0.310000:\n # print f[iLo]\n # print x[iLo]\n # print x\n # sys.exit(1)\n # print \"k: \", k, \" f_best_prev: \", f_best_prev, \" f[iLo]: \", f[iLo], \" f_best_count: \", f_best_count\n # print \"Beginning of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\n # print \"x: \", x, \" f: \", f\n # print \"=========================================================================================\"\n # check if the solution has changed from the previous iterations\n if f[iLo] < f_best_prev:\n f_best_prev = f[iLo]\n f_best_count = 0\n else:\n f_best_count += 1\n\n if f_best_count > maxiternochange:\n print \"Stopping criteria: maximum number of iterations with no improvement in the best solution\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'NOIMPROVEMENT'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'NOIMPROVEMENT'}\n\n if abs(f[iLo] - f[iHi]) < ftol: # If difference between highest and lowest is smaller than ftol, return\n print \"Stopping criteria: difference between highest and lowest points is smaller than tolerance\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXTOLERANCE'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXTOLERANCE'}\n # compute the move vector d\n d = (-(n+1) * x[iHi] + np.sum(x, axis=0)) / n\n # print \"d: \", d\n\n # check for convergence\n if sqrt(np.dot(d, d)/n) < xtol: # length of the vector d\n print \"Stopping criteria: length of step d smaller than tolerance\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'SMALLSTEP'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'SMALLSTEP'}\n # try reflection\n xNew = np.array(map(round_map, x[iHi] + 2 * d))\n fNew = F(xNew, args)\n f_count += 1\n # print \"Reflected point: \", xNew, \" value: \", fNew\n\n # check for no improvement over the worst point\n # and for plateau condition\n if f[iHi] - epsilon <= fNew <= f[iHi] + epsilon:\n p_count += 1\n # print \"No improvement here\"\n\n if p_count == n+2: # we reflected all vertices with no improvement\n print \"Stopping criteria: Probably we landed on a plateau... exiting\" # TODO: restart instead of exiting\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'PLATEAU'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'PLATEAU'}\n\n\n else:\n p_count = 0\n\n\n if fNew <= f[iLo]: # if the new value is better than the best so far,\n x[iHi] = xNew # substitute the worst vertex with the new one\n f[iHi] = fNew\n\n # try to expand the reflection\n xNew = np.array(map(round_map, x[iHi] + d))\n fNew = F(xNew, args)\n f_count += 1\n # print \"Expanded point: \", xNew, \" value: \", fNew\n\n if fNew <= f[iHi]: # in the original source version it is f[iLo] (?)\n x[iHi] = xNew\n f[iHi] = fNew\n else:\n # try reflection again\n if fNew <= f[iHi]:\n x[iHi] = xNew\n f[iHi] = fNew\n else:\n # try contraction\n xNew = np.array(map(round_map, x[iHi] + 0.5 * d))\n fNew = F(xNew, args)\n f_count += 1\n # print \"Contracted point: \", xNew, \" value: \", fNew\n\n if fNew <= f[iHi]: # accept contraction\n x[iHi] = xNew\n f[iHi] = fNew\n else:\n # shrink\n for i in xrange(len(x)):\n if i != iLo:\n x[i] = np.array(map(round_map, x[i] - x[iLo] * 0.5))\n f[i] = F(x[i], args)\n f_count += 1\n\n # print \"End of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\n # print \"x: \", x, \" f: \", f\n # print \"*\"*50\n # print \"\"\n\n\n\n print \"Stopping criteria: maximum number of iterations\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXITERATION'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXITERATION'}","def optimize(self, X, y, *args):\n self.loss_function.set_space(X, y, *args)\n self.betas_ = fastgradalgo(\n self.loss_function,\n t_init=self.eta_init,\n max_iter=self.max_iter\n )\n return self.betas_","def heuristics(e, z, z0, direction):\n\n from sympy.calculus.util import AccumBounds\n rv = None\n if abs(z0) is S.Infinity:\n rv = limit(e.subs(z, 1 / z), z, S.Zero, 1 if z0 is S.Infinity else -1)\n if isinstance(rv, Limit):\n return\n elif e.is_Mul or e.is_Add or e.is_Pow or e.is_Function:\n r = []\n for a in e.args:\n l = limit(a, z, z0, direction)\n if l.has(S.Infinity) and l.is_finite is None:\n if isinstance(e, Add):\n m = factor_terms(e)\n if not isinstance(m, Mul): # try together\n m = together(m)\n if not isinstance(m, Mul): # try factor if the previous methods failed\n m = factor(e)\n if isinstance(m, Mul):\n return heuristics(m, z, z0, direction)\n return\n return\n elif isinstance(l, Limit):\n return\n elif l is S.NaN:\n return\n else:\n r.append(l)\n if r:\n rv = e.func(*r)\n if rv is S.NaN and e.is_Mul and any(isinstance(rr, AccumBounds) for rr in r):\n r2 = []\n e2 = []\n for ii in range(len(r)):\n if isinstance(r[ii], AccumBounds):\n r2.append(r[ii])\n else:\n e2.append(e.args[ii])\n\n if len(e2) > 0:\n from sympy import simplify\n e3 = simplify(Mul(*e2))\n l = limit(e3, z, z0, direction)\n rv = l * Mul(*r2)\n\n if rv is S.NaN:\n try:\n rat_e = ratsimp(e)\n except PolynomialError:\n return\n if rat_e is S.NaN or rat_e == e:\n return\n return limit(rat_e, z, z0, direction)\n return rv","def act(self, q_values, *args, **kwargs):\n return np.array([np.argmax(q_values)])","def _autolag(mod, endog, exog, startlag, maxlag, method, modargs=(),\n fitargs=(), regresults=True):\n if not regresults: # pragma: no cover\n # TODO: update docstring\n raise NotImplementedError(\"option `regresults=False` not ported \"\n \"from upstream. _autolag always returns \"\n \"a tuple (icbest, bestlag, results)\")\n\n # TODO: can tcol be replaced by maxlag + 2?\n # TODO: This could be changed to laggedRHS and exog keyword arguments if\n # this will be more general.\n\n results = {}\n method = method.lower()\n for lag in range(startlag, startlag + maxlag + 1):\n mod_instance = mod(endog, exog[:, :lag], *modargs)\n results[lag] = mod_instance.fit()\n\n if method == \"aic\":\n icbest, bestlag = min((v.aic, k) for k, v in results.items())\n elif method == \"bic\":\n icbest, bestlag = min((v.bic, k) for k, v in results.items())\n elif method == \"t-stat\":\n # stop = stats.norm.ppf(.95)\n stop = 1.6448536269514722\n for lag in range(startlag + maxlag, startlag - 1, -1):\n icbest = np.abs(results[lag].tvalues[-1])\n if np.abs(icbest) >= stop:\n bestlag = lag\n icbest = icbest\n break\n else: # pragma: no cover\n raise ValueError(\"Information Criterion %s not understood.\" % method)\n\n return icbest, bestlag, results","def maximizer(evaluate):\n def strategy(player, board):\n def score_move(move):\n return evaluate(player, Othello.make_move(move, player, list(board)))\n return max(Othello.legal_moves(player, board), key=score_move)\n return strategy","def MidpointFnBuilder(max_speed = 26.8, gain = 0.1, beta = 0.5, duration = 500, bias = 1.0, ratio = 0.5):\n\n def MidpointFn((idx, car), sim, step):\n \"\"\"\n :param idx:\n :param car:\n :param sim:\n :param step:\n :return:\n \"\"\"\n vehID = car[\"id\"]\n\n try:\n [back_car, front_car] = sim.getCars(idx, numBack=1, numForward=1, lane=car[\"lane\"])\n except ValueError:\n # Not enough cars on lane\n return\n\n front_dist = (front_car[\"x\"] - car[\"x\"]) % sim.length\n back_dist = (car[\"x\"] - back_car[\"x\"]) % sim.length\n\n curr_speed = car[\"v\"]\n front_speed = front_car[\"v\"]\n follow_dist = (front_dist + back_dist) * ratio\n delta = front_dist - follow_dist\n # print delta, curr_speed, front_speed, curr_speed-front_speed\n if follow_dist < front_dist and curr_speed < max_speed:\n # speed up\n new_speed = min(curr_speed + beta * (front_speed-curr_speed) + gain * delta + bias, max_speed)\n traci.vehicle.slowDown(vehID, new_speed, duration) # 2.5 sec\n # print \"t=%d, FASTER, %0.1f -> %0.1f (%0.1f) | d=%0.2f = %0.2f vs %0.2f\" % \\\n # (step, curr_speed, new_speed, front_speed, delta, front_dist, follow_dist)\n elif follow_dist > front_dist:\n # slow down\n new_speed = max(curr_speed + beta * (front_speed-curr_speed) + gain * delta + bias, 0)\n traci.vehicle.slowDown(vehID, new_speed, duration) # 2.5 sec\n # print \"t=%d, SLOWER, %0.1f -> %0.1f (%0.1f) | d=%0.2f = %0.2f vs %0.2f\" % \\\n # (step, curr_speed, new_speed, front_speed, delta, front_dist, follow_dist)\n\n return MidpointFn","def optimize(self, iterations=1000):\r\n prev = None\r\n finalx = None\r\n finaly = None\r\n while iterations:\r\n maxei, eis = self.acquisition()\r\n new_y = self.f(maxei)\r\n if maxei == prev:\r\n break\r\n self.gp.update(maxei, new_y)\r\n pycodehack = finaly is None or self.minimize and finaly > new_y\r\n if ((pycodehack or not self.minimize and finaly < new_y)):\r\n finaly = new_y\r\n finalx = maxei\r\n prev = maxei\r\n iterations -= 1\r\n return finalx, finaly","def _generic_minimize(method, loss, x0,\n verbose=False,\n num_iters=1000,\n tol=1e-4,\n state=None,\n full_output=False,\n suppress_warnings=False,\n **kwargs):\n # Flatten the loss\n _x0, unflatten = flatten(x0)\n _objective = lambda x_flat, itr: loss(unflatten(x_flat), itr)\n\n if verbose:\n print(\"Fitting with {}.\".format(method))\n\n # Specify callback for fitting\n itr = [0]\n def callback(x_flat):\n itr[0] += 1\n print(\"Iteration {} loss: {:.3f}\".format(itr[0], loss(unflatten(x_flat), -1)))\n\n # Wrap the gradient to avoid NaNs\n def safe_grad(x, itr):\n g = grad(_objective)(x, itr)\n g[~np.isfinite(g)] = 1e8\n return g\n\n # Call the optimizer. Pass in -1 as the iteration since it is unused.\n result = minimize(_objective, _x0, args=(-1,),\n jac=safe_grad,\n method=method,\n callback=callback if verbose else None,\n options=dict(maxiter=num_iters, disp=verbose),\n tol=tol,\n **kwargs)\n if verbose:\n print(\"{} completed with message: \\n{}\".format(method, result.message))\n\n if not suppress_warnings and not result.success:\n warn(\"{} failed with message:\\n{}\".format(method, result.message))\n\n if full_output:\n return unflatten(result.x), result\n else:\n return unflatten(result.x)","def tune_parameters(self, parameters, search_alg, num_trials=5, metric=\"f1\", direction=\"maximize\", train_ratio=0.7, num_times=1, export_metrics=True):\n self._clear_cache()\n model_id = self.model_id\n if self.comet_key != None:\n exp = init_experiment(self.comet_key, \"model-performance\", \"covid-vaccine\")\n exp.log_parameters({\n \"model_id\":model_id,\n \"model_type\":self.embedding_type,\n \"multiclass\":self.class_label,\n \"train_ratio\":train_ratio,\n \"num_samples\":num_trials,\n \"metric\":metric,\n \"direction\":direction,\n \"search_alg\":search_alg\n })\n log_fixed_params(parameters, exp)\n exp.add_tag(\"multi\" if self.class_label == \"Multiclass\" else \"binary\")\n start = time.time()\n tr_text, tr_label, self.tr_meta, te_text, te_label, self.te_meta, _ = get_train_test_data(self.seed_fp, self.label_fp, train_ratio=train_ratio, meta_cols=self.meta_cols, drop_irrelevant=self.drop_irrelevant, visualize=False, verbose=self.verbose)\n self._transform_labels(tr_label, te_label)\n print(\"data loading:\", time.time() - start, \"seconds\\n\")\n start = time.time()\n self._prepare_feature_components(tr_text, te_text, parameters)\n print(\"total preprocessing:\", time.time() - start, \"seconds\\n\")\n metric_df_parts = []\n def objective(trial):\n config = suggest_config(parameters, trial)\n instances = []\n for _ in range(num_times):\n instance_df = self._run_single_config(train_ratio, config)\n instance_df = instance_df[instance_df[\"part\"] == \"test\"]\n instances.append(instance_df)\n tmp_df = pd.concat(instances, axis=0)\n print(\"metrics 1\", tmp_df.shape)\n group_cols = list(tmp_df.drop(\"score\", axis=1).columns)\n print(group_cols)\n tmp_df = tmp_df.groupby(group_cols)[\"score\"].agg([\"mean\",\"std\"]).reset_index()\n print(\"metrics 2\", tmp_df.shape)\n metric_df_parts.append(tmp_df)\n metrics = dict(zip(tmp_df[\"metric\"],tmp_df[\"mean\"]))\n return metrics[metric]\n if search_alg == \"GRID\":\n algo = GridSampler(extract_grid(parameters))\n elif search_alg == \"RND\":\n algo = RandomSampler()\n elif search_alg == \"TPE\":\n algo = TPESampler(n_startup_trials=int(num_trials*0.3))\n else:#default optuna setting\n algo = None\n study = optuna.create_study(direction=\"maximize\", sampler=algo)\n study.optimize(objective, n_trials=num_trials, n_jobs=1)\n metrics_df = pd.concat(metric_df_parts)\n best_config = study.best_params\n print(\"Best config: \", best_config)\n if export_metrics:\n result_dir = os.path.join(self.model_dir, \"results\")\n if not os.path.exists(result_dir):\n os.makedirs(result_dir)\n study_fp = os.path.join(result_dir, \"%s.pkl\" % model_id)\n print(\"Study file:\", study_fp)\n joblib.dump(study, study_fp)\n result_fp = os.path.join(result_dir, \"%s.csv\" % model_id)\n print(\"Output file:\", result_fp)\n metrics_df.to_csv(result_fp, index=False)\n if self.comet_key != None:\n exp.log_parameters(best_config)\n exp.log_metrics({\n \"train_size\":len(tr_text),\n \"test_size\":len(te_text)\n })\n best_results = dict(metrics_df.groupby(\"metric\")[\"mean\"].max()[[\"f1\",\"acc\",\"auc\"]])\n exp.log_metrics(best_results)\n exp.end()\n return best_config","def optimize(self, state, algorithm, distances):\n\n if self.__current_job is not None:\n raise ServiceError('Optimization in progress. Wait till the end, before submitting next state.', 3)\n\n assert isinstance(state, State)\n assert isinstance(algorithm, Algorithm)\n assert isinstance(distances, Distances)\n\n data = {\n 'state': json.dumps(state.to_dict()),\n 'key': self.key,\n 'distances': json.dumps(distances.to_dict()),\n 'algorithm': json.dumps(algorithm.to_dict()),\n 'previous_task': self.__previous_job\n }\n\n try:\n response = requests.post('{}/api/v1/solve'.format(self.URL), data=data, timeout=10)\n except (Timeout, ConnectionError):\n raise ServiceError('Service unavailable: timeout.', 4)\n\n result = self._validate(response)\n self.__current_job = result.get('jid')\n return self.__current_job","def evaluate(Agent, rules, wrappers, params_path=None, steps=1024):\n\n score = 0.0\n\n agent = Agent()\n\n if params_path is not None:\n agent.load_state_dict(params_path)\n\n env = CARLE()\n\n\n for wrapper in wrappers:\n env = wrapper[0](env)\n env.reward_scale = wrapper[1]\n\n env.batch_size = steps*len(rules)\n\n if wrapper[2] is not None:\n env.load_state_dict(torch.load(wrapper[2]))\n\n env.eval()\n\n #env.set_no_grad()\n\n total_steps = 0\n score_trace = []\n for ruleset in rules:\n\n env.inner_env.birth = ruleset[0]\n env.inner_env.survive = ruleset[0]\n\n obs = env.reset()\n\n for step in range(steps):\n\n action = agent(obs)\n\n obs, reward, done, info = env.step(action)\n\n score += reward.detach().sum().cpu().numpy()\n score_trace.append(reward.detach().sum().cpu().numpy())\n\n total_steps += 1\n\n print(\"cumulative score = {:.3e} at total steps = {}, rulset = {}\".format(\\\n score, total_steps, ruleset))\n\n score /= total_steps\n \n return score, score_trace","def get_optbins(data, method='freedman', ret='N'):\n x = np.asarray(data)\n n = x.size\n r = x.max() - x.min()\n\n def sturge():\n if (n <= 30):\n print(\"Warning: Sturge estimator can perform poorly for small samples\")\n k = int(np.log(n) + 1)\n h = r / k\n return h, k\n\n def scott():\n h = 3.5 * np.std(x) * float(n) ** (-1. / 3.)\n k = int(r / h)\n return h, k\n\n def freedman():\n q = quantiles(x, [25, 75])\n h = 2 * (q[75] - q[25]) * float(n) ** (-1. / 3.)\n k = int(r / h)\n return h, k\n\n def bayesian():\n r = bayesian_blocks(x)\n return np.diff(r),r\n\n m = {'sturge': sturge, 'scott': scott, 'freedman': freedman,\n 'bayesian': bayesian}\n\n if method.lower() in m:\n s = m[method.lower()]()\n if ret.lower() == 'n':\n return s[1]\n elif ret.lower() == 'w':\n return s[0]\n else:\n return None","def max(x):\n pass","def solve(self, topology, algorithm=\"SLSQP\", grad=\"AD\", step_size=1e-6, iters=100, eps=1e-6, kappa=1e-8, tmax=100, eta=1e-6, verbose=False):\n if verbose:\n print(\"----------\")\n print(\"Optimization with {} started!\".format(algorithm))\n print(f\"# Parameters: {self.number_of_parameters()}, # Constraints {self.number_of_constraints()}\")\n\n # test for bad stuff before going any further\n self.check_optimization_sanity()\n\n # compose gradient and objective functions\n if grad not in (\"AD\", \"FD\"):\n raise ValueError(f\"Gradient method {grad} is not supported!\")\n if grad == \"AD\":\n if verbose:\n print(\"Computing gradients using automatic differentiation!\")\n x_func = partial(self._optimize_form, topology=topology.copy(), tmax=tmax, eta=eta)\n grad_func = partial(grad_autograd, grad_func=agrad(x_func)) # x, grad, x_func\n\n elif grad == \"FD\":\n if verbose:\n print(f\"Warning: Calculating gradients using finite differences with step size {step_size}. This may take a while...\")\n grad_func = self.gradient_func(grad_finite_differences, topology.copy(), tmax, eta, step_size)\n\n # grad_func = self.gradient_func(grad_func, topology.copy(), tmax, eta, step_size)\n obj_func = self.objective_func(topology, grad_func, tmax, eta)\n\n # generate optimization variables\n x = self.optimization_parameters(topology)\n\n # extract the lower and upper bounds to optimization variables\n bounds_low, bounds_up = self.optimization_bounds(topology)\n\n # stack keyword arguments\n hyper_parameters = {\"f\": obj_func,\n \"algorithm\": algorithm,\n \"dims\": self.number_of_parameters(),\n \"bounds_low\": bounds_low,\n \"bounds_up\": bounds_up,\n \"iters\": iters,\n \"eps\": eps,\n \"ftol\": kappa}\n\n # assemble optimization solver\n solver = nlopt_solver(**hyper_parameters)\n\n # solve optimization problem\n x_opt = None\n start = time()\n try:\n x_opt = solver.optimize(x)\n if verbose:\n print(\"Optimization ended correctly!\")\n except RoundoffLimited:\n print(\"Optimization was halted because roundoff errors limited progress\")\n print(\"Results may still be useful though!\")\n x_opt = self.optimization_parameters(topology)\n except RuntimeError:\n print(\"Optimization failed due to a runtime error!\")\n print(f\"Optimization total runtime: {round(time() - start, 4)} seconds\")\n return static_equilibrium(topology)\n\n # fetch last optimum value of loss function\n time_opt = time() - start\n loss_opt = solver.last_optimum_value()\n evals = solver.get_numevals()\n status = nlopt_status(solver.last_optimize_result())\n\n # set optimizer attributes\n self.time_opt = time_opt\n self.x_opt = x_opt\n self.penalty = loss_opt\n self.evals = evals\n self.status = status\n\n # set norm of the gradient\n # NOTE: np.zeros is a dummy array (signature requirement set by nlopt)\n self.gradient = grad_func(x_opt, np.zeros(x_opt.size))\n self.gradient_norm = np.linalg.norm(self.gradient)\n\n if verbose:\n print(f\"Optimization total runtime: {round(time_opt, 6)} seconds\")\n print(\"Number of evaluations incurred: {}\".format(evals))\n print(f\"Final value of the objective function: {round(loss_opt, 6)}\")\n print(f\"Norm of the gradient of the objective function: {round(self.gradient_norm, 6)}\")\n print(f\"Optimization status: {status}\".format(status))\n print(\"----------\")\n\n # exit like a champion\n return static_equilibrium(topology)","def fit(args):\n\n config_file = args.setupfn\n conf_base = os.path.basename(config_file).split('.')[0]\n print(\"Performing maximum a posteriori fitting for {}\".format(conf_base))\n\n P, post = radvel.utils.initialize_posterior(config_file, decorr=args.decorr)\n\n post = radvel.fitting.maxlike_fitting(post, verbose=True)\n\n postfile = os.path.join(args.outputdir,\n '{}_post_obj.pkl'.format(conf_base))\n post.writeto(postfile)\n\n savestate = {'run': True,\n 'postfile': os.path.relpath(postfile)}\n save_status(os.path.join(args.outputdir,\n '{}_radvel.stat'.format(conf_base)),\n 'fit', savestate)","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n\n def MaxValue(gameState, currentDepth, agentNumber):\n \n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\n \n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\n return (self.evaluationFunction(gameState), Directions.NORTH)\n #print 'depth ',currentDepth\n \n largestValue = float(\"-inf\")\n bestAction = Directions.NORTH\n for action in gameState.getLegalActions(agentNumber):\n #print 'analyzing ',action,' for pacman ',agentNumber\n successor = gameState.generateSuccessor(agentNumber, action)\n successorValue = MinValue(successor, currentDepth, (agentNumber + 1) % gameState.getNumAgents())[0]\n if(successorValue > largestValue):\n largestValue = successorValue\n bestAction = action\n return (largestValue, bestAction)\n \n def MinValue(gameState, currentDepth, agentNumber):\n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\n return (self.evaluationFunction(gameState), Directions.NORTH)\n \n #print 'depth ',currentDepth\n \n smallestValue = float(\"inf\")\n bestAction = Directions.NORTH \n for action in gameState.getLegalActions(agentNumber):\n #print 'analyzing ',action,' for ghost ',agentNumber\n successor = gameState.generateSuccessor(agentNumber, action)\n nextAgentNumber = (agentNumber + 1) % gameState.getNumAgents()\n if nextAgentNumber is 0:\n successorValue = MaxValue(successor, currentDepth + 1, nextAgentNumber)[0]\n else:\n successorValue = MinValue(successor, currentDepth, nextAgentNumber)[0]\n if(successorValue < smallestValue):\n smallestValue = successorValue\n bestAction = action\n return (smallestValue, bestAction)\n\n result = MaxValue(gameState, 0, 0)\n resultActionToTake = result[1]\n #print 'Minimax value for depth ', self.depth,' ',result[0]\n #import time\n #time.sleep(1000000)\n return resultActionToTake","def test_minimax_regret():\n f = np.asarray([\n [0.99, 1.0, 0.5],\n [0.69, 0.6, 0.6]])\n R = common_metrics.minimax_regret(f, maximise=True)\n expected = np.asarray(\n [-0.1, -0.4])\n assert np.allclose(R, expected)\n R = common_metrics.minimax_regret(f, maximise=False)\n expected = np.asarray(\n [-0.4, -0.1])\n assert np.allclose(R, expected)","def get_result_function(test_case):\n if (test_case.direction == 'grad'):\n return get_grad_results\n elif (test_case.direction == 'forward'):\n return get_forward_results\n else:\n raise Exception(\"Direction provided not recognised\")","def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\r\n\r\n\t\r\n\tif grad == 'NO':\r\n\t\tif method == 'Powell' :\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'Nelder-Mead':\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t options = {'ftol': 0.0001})\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'default':\r\n\t\t\tres = opt.minimize(Ulike,init_par, \r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\r\n\telif grad == 'YES':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \r\n \t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\r\n\t\treturn res.x, res.nit \r\n\t\t\t\r\n\t\t\r\n\telif grad == 'HESS':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\r\n\t\t\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \r\n\t\treturn res.x, res.nit","def optimize_svr(data, targets):\r\n def svc_crossval(C,epsilon,loss_n):\r\n\r\n return svc_cv(C=C, epsilon=epsilon,loss_n=loss_n, data=data, targets=targets)\r\n\r\n optimizer = BayesianOptimization(\r\n f=svc_crossval,\r\n pbounds={\"C\": (0.0001, 1000), \"epsilon\": (0, 0.2),'loss_n':(0,1)},\r\n random_state=1234,\r\n verbose=2\r\n )\r\n logger=JSONLogger(path=\"./linsvrlogs.json\")\r\n optimizer.subscribe(Events.OPTMIZATION_STEP,logger)\r\n optimizer.maximize(init_points=50,n_iter=300)\r\n with open('./linsvrlogs.json','a',encoding='utf-8')as f:\r\n f.write(str(optimizer.max))","def optimize(self, num_restarts=1, max_iters=100, max_f_eval=300.0, method='Anneal'):\n dic = DictVectorizer()\n # flatten the parameters\n init_params,bounds=dic.fit_transform(self.params)\n #we minimise minus the marginal likelihood\n def objective(params_flatten):\n self.params=dic.inverse_transform(params_flatten,bounds)\n val = -self.log_marginal_likelihood()\n return val# we want to maximize it\n \n \n #run ptimisation with multiple restarts\n optml=np.inf\n for i in range(num_restarts):\n #minimise function\n if method=='Anneal':\n res=dual_annealing(objective,bounds, maxiter=max_iters, maxfun=max_f_eval, x0=init_params)\n else:\n \n res = minimize(objective, init_params, \n bounds=bounds, method=method,options={'maxiter': max_iters, 'disp': False})\n #print(\"Iteration \"+str(i)+\" \",-res.fun)\n if res.fun<optml:\n params_best=res.x #init_params \n optml=res.fun\n init_params=bounds[:,0]+(bounds[:,1]-bounds[:,0])*np.random.rand(len(bounds[:,0]))\n print(\"Iteration \"+str(i)+\" \",-res.fun)\n #params_best=res.x\n #optml=res.fun\n self.params=dic.inverse_transform(params_best,bounds)\n return -optml","def max_hybrid(func: Callable[[Tuple], np.ndarray], over: Tuple[Tuple],\\\n state: Tuple[Union[int, float]], cont: Tuple[bool],\\\n actions: Iterable[Tuple]) -> Tuple[float, Tuple[Union[int, float]], None]:\n best = -np.inf\n bestarg = None\n funcarg = lambda x: -func(np.asarray(x).reshape(1, -1))[0, 0]\n statebounds = tuple(zip(state, state))\n for act in actions:\n actbounds = [b if c else (a, a) for a, c, b in zip(act, cont, over)]\n init = tuple([*state, *np.random.uniform(*zip(*over))])\n res = minimize(funcarg, x0=init, bounds=(*statebounds, *actbounds))\n val = -funcarg(res.x)\n if val > best:\n best = val\n bestarg = res.x\n return (best, tuple([float(v) if c else int(v) for v, c in \\\n zip(bestarg[len(state):], cont)]), None)","def checkgrad(self, target_param=None, verbose=False, step=1e-6, tolerance=1e-3):\r\n\r\n x = self._get_params_transformed().copy()\r\n\r\n if not verbose:\r\n # just check the global ratio\r\n\r\n #choose a random direction to find the linear approximation in\r\n if x.size==2:\r\n dx = step * np.ones(2) # random direction for 2 parameters can fail dure to symmetry\r\n else:\r\n dx = step * np.sign(np.random.uniform(-1, 1, x.size))\r\n\r\n # evaulate around the point x\r\n f1, g1 = self.objective_and_gradients(x + dx)\r\n f2, g2 = self.objective_and_gradients(x - dx)\r\n gradient = self.objective_function_gradients(x)\r\n\r\n numerical_gradient = (f1 - f2) / (2 * dx)\r\n global_ratio = (f1 - f2) / (2 * np.dot(dx, np.where(gradient==0, 1e-32, gradient)))\r\n\r\n return (np.abs(1. - global_ratio) < tolerance) or (np.abs(gradient - numerical_gradient).mean() < tolerance)\r\n else:\r\n # check the gradient of each parameter individually, and do some pretty printing\r\n try:\r\n names = self._get_param_names_transformed()\r\n except NotImplementedError:\r\n names = ['Variable %i' % i for i in range(len(x))]\r\n\r\n # Prepare for pretty-printing\r\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\r\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\r\n float_len = 10\r\n cols = [max_names]\r\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\r\n cols = np.array(cols) + 5\r\n header_string = [\"{h:^{col}}\".format(h=header[i], col=cols[i]) for i in range(len(cols))]\r\n header_string = map(lambda x: '|'.join(x), [header_string])\r\n separator = '-' * len(header_string[0])\r\n print '\\n'.join([header_string[0], separator])\r\n\r\n if target_param is None:\r\n param_list = range(len(x))\r\n else:\r\n param_list = self.grep_param_names(target_param, transformed=True, search=True)\r\n if not np.any(param_list):\r\n print \"No free parameters to check\"\r\n return\r\n\r\n\r\n for i in param_list:\r\n xx = x.copy()\r\n xx[i] += step\r\n f1, g1 = self.objective_and_gradients(xx)\r\n xx[i] -= 2.*step\r\n f2, g2 = self.objective_and_gradients(xx)\r\n gradient = self.objective_function_gradients(x)[i]\r\n\r\n numerical_gradient = (f1 - f2) / (2 * step)\r\n ratio = (f1 - f2) / (2 * step * np.where(gradient==0, 1e-312, gradient))\r\n difference = np.abs((f1 - f2) / 2 / step - gradient)\r\n\r\n if (np.abs(1. - ratio) < tolerance) or np.abs(difference) < tolerance:\r\n formatted_name = \"\\033[92m {0} \\033[0m\".format(names[i])\r\n else:\r\n formatted_name = \"\\033[91m {0} \\033[0m\".format(names[i])\r\n r = '%.6f' % float(ratio)\r\n d = '%.6f' % float(difference)\r\n g = '%.6f' % gradient\r\n ng = '%.6f' % float(numerical_gradient)\r\n grad_string = \"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\".format(formatted_name, r, d, g, ng, c0=cols[0] + 9, c1=cols[1], c2=cols[2], c3=cols[3], c4=cols[4])\r\n print grad_string","def checkgrad(self, target_param = None, verbose=False, step=1e-6, tolerance = 1e-3):\n\n x = self._get_params_transformed().copy()\n\n if not verbose:\n #just check the global ratio\n dx = step*np.sign(np.random.uniform(-1,1,x.size))\n\n #evaulate around the point x\n f1, g1 = self.objective_and_gradients(x+dx)\n f2, g2 = self.objective_and_gradients(x-dx)\n gradient = self.objective_function_gradients(x)\n\n numerical_gradient = (f1-f2)/(2*dx)\n global_ratio = (f1-f2)/(2*np.dot(dx,gradient))\n\n if (np.abs(1.-global_ratio)<tolerance) and not np.isnan(global_ratio):\n return True\n else:\n return False\n else:\n #check the gradient of each parameter individually, and do some pretty printing\n try:\n names = self._get_param_names_transformed()\n except NotImplementedError:\n names = ['Variable %i'%i for i in range(len(x))]\n\n # Prepare for pretty-printing\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\n float_len = 10\n cols = [max_names]\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\n cols = np.array(cols) + 5\n header_string = [\"{h:^{col}}\".format(h = header[i], col = cols[i]) for i in range(len(cols))]\n header_string = map(lambda x: '|'.join(x), [header_string])\n separator = '-'*len(header_string[0])\n print '\\n'.join([header_string[0], separator])\n\n if target_param is None:\n param_list = range(len(x))\n else:\n param_list = self.grep_param_names(target_param)\n\n for i in param_list:\n xx = x.copy()\n xx[i] += step\n f1, g1 = self.objective_and_gradients(xx)\n xx[i] -= 2.*step\n f2, g2 = self.objective_and_gradients(xx)\n gradient = self.objective_function_gradients(x)[i]\n\n numerical_gradient = (f1-f2)/(2*step)\n ratio = (f1-f2)/(2*step*gradient)\n difference = np.abs((f1-f2)/2/step - gradient)\n\n if (np.abs(ratio-1)<tolerance):\n formatted_name = \"\\033[92m {0} \\033[0m\".format(names[i])\n else:\n formatted_name = \"\\033[91m {0} \\033[0m\".format(names[i])\n r = '%.6f' % float(ratio)\n d = '%.6f' % float(difference)\n g = '%.6f' % gradient\n ng = '%.6f' % float(numerical_gradient)\n grad_string = \"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\".format(formatted_name,r,d,g, ng, c0 = cols[0]+9, c1 = cols[1], c2 = cols[2], c3 = cols[3], c4 = cols[4])\n print grad_string","def __call__(self, parameters) -> ValueEstimate:\n # Encode params to json string\n save_circuit_template_params(parameters, \"current_optimization_params.json\")\n with open(\"current_optimization_params.json\", \"r\") as f:\n current_params_string = f.read()\n\n # POST params to proxy\n evaluation_id = self.client.post_argument_values(current_params_string)\n\n # POST status to EVALUATING\n self.client.post_status(\"EVALUATING\")\n\n # WAIT for status to be OPTIMIZING\n while self.client.get_status() != \"OPTIMIZING\":\n time.sleep(1)\n\n # GET cost function evaluation from proxy\n evaluation_string = self.client.get_evaluation_result(evaluation_id)\n value_estimate = load_value_estimate(io.StringIO(evaluation_string))\n\n return value_estimate","def optimizing(theta, data = data, target = target):\n # num = (sin(individual[0] - individual[1] / 8))**2 + (sin(individual[1] + individual[0] / 8))**2\n # denum = ((individual[0] - 8.6998)**2 + (individual[1] - 6.7665)**2)**0.5 + 1\n learner = MLPClassifier(hidden_layer_sizes=theta[0], learning_rate_init=theta[1], alpha=theta[2], verbose=True, early_stopping=True, n_iter_no_change=6)\n\n model = learner.fit(data, target)\n return model.best_loss_ # return the best error/residual (best error is cloes to zero) The error of a model is the difference between your predicted outcome and the real observed outcome and therefore 0 is desired\n\n # individual as a factor containing x, y = to tetha which ","def compute_optimalReward(task):\n\n\tT = 15.0\n\tweights = 0\n\tif task == TABLE_TASK or task == COFFEE_TASK:\n\t\tweights = 1\n\telif task == LAPTOP_TASK:\n\t\tweights = 10\n\n\t# initialize start/goal based on task \n\tif task == COFFEE_TASK or task == HUMAN_TASK:\n\t\tpick = pick_shelf\n\telse:\n\t\tpick = pick_basic\n\n\tif task == LAPTOP_TASK:\n\t\tplace = place_higher\n\telse:\n\t\tplace = place_lower\n\t\t\n\tstartRad = np.array(pick)*(math.pi/180.0)\n\tgoalRad = np.array(place)*(math.pi/180.0)\n\tstart = startRad\n\tgoal = goalRad\n\n\tplan = Planner(task)\t\n\tfilename = None\n\tif task == 1:\n\t\tfilename = \"task1.csv\"\n\telif task == 2:\n\t\tfilename = \"task2.csv\"\n\telif task == 3:\n\t\tfilename = \"task3.csv\"\n\t\t\n\t# get optimal waypts from file\n\twaypts = get_opt_waypts(filename)\n\tr = plan.featurize(waypts)\n\tRvel = r[0]\n\tRfeat = np.sum(r[1])\n\n\tplan.kill_planner()\n\treturn (Rvel, Rfeat)","def get_calculator(self, mode, step=500, ftol=1e-3, FixAngles=False, eVperA=True, md_params={}):\n if eVperA: ftol *= 0.194469064593167E-01\n atom_types = set(self.struc.get_chemical_symbols())\n kwargs = make_Hamiltonian(self.skf_dir, atom_types, self.disp, self.kpts, use_omp=self.use_omp)\n \n if mode in ['relax', 'vc-relax']:\n #kwargs['Driver_'] = 'ConjugateGradient'\n kwargs['Driver_'] = 'GeometryOptimization'\n kwargs['Driver_Optimizer'] = 'FIRE {}'\n #kwargs['Driver_MaxForceComponent'] = ftol\n kwargs['Driver_MaxSteps'] = step\n kwargs['Driver_OutputPrefix'] = self.prefix\n kwargs['Driver_Convergence_'] = ''\n kwargs['Driver_Convergence_GradElem'] = ftol\n \n if mode == 'vc-relax':\n kwargs['Driver_MovedAtoms'] = \"1:-1\"\n kwargs['Driver_LatticeOpt'] = \"Yes\"\n if FixAngles:\n kwargs['Driver_FixAngles'] = \"Yes\"\n\n elif mode in ['nve', 'nvt', 'npt']:\n # 1fs = 41.3 au\n # 1000K = 0.0031668 au\n dicts = {\n 'temperature': 300,\n 'pressure': 1e+5, #1atm\n 'timestep': 1,\n 'Thermostat': 'NoseHoover',\n 'MDRestartFrequency': 1000,\n 'band': 'No',\n }\n dicts.update(md_params)\n\n kwargs['Analysis_WriteBandOut'] = dicts['band']\n kwargs['Driver_'] = 'VelocityVerlet'\n kwargs['Driver_Steps'] = step\n kwargs['Driver_TimeStep [fs]'] = dicts['timestep']\n kwargs['Driver_MDRestartFrequency'] = dicts['MDRestartFrequency']\n kwargs['Driver_MovedAtoms'] = \"1:-1\"\n kwargs['Driver_OutputPrefix'] = self.prefix\n\n if mode in ['nvt', 'npt']:\n kwargs['Driver_Thermostat_'] = dicts['Thermostat']\n kwargs['Driver_Thermostat_Temperature [Kelvin]'] = dicts['temperature']\n kwargs['Driver_Thermostat_CouplingStrength [cm^-1]'] = 3200\n\n if mode == 'npt':\n kwargs['Driver_Barostat_'] = ''\n kwargs['Driver_Barostat_Pressure [Pa]'] = dicts['pressure']\n kwargs['Driver_Barostat_Timescale [ps]'] = 0.1\n\n \n calc = Dftb(label=self.label,\n #run_manyDftb_steps=True,\n atoms=self.struc,\n kpts=self.kpts,\n **kwargs,\n )\n return calc","def fit(self, X, y, weights=None, idx=0, verbose=False, early_stop=None, split=None):\n\n start_time = timer()\n self.idx = idx\n self.split = split\n\n # Display Optuna trial messages\n if not verbose:\n optuna.logging.set_verbosity(optuna.logging.ERROR)\n\n # Single objective optimization\n if split is None:\n\n # Create optuna study maximizing correlation\n self.study = optuna.create_study(direction='maximize', study_name=self.function)\n\n # Set required early stopping variables\n self.study.early_stop = early_stop\n self.study.early_stop_count = 0\n self.study.best_score = None\n\n # Start optimization trial\n try:\n self.study.optimize(lambda trial: _objective(self, trial, X, y, weights),\n n_trials=self.n_trials, callbacks=[_single_early_stopping_opt])\n\n # Early stopping (not officially supported by Optuna)\n except optuna.exceptions.OptunaError:\n pass\n\n # Keep only results of best trial for prune and reporting\n self.res_y = self.res_y[self.study.best_trial.number]\n self.res_y.name = col_name(self.function, self.study.best_trial.params)\n self.res_y_corr = self.res_y_corr[self.study.best_trial.number]\n\n # Multi objective optimization\n else:\n\n # Create study to maximize eash split\n sampler = optuna.samplers.NSGAIISampler()\n self.study = optuna.create_study(directions=(len(split)-1) * ['maximize'], sampler=sampler,\n study_name=self.function)\n\n # Early stopping variables\n self.study.early_stop = early_stop\n self.study.early_stop_count = 0\n\n # Custom best trial variables (Optuna \"best\" are immutable)\n self.study.top_trial = 0\n self.study.top_params = None\n self.study.top_value = None\n\n # Start optimization trial\n try:\n self.study.optimize(lambda trial: _objective(self, trial, X, y, weights, split),\n n_trials=self.n_trials, callbacks=[_multi_early_stopping_opt])\n\n # Early stopping (not officially supported by Optuna)\n except optuna.exceptions.OptunaError:\n pass\n\n # Validation checks\n if np.mean(self.study.trials[self.study.top_trial].values) != self.study.top_value:\n raise RuntimeError(\"Top trial score invalid\")\n if len(self.res_y) != len(self.study.trials) or len(self.res_y) != len(self.res_y_corr):\n raise RuntimeError(\"Total results does not equal trials\")\n\n # Keep only results of best trial for prune and reporting\n self.res_y = self.res_y[self.study.top_trial]\n self.res_y.name = col_name(self.function, self.study.trials[self.study.top_trial].params)\n self.res_y_corr = self.res_y_corr[self.study.top_trial]\n\n end_time = timer()\n self.time = round(end_time - start_time, 2)\n\n return self","def do_optimisation(self):\n\n print('--> Parameters for optimisation:')\n print('--> Using measurements : {}'.format(self.stoma_cfg.comparison_helper.optimisation_keys))\n print('')\n\n x0 = self.initial_guess()\n\n tol, eps = 1e-4, 0.001\n\n print('--> Using SLSQP with tol={} and eps={}'.format(tol, eps))\n\n soln = opt.minimize(fun=self.optimise_fn,\n x0=x0,\n method='SLSQP',\n tol=tol,\n options={'eps': eps})\n\n print('*' * 120)\n print('--> Optimisation procedure has finished...')\n print(soln)\n print('*' * 120)\n\n if soln.success:\n print('--> Optimisation succeeded. Result is...')\n self._set_material_parameters(soln.x)\n print('--> {}'.format(self.material_model))\n else:\n print('--> The optimisation failed!')\n\n print('*' * 120)\n\n return soln","def __init__(self, direction, max_momentum, current_momentum=None, max_speed=2, current_speed=0, rowing=False):\n self.direction = direction\n self.max_momentum = max_momentum\n if current_momentum is None:\n self.current_momentum = self.max_momentum\n else:\n self.current_momentum = current_momentum\n self.max_speed = max_speed\n self.current_speed = current_speed\n self.rowing = rowing","def quality_control(self, method = \"mv\", **kwargs):\n input_col = \"result\"\n if input_col not in self.cols:\n raise Exception(\"There is no result for quality control. \"\n \"Pease call get_result() to get results first.\")\n\n output_col = None\n if method == \"mv\":\n output_col = \"mv\"\n self.data[output_col] = self.__mv_col(self.data[input_col], **kwargs)\n elif method == \"em\":\n output_col = \"em\"\n self.data[output_col] = self.__em_col(self.data[input_col], **kwargs)\n\n if output_col == None:\n raise Exception(str(method)+\" is not a valid input.\")\n\n if output_col not in self.cols:\n self.cols.append(output_col)\n\n return self","def optimal_max(board):\n # Board full?\n if terminal(board):\n return [None, utility(board)]\n\n available_actions = list(actions(board))\n\n # Naive baseline comparison is negative infinity\n global_optimum = [None, -math.inf]\n\n # For each move, what would opponent do next? Update best move.\n for action in available_actions:\n # Anticipates optimal adversarial moves\n local_optimum = optimal_min(result(board, action))\n\n # Compares local vs global optima\n if global_optimum[1] <= local_optimum[1]:\n global_optimum = [action, local_optimum[1]]\n\n return global_optimum","def __max_step(self, batch):\n\n # short hand and optimizer\n policy = self.mc.get('policy', target=False)\n policy_parameters = list(policy.parameters())\n opt_outer = optim.Adam(policy_parameters, lr=self.outer_lr)\n\n # optimize\n opt_outer.zero_grad()\n obj = -self.obj(batch)\n obj.backward()\n opt_outer.step()","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n \n def miniMaxAgent(state, depth, agentIndex):\n \n #return evaluation function if game is won or lost or the depth is reached\n if state.isLose() or state.isWin() or depth == self.depth:\n return self.evaluationFunction(state)\n \n #if agent index is 0 that is pacman so get the maximum value\n if agentIndex == 0:\n maximum = float(\"-inf\")\n actions = state.getLegalActions(agentIndex) #pacmans legal actions\n \n #get successor from all actions and set maximum as the largest value found\n for action in actions:\n successor = state.generateSuccessor(agentIndex, action)\n maximum = max(maximum, miniMaxAgent(successor, depth, 1)) #pass agent index as 1 to move onto the ghosts (min)\n \n return maximum\n \n #if agent index is greater than 0 it is a ghost so get the minimum value\n else:\n minimum = float(\"inf\")\n actions = state.getLegalActions(agentIndex)\n \n #get successor from all actions and set the minimum to the smallest value found\n for action in actions:\n successor = state.generateSuccessor(agentIndex, action) #ghosts legal actions\n \n #if all ghosts have found a min, increase depth and set agent back to pacman (max)\n if state.getNumAgents() -1 == agentIndex:\n minimum = min(minimum, miniMaxAgent(successor, depth + 1, 0))\n \n #increase agent index to get the next ghost\n else:\n minimum = min(minimum, miniMaxAgent(successor, depth, agentIndex + 1))\n return minimum\n \n score = float(\"-inf\")\n direction = None\n \n #get all the legal actions in the game state\n legalActions = gameState.getLegalActions()\n \n #get successor from each action in the game\n for action in legalActions:\n successor = gameState.generateSuccessor(0, action)\n \n #start at depth 0 and agent index 1\n value = miniMaxAgent(successor, 0, 1)\n \n #find the largest value and set direction to the action that returned that value\n if score < value:\n score = value\n direction = action\n \n return direction\n util.raiseNotDefined()","def minimax(self, game, depth):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n\n \"\"\"\n From AIMA psuedocode:\n\n function MINIMAX-DECISION(state) returns an action\n return arg max a is in ACTIONS(s) MIN-VALUE(RESULT(state, a))\n \"\"\"\n\n best_move = (-1,-1)\n best_score = float(\"-inf\")\n actions = game.get_legal_moves()\n\n if not actions:\n return best_move\n else:\n best_move = actions[randint(0, len(actions) - 1)]\n\n try:\n # The try/except block will automatically catch the exception\n # raised when the timer is about to expire.\n # return max(actions, key=lambda action: self._min_value(game.forecast_move(action), 1))\n for action in actions:\n score = self._min_value(game.forecast_move(action), 1)\n if score > best_score:\n best_score = score\n best_move = action\n\n except SearchTimeout:\n pass\n\n return best_move","def optimization_step(self):\n \n if \"CSS\" in self.algorithm:\n \n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\n \n var_list = [self.x_tilda, self.minibatch_set]\n \n if (self.num_samples > 0) and (not self.mixture):\n \n if ((self.mf_steps > 0) and self.alpha >0) or\\\n self.gibbs_steps > 0: \n \n var_list.append(self.sampler_theta)\n \n elif \"CD\" in self.algorithm:\n \n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \n \n var_list = [self.minibatch_set]\n \n var_list.append(self.learning_rate)\n \n if self.use_momentum:\n \n var_list.append(self.momentum)\n \n output_vars = [self.pseudo_cost]\n \n if self.report_p_tilda:\n \n output_vars.append(self.p_tilda)\n \n else:\n \n output_vars.append(theano.shared(0))\n \n opt_step = theano.function(inputs = var_list,\n outputs = output_vars,\n updates = self.updates,\n givens = input_dict,\n on_unused_input='warn')\n \n return opt_step","def optimize(opt, target, n_agents, n_variables, n_iterations, lb, ub, hyperparams):\n\n # Creating the SearchSpace\n space = SearchSpace(n_agents=n_agents, n_variables=n_variables,\n n_iterations=n_iterations, lower_bound=lb, upper_bound=ub)\n\n # Creating the Function\n function = Function(pointer=target)\n\n # Creating Optimizer\n if opt.__name__ is not 'BH':\n optimizer = opt(hyperparams=hyperparams)\n else:\n optimizer = opt()\n\n # Creating the optimization task\n task = Opytimizer(space=space, optimizer=optimizer, function=function)\n\n return task.start(store_best_only=True)","def minimize(fun, \n bounds = None, \n value_limit = math.inf,\n num_retries = 1000,\n logger = None,\n workers = mp.cpu_count(),\n popsize = 31, \n max_evaluations = 50000, \n capacity = 500,\n stop_fittness = None,\n optimizer = None,\n ):\n\n if optimizer is None:\n optimizer = de_cma(max_evaluations, popsize, stop_fittness) \n store = Store(bounds, capacity = capacity, logger = logger)\n return retry(fun, store, optimizer.minimize, num_retries, value_limit, workers)","def optimize(\n self, n, tol=None, jac=True, hessp=False, optlib=\"scipy\", **options\n ):\n return {\"scipy\": self.optimize_scipy, \"nlopt\": self.optimize_nlopt,}[\n optlib\n ](n=n, tol=tol, jac=jac, hessp=hessp, **options)","def optimize(maxiter: int = 1000,\n tol = None,\n save_steps: int = 1,\n c0: float = 0.62,\n c1: float = 0.1,\n c2: float = 0.602,\n c3: float = 0.101,\n c4: float = 0):\n _spsa_vars = [c0, c1, c2, c3, c4]\n theta = self.vectorizer.vector\n nb_params = len(theta)\n use_exact_grads = 'grads' in self._method\n \n if save_steps:\n theta_vec = [theta]\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\n \n \n pbar = tqdm(total=maxiter, disable=not self.progbar)\n def callback(_):\n pbar.clear()\n pbar.update()\n val = round(self.loss, 5)\n pbar.set_description(str(val))\n\n if self.loss_target is not None:\n if self.loss < self.loss_target:\n # returning True doesn't terminate optimization\n pbar.close()\n raise KeyboardInterrupt\n \n for ii in range(maxiter):\n \n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\n delta = 2 * randint(0, 2, size=nb_params) - 1\n # plus and minus directions\n \n if use_exact_grads:\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\n else:\n theta_plus = theta + c_spsa * delta\n theta_minus = theta - c_spsa * delta\n\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\n # derivative estimate\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\n # updated theta\n theta = theta - a_spsa * g_spsa\n \n callback(ii)\n \n if tol is not None:\n if (cost_plus + cost_minus)/2 < tol:\n pbar.close()\n break\n \n if save_steps:\n theta_vec.append(theta)\n cost_vec.append(cost_plus/2+cost_minus/2)\n \n \n result_dict = {'hyper_parameters':_spsa_vars,\n 'maxiter':maxiter,\n 'theta_opt':theta,\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\n if save_steps:\n result_dict['theta_history'] = theta_vec\n result_dict['cost_history'] = cost_vec\n self.result_dict = result_dict\n pbar.close()\n\n return self.inject_res_vector_and_return_tn()","def hyperopt_fmin(\n fn,\n space,\n algo,\n max_evals=sys.maxsize,\n timeout=None,\n loss_threshold=None,\n trials=None,\n rstate=None,\n allow_trials_fmin=True,\n pass_expr_memo_ctrl=None,\n catch_eval_exceptions=False,\n verbose=True,\n return_argmin=True,\n points_to_evaluate=None,\n max_queue_len=1,\n show_progressbar=True,\n # early_stop_fn=None,\n):\n if rstate is None:\n env_rseed = os.environ.get(\"HYPEROPT_FMIN_SEED\", \"\")\n if env_rseed:\n rstate = np.random.RandomState(int(env_rseed))\n else:\n rstate = np.random.RandomState()\n\n validate_timeout(timeout)\n validate_loss_threshold(loss_threshold)\n\n if allow_trials_fmin and hasattr(trials, \"fmin\"):\n assert False\n # return trials.fmin(\n # fn,\n # space,\n # algo=algo,\n # max_evals=max_evals,\n # timeout=timeout,\n # loss_threshold=loss_threshold,\n # max_queue_len=max_queue_len,\n # rstate=rstate,\n # pass_expr_memo_ctrl=pass_expr_memo_ctrl,\n # verbose=verbose,\n # catch_eval_exceptions=catch_eval_exceptions,\n # return_argmin=return_argmin,\n # show_progressbar=show_progressbar,\n # early_stop_fn=early_stop_fn,\n # )\n\n if trials is None:\n if points_to_evaluate is None:\n trials = base.Trials()\n else:\n assert type(points_to_evaluate) == list\n trials = generate_trials_to_calculate(points_to_evaluate)\n\n domain = base.Domain(fn, space, pass_expr_memo_ctrl=pass_expr_memo_ctrl)\n\n rval = FMinIter(\n algo,\n domain,\n trials,\n max_evals=max_evals,\n timeout=timeout,\n loss_threshold=loss_threshold,\n rstate=rstate,\n verbose=verbose,\n max_queue_len=max_queue_len,\n show_progressbar=show_progressbar,\n # early_stop_fn=early_stop_fn,\n )\n rval.catch_eval_exceptions = catch_eval_exceptions\n\n # next line is where the fmin is actually executed\n rval.exhaust()\n\n if len(trials.trials) == 0:\n raise Exception(\n \"There are no evaluation tasks, cannot return argmin of task losses.\"\n )\n return trials","def optimize(self, args):\n\n ############################\n # Get the data\n ############################\n\n # Read the CSV file ignoring the header and the first column (which\n # contains the file name of the image used for extracting the data in\n # a row)\n try:\n data = np.genfromtxt(args.featuresFile, delimiter=',',\n skip_header=1)\n data = data[:, 1:]\n except:\n print('Could not read CSV file: {}'.format(args.featuresFile))\n return -1\n\n x = data[:, :-1]\n y = np.squeeze(data[:, -1:])\n\n ############################\n # Execute the optimization\n ############################\n\n tunningParams = [\n {\n 'kernel': ['linear'],\n 'C': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3]\n },\n {\n 'kernel': ['rbf'],\n 'gamma': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3],\n 'C': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3]\n },\n ]\n\n scores = ['precision', 'recall']\n\n for score in scores:\n print('# Tuning hyper-parameters for {}\\n'.format(score))\n\n clf = GridSearchCV(svm.SVC(C=1), tunningParams, cv=5,\n scoring=format('{}_macro'.format(score)))\n clf.fit(x, y)\n\n print('Best parameters set found on development set:\\n')\n print(clf.best_params_)\n\n print('\\nGrid scores on development set:\\n')\n means = clf.cv_results_['mean_test_score']\n stds = clf.cv_results_['std_test_score']\n for mean, std, params in zip(means, stds, clf.cv_results_['params']):\n print('{:.3f} (+/-{:.3f}) for {}'.format(mean, std * 2, params))\n\n #print('\\nDetailed classification report:\\n')\n #print('The model is trained on the full development set.')\n #print('The scores are computed on the full evaluation set.\\n')\n #y_true, y_pred = y_test, clf.predict(X_test)\n #print(classification_report(y_true, y_pred))\n #print()\n\n return 0","def smooth_objective(self, x, mode='both', check_feasibility=False):\n\n x = self.apply_offset(x)\n if self.Q is None:\n if mode == 'both':\n f, g = self.scale(np.linalg.norm(x)**2) / 2., self.scale(x)\n return f, g\n elif mode == 'grad':\n f, g = None, self.scale(x)\n return g\n elif mode == 'func':\n f, g = self.scale(np.linalg.norm(x)**2) / 2., None\n return f\n else:\n raise ValueError(\"mode incorrectly specified\")\n else:\n if mode == 'both':\n f, g = self.scale(np.sum(x * self.Q_transform.linear_map(x))) / 2., self.scale(self.Q_transform.linear_map(x))\n return f, g\n elif mode == 'grad':\n f, g = None, self.scale(self.Q_transform.linear_map(x))\n return g\n elif mode == 'func':\n f, g = self.scale(np.sum(x * self.Q_transform.linear_map(x))) / 2., None\n return f\n else:\n raise ValueError(\"mode incorrectly specified\")","def _optimize(self, X, y, W, steps):\n\n X = X.flatten(1)\n\n min_x, max_x = X.min(), X.max()\n len_x = max_x - min_x\n \n bestd = 1\n bestp = min_x\n minerr = W.sum()\n\n if len_x > 0.0:\n for p in np.arange(min_x, max_x, len_x/steps):\n for d in [-1, 1]:\n gy = np.ones((y.size))\n gy[X*d < p*d] = -1\n err = np.sum((gy != y)*W)\n if err < minerr:\n minerr = err\n bestd = d\n bestp = p\n\n return minerr, bestd, bestp","def maximize_scalar(max_func, *args, **kwargs):\n def min_func(*args):\n return -max_func(*args)\n\n res = minimize_scalar(min_func, *args, **kwargs)\n\n # we have to negate the function value before returning res\n res.fun = -res.fun\n return res"],"string":"[\n \"def optimize_library_descent(self, target, direction='max', steps=100,\\n multiprocessing=False, ret_info=False,\\n args=None):\\n # get the target function to call\\n target_function = getattr(self, target)\\n if args is not None:\\n target_function = functools.partial(target_function, **args)\\n\\n # initialize the optimizer\\n value = target_function()\\n value_best, state_best = value, self.sens_mat.copy()\\n \\n if ret_info:\\n # store extra information\\n start_time = time.time()\\n info = {'values': {}}\\n values_count = self.parameters['optimizer_values_count']\\n values_step = max(1, steps // values_count)\\n \\n if multiprocessing:\\n # run the calculations in multiple processes\\n pool_size = self.get_number_of_cores()\\n pool = mp.Pool(processes=pool_size)\\n if ret_info:\\n values_step = max(1, values_step // pool_size)\\n \\n # iterate for given number of steps\\n for step in range(int(steps) // pool_size):\\n joblist = []\\n init_arguments = self.init_arguments\\n for _ in range(pool_size):\\n # modify the current state and add it to the job list\\n i = random.randrange(self.sens_mat.size)\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n params = init_arguments['parameters'] \\n params['sensitivity_matrix'] = self.sens_mat\\n params['initialize_state']['sensitivity'] = 'exact'\\n \\n joblist.append((copy.deepcopy(init_arguments), target))\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n # run all the jobs\\n results = pool.map(_run_job, joblist)\\n \\n # find the best result \\n if direction == 'max':\\n res_best = np.argmax(results)\\n if results[res_best] > value_best:\\n value_best = results[res_best]\\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\\n # use the best state as a basis for the next iteration\\n self.sens_mat = state_best\\n \\n elif direction == 'min':\\n res_best = np.argmin(results)\\n if results[res_best] < value_best:\\n value_best = results[res_best]\\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\\n # use the best state as a basis for the next iteration\\n self.sens_mat = state_best\\n \\n else:\\n raise ValueError('Unsupported direction `%s`' % direction)\\n \\n if ret_info and step % values_step == 0:\\n info['values'][step * pool_size] = results[res_best]\\n \\n else:\\n # run the calculations in this process\\n for step in range(int(steps)):\\n # modify the current state\\n i = random.randrange(self.sens_mat.size)\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n # get the value of the new state\\n value = target_function()\\n \\n improved = ((direction == 'max' and value > value_best) or\\n (direction == 'min' and value < value_best))\\n if improved:\\n # save the state as the new best value\\n value_best, state_best = value, self.sens_mat.copy()\\n else:\\n # undo last change\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n if ret_info and step % values_step == 0:\\n info['values'][step] = value_best\\n\\n # sort the best state and store it in the current object\\n state_best = self.sort_sensitivity_matrix(state_best)\\n self.sens_mat = state_best.copy()\\n\\n if ret_info:\\n info['total_time'] = time.time() - start_time \\n info['states_considered'] = steps\\n info['performance'] = steps / info['total_time']\\n return value_best, state_best, info\\n else:\\n return value_best, state_best\",\n \"def optimize_library_anneal(self, target, direction='max', steps=100,\\n ret_info=False, args=None):\\n # lazy import\\n from .optimizer import ReceptorOptimizerAnnealer # @UnresolvedImport\\n \\n # prepare the class that manages the simulated annealing\\n annealer = ReceptorOptimizerAnnealer(self, target, direction, args,\\n ret_info=ret_info)\\n annealer.steps = int(steps)\\n annealer.Tmax = self.parameters['anneal_Tmax']\\n annealer.Tmin = self.parameters['anneal_Tmin']\\n if self.parameters['verbosity'] == 0:\\n annealer.updates = 0\\n\\n # do the optimization\\n MI, state = annealer.optimize()\\n\\n # sort the best state and store it in the current object\\n state = self.sort_sensitivity_matrix(state)\\n self.sens_mat = state.copy()\\n \\n if ret_info:\\n return MI, state, annealer.info\\n else:\\n return MI, state\",\n \"def optimize_library_descent_multiple(self, target, direction='max',\\n trials=4, multiprocessing=False,\\n ret_error=False, **kwargs):\\n \\n # pass some parameters down to the optimization function to call\\n kwargs['target'] = target\\n kwargs['direction'] = direction\\n \\n # initialize the list of jobs with an optimization job starting from the\\n # current interaction matrix\\n joblist = [(self.init_arguments, 'optimize_library_descent', kwargs)]\\n sens_mat = self.sens_mat #< store matrix to restore it later\\n\\n # set the ensemble of sensitivity matrices to try\\n self.choose_sensitivity_matrix(density='auto')\\n self.parameters['initialize_state']['sensitivity'] = 'ensemble'\\n\\n # add additional jobs with random initial interaction matrices\\n init_arguments = self.init_arguments\\n for _ in range(trials - 1):\\n joblist.append((copy.deepcopy(init_arguments),\\n 'optimize_library_descent', kwargs))\\n \\n # restore interaction matrix of this object\\n self.sens_mat = sens_mat\\n \\n if multiprocessing:\\n # calculate all results in parallel\\n pool = mp.Pool(processes=self.get_number_of_cores())\\n result_iter = pool.imap_unordered(_run_job, joblist)\\n \\n else:\\n # create a generator over which we iterate later\\n result_iter = (_run_job(job) for job in joblist)\\n \\n # find the best result by iterating over all results\\n result_best, values = None, []\\n for result in result_iter:\\n values.append(result[0])\\n # check whether this run improved the result\\n if result_best is None:\\n result_best = result\\n elif ((direction == 'max' and result[0] > result_best[0]) or\\n (direction == 'min' and result[0] < result_best[0])):\\n result_best = result\\n \\n # sort the best state and store it in the current object\\n state = self.sort_sensitivity_matrix(result_best[1])\\n self.sens_mat = state.copy()\\n\\n if ret_error:\\n # replace the best value by a tuple of the best value and its error\\n value_best = result_best[0]\\n value_err = np.abs(value_best - np.median(values))\\n result_best = ((value_best, value_err), ) + result_best[1:]\\n return result_best\",\n \"def Optimise(LogLikelihood,par,func_args,fixed=None,type='max',method='NM',maxiter=10000, maxfun=10000, verbose=True):\\n \\n if fixed==None:\\n var_par = np.copy(par)\\n #otherwise construct the parameter vector from var_par and fixed_par_val\\n else:\\n par = np.array(par)\\n fixed = np.array(fixed) #ensure fixed is a np array\\n #assign parameters to normal param vector\\n fixed_par = par[np.where(fixed==True)]\\n var_par = par[np.where(fixed!=True)]\\n \\n #set the algorithm to use - CG and P not working (at least not well)\\n add_kwords = {'verbose':verbose}\\n if method == 'NM':\\n Algorithm = NelderMead\\n add_kwords = {'maxiter':maxiter, 'maxfun':maxfun,'verbose':verbose}\\n elif method == 'CG':\\n print \\\"warning: CG method didn't work properly during testing\\\"\\n Algorithm = ConjugateGradient\\n elif method == 'P':\\n print \\\"warning: Powell algorithm didn't work properly during testing\\\"\\n Algorithm = Powell\\n else:\\n print \\\"error: optimisation function not found\\\"\\n return par\\n \\n #set the optimisation function to pos or neg for the fmin funcitons\\n if type == 'max': OptFunc = NegFixedPar_func\\n elif type == 'min': OptFunc = FixedPar_func\\n else:\\n print \\\"error: %s not a valid option\\\" % type\\n return par\\n \\n #call the optimser with the appropriate function\\n fitted_par = Algorithm(OptFunc, var_par, (LogLikelihood,func_args,fixed,fixed_par), \\\\\\n **add_kwords)\\n \\n #now return the params in the correct order...\\n if fixed==None:\\n return_par = fitted_par\\n else:\\n return_par = np.copy(par) \\n return_par[np.where(fixed!=True)] = fitted_par\\n \\n return return_par\",\n \"def maximize(self,x0,method='fmin',**kwargs):\\n return self._optimize(x0,'max',method,**kwargs)\",\n \"def produce_max(self, *args, **kwargs):\\n raise NotImplementedError('This interaction has no produce_max method yet!')\",\n \"def opt_wrapper(m, **kwargs):\\r\\n m.optimize(**kwargs)\\r\\n return m.optimization_runs[-1]\",\n \"def opt_wrapper(m, **kwargs):\\n m.optimize(**kwargs)\\n return m.optimization_runs[-1]\",\n \"def Optimization(*args, **kwargs):\\n from warnings import warn\\n\\n warn(\\n \\\"Optimization has been renamed to OptimizationResult and will be removed as soon as v0.13.0\\\", DeprecationWarning\\n )\\n return OptimizationResult(*args, **kwargs)\",\n \"def getMaximum(self, arguments, maximum):\\n\\n self.sequence.append({\\\"type\\\": \\\"findingMaximum\\\", \\\"coords\\\": arguments})\\n\\n self.sequence.append({\\\"type\\\": \\\"foundMaximum\\\", \\\"coord\\\": maximum})\",\n \"def __call__(self, origin, state, **kwargs):\\n fun = kwargs['function']\\n d = state['direction']/np.linalg.norm(state['direction'])\\n # filter directions that are too large\\n if self.filter:\\n ndabs_log = -np.log10(np.abs(d))\\n mean_log = np.mean(ndabs_log)\\n #print \\\"\\\\n ** MEAN =\\\", mean_log\\n direction = (ndabs_log > mean_log-1.5).astype(int)*d\\n else:\\n direction = d\\n state['direction'] = direction\\n## for pos, d in enumerate(direction):\\n## use_dir = self.use_dirs[pos]\\n## if use_dir * d < 0:\\n## # directions don't match so don't move in this direction\\n## direction[pos] = 0\\n maxStepSize = self.maxStepSize\\n if np.isscalar(maxStepSize):\\n stepSize = maxStepSize\\n else:\\n stepfacs = np.zeros(self.dim)\\n for d in range(self.dim):\\n # explicit loop so as to catch any ZeroDivisionErrors\\n try:\\n stepfacs[d] = abs(maxStepSize[d] / direction[d])\\n except ZeroDivisionError:\\n # Direction is orthogonal to this parameter direction,\\n # so ensure won't choose this as the minimum step size\\n stepfacs[d] = Inf\\n # Stop stepping with giant sizes if direction vector has strong\\n # separation of scales\\n stepSize = min(stepfacs)\\n# print \\\"direction = \\\", direction\\n# print \\\"step = \\\", step\\n i = 1\\n old_value = state['old_value']\\n not_done = True\\n# print \\\"** TEMP: Hardwiring step size to be 0.0005\\\"\\n# stepSize = 0.0005\\n init_step = stepSize\\n while not_done:\\n print(\\\"\\\\nLinestep: i =\\\", i, \\\"step size =\\\", stepSize, \\\"direction =\\\\n\\\", end='')\\n print(direction)\\n p = origin + i * stepSize * direction\\n print(\\\"Testing p = \\\", p)\\n new_value = fun(p)\\n if new_value < old_value:\\n i += 1\\n old_value = new_value\\n else:\\n if i == 1:\\n # don't shrink step size to be less than 1/maxReduceFac of initial\\n if stepSize*self.maxReduceFac < init_step:\\n not_done = False\\n p = origin + (i-1) * stepSize * direction\\n else:\\n stepSize /= self.stepMod\\n else:\\n # had found a working step but it's no longer stepping to lower residuals\\n not_done = False\\n p = origin + (i-1) * stepSize * direction\\n state['alpha_step'] = stepSize\\n return p\",\n \"def max_(*args, **kwargs):\\n ...\",\n \"def optimize(self):\\n \\n if self.verbose:\\n print('Starting grid search with bounds: [' + \\\\\\n ';'.join(['%5g to %5g']*len(self.steps))%tuple([(self.steps[i][0], self.steps[i][-1]) for i in range(len(self.steps))]) +']')\\n\\n for params in self._get_next_point():\\n self.transform.set_params(params)\\n\\n v, _ = self.measure.value_and_derivatives(self.transform)\\n\\n if v < self.best_value:\\n self.best_value = v\\n self.best_params = params\\n# print('New best value %2.4f at ('%v, ', '.join(['%8.3f']*len(params))%tuple(params), ')')\\n\\n self.value_history.append(v)\\n self.last_value = v\\n self.iteration += 1\\n\\n if self.report_freq > 0 and (self.iteration % self.report_freq == 0) and self.report_func is not None:\\n self.report_func(self)\\n\\n # Set the best transform\\n self.transform.set_params(self.best_params)\\n self.last_value = self.best_value\\n return self.best_value\",\n \"def maximum(x, y):\\r\\n # see decorator for function body\\r\",\n \"def MAXED(N, sigma2, R, f_def, params):\\n\\n # pull out algorithm-specific parameters\\n Omega = params['Omega']\\n\\n # create the function that we will maximize, Z\\n def Z(lam, N, sigma2, R, f_def, Omega):\\n \\\"\\\"\\\"A function, the maximization of which is equivalent to the\\n maximization of \\\"\\\"\\\"\\n\\n A = - np.sum(f_def * np.exp(- np.sum((lam * R.T).T, axis=0)))\\n B = - (Omega * np.sum(lam**2 * sigma2))**(0.5)\\n C = - np.sum(N * lam)\\n\\n # negate because it's a minimization\\n return - (A + B + C)\\n\\n # create a lambda\\n lam = np.ones(len(N))\\n\\n # apply the simulated annealing to the Z\\n mk = {'args': (N, sigma2, R, f_def, Omega)}\\n lam = basinhopping(Z, lam, minimizer_kwargs=mk).x\\n\\n # back out the spectrum values from the lam\\n return f_def * np.exp(-np.sum((lam * R.T).T, axis=0))\",\n \"def _optimize(self,x0,type,method,**kwargs):\\n from scipy.optimize import fmin,fmin_powell\\n\\n if type == 'min':\\n g=lambda x:self(x)\\n elif type == 'max':\\n g=lambda xs:-1*self(x)\\n elif type == 'root':\\n g=lambda x:np.abs(self(x))\\n elif type == 'val':\\n val = kwargs.pop('valtofind')\\n g=lambda x:np.abs(self(x)-val)\\n elif type == 'saddle':\\n raise NotImplementedError\\n else:\\n raise ValueError('Unrecognized optimization type')\\n\\n if method == 'fmin':\\n res = fmin(g,x0,**kwargs)\\n elif method == 'fmin_powell':\\n res = fmin_powell(g,x0,**kwargs)\\n else:\\n raise ValueError('Unrecognized method')\\n\\n self.lastOpt = res\\n return res[0]\",\n \"def process_solve_kwargs(**kwargs):\\n\\n tol = kwargs.get('tol', DEFAULT_TOL)\\n maxiter = kwargs.get('maxiter', MAX_ITER)\\n Ainv = kwargs.get('Ainv', None)\\n verbose = kwargs.get('verbose', False)\\n\\n if VERBOSE:\\n print(\\\"tol:\\\", tol)\\n print(\\\"maxiter:\\\", maxiter)\\n print(\\\"Ainv:\\\", Ainv)\\n\\n return tol, int(maxiter), Ainv, verbose\",\n \"def expectimax_move(game, method='score'):\\n\\n if method == 'score':\\n def val(g):\\n return g[1]\\n elif method == 'empty':\\n val = empty_squares\\n elif method == 'gradient':\\n val = gradient_value\\n else:\\n print('Invalid method given to expectimax function')\\n exit(1)\\n\\n _, move = expectimax(game, 2, val)\\n return move\",\n \"def best_metric(\\n self, return_step: bool = False\\n ) -> Union[\\n None,\\n float,\\n Tuple[float, int],\\n Tuple[None, None],\\n Dict[str, Union[float, None]],\\n Tuple[Dict[str, Union[float, None]], Dict[str, Union[int, None]]],\\n ]:\\n res = self.compute_all()\\n if isinstance(res, list):\\n rank_zero_warn(\\n \\\"Encounted nested structure. You are probably using a metric collection inside a metric collection, or\\\"\\n \\\" a metric wrapper inside a metric collection, which is not supported by `.best_metric()` method.\\\"\\n \\\"Returning `None` instead. Please consider \\\"\\n )\\n if return_step:\\n return None, None\\n return None\\n\\n if isinstance(self._base_metric, Metric):\\n fn = torch.max if self.maximize else torch.min\\n try:\\n value, idx = fn(res, 0)\\n if return_step:\\n return value.item(), idx.item()\\n return value.item()\\n except (ValueError, RuntimeError) as error:\\n rank_zero_warn(\\n f\\\"Encountered the following error when trying to get the best metric: {error}\\\"\\n \\\"this is probably due to the 'best' not being defined for this metric.\\\"\\n \\\"Returning `None` instead.\\\",\\n UserWarning,\\n )\\n if return_step:\\n return None, None\\n return None\\n\\n else: # this is a metric collection\\n maximize = self.maximize if isinstance(self.maximize, list) else len(res) * [self.maximize]\\n value, idx = {}, {}\\n for i, (k, v) in enumerate(res.items()):\\n try:\\n fn = torch.max if maximize[i] else torch.min\\n out = fn(v, 0)\\n value[k], idx[k] = out[0].item(), out[1].item()\\n except (ValueError, RuntimeError) as error: # noqa: PERF203 # todo\\n rank_zero_warn(\\n f\\\"Encountered the following error when trying to get the best metric for metric {k}:\\\"\\n f\\\"{error} this is probably due to the 'best' not being defined for this metric.\\\"\\n \\\"Returning `None` instead.\\\",\\n UserWarning,\\n )\\n value[k], idx[k] = None, None\\n\\n if return_step:\\n return value, idx\\n return value\",\n \"def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\\n return x_best, -y_best\",\n \"def run_migrad(self, fitarg, **kwargs):\\n self.fitarg = fitarg\\n kwargs['up'] = 1.\\n\\n\\n logging.debug(self._par_names)\\n logging.debug(self.__wrap_likelihood(list(fitarg['pinit'].values())))\\n\\n if kwargs['scipy']:\\n self._res = op.minimize(self.__wrap_likelihood,\\n list(fitarg['pinit'].values()),\\n bounds=list(fitarg['limits'].values()),\\n method='TNC',\\n #method='Powell',\\n options={'maxiter': kwargs['ncall']} #'xtol': 1e-20, 'eps' : 1e-20, 'disp': True}\\n #tol=None, callback=None,\\n #options={'disp': False, 'minfev': 0, 'scale': None,\\n #'rescale': -1, 'offset': None, 'gtol': -1,\\n #'eps': 1e-08, 'eta': -1, 'maxiter': kwargs['ncall'],\\n #'maxCGit': -1, 'mesg_num': None, 'ftol': -1, 'xtol': -1, 'stepmx': 0,\\n #'accuracy': 0}\\n )\\n logging.info(self._res)\\n for i, k in enumerate(self._par_names):\\n fitarg[k] = self._res.x[i]\\n\\n logging.debug(fitarg)\\n\\n cmd_string = \\\"lambda {0}: self.__calcLikelihood({0})\\\".format(\\n (\\\", \\\".join(self._par_names), \\\", \\\".join(self._par_names)))\\n\\n string_args = \\\", \\\".join(self._par_names)\\n global f # needs to be global for eval to find it\\n f = lambda *args: self.__calc_likelihood(*args)\\n\\n cmd_string = \\\"lambda %s: f(%s)\\\" % (string_args, string_args)\\n logging.debug(cmd_string)\\n\\n # work around so that the parameters get names for minuit\\n self._minimize_f = eval(cmd_string, globals(), locals())\\n self._minimize_f.errordef = minuit.Minuit.LEAST_SQUARES\\n\\n self._m = minuit.Minuit(self._minimize_f,\\n #list(fitarg['pinit'].values()),\\n **fitarg['pinit'],\\n #names=self._par_names\\n )\\n# print_level=kwargs['verbosity'],\\n# errordef=kwargs['up'],\\n# pedantic=kwargs['pedantic'],\\n #**fitarg)\\n\\n for p in self._par_names:\\n self._m.fixed[p] = fitarg['fix'][p]\\n self._m.limits[p] = fitarg['limits'][p]\\n self._m.errors[p] = fitarg['error'][p]\\n\\n self._m.tol = kwargs['tol']\\n self._m.strategy = kwargs['strategy']\\n\\n logging.debug(\\\"tol {0:.2e}, strategy: {1:n}\\\".format(\\n self._m.tol, self._m.strategy.strategy))\\n\\n self._m.migrad(ncall=kwargs['ncall']) #, precision = kwargs['precision'])\",\n \"def best_move(game, method='score'):\\n board, score = game\\n\\n if method == 'score':\\n def val(g):\\n return g[1]\\n elif method == 'empty':\\n val = empty_squares\\n elif method == 'gradient':\\n val = gradient_value\\n else:\\n print('Invalid method given to best_move function')\\n exit(1)\\n\\n if score < 10000:\\n depth = 4\\n elif score < 20000:\\n depth = 5\\n elif score < 30000:\\n depth = 7\\n else:\\n depth = 7\\n\\n moves = possible_moves(board)\\n\\n # dict with score for each move\\n move_score = dict(zip(moves, [0] * len(moves)))\\n\\n # search for max score for each move\\n for move in moves:\\n move_score[move] += max_score_search(move_made(game, move), depth, val)\\n\\n move = max(move_score, key=move_score.get)\\n return move\",\n \"def _call_maximum(vecObj, vec2):\\n res = vecObj.maximum(vec2)\\n return res\",\n \"def _random_max_wrap(*args):\\n _, opt_pt = random_maximise(*args)\\n return opt_pt\",\n \"def solve(self, **kwargs) -> OptimizationResult:\\n raise NotImplementedError\",\n \"def custom_method(*args, **kwargs):\\n return objective_return\",\n \"def custom_method(*args, **kwargs):\\n return objective_return\",\n \"def nn_ga_optimise_from_args(func_caller, worker_manager, max_capital, mode, mutation_op,\\n crossover_op=None, options=None, reporter='default'):\\n if options is None:\\n reporter = get_reporter(reporter)\\n options = load_options(ga_opt_args, reporter=reporter)\\n options.mode = mode\\n return (NNGAOptimiser(func_caller, worker_manager, mutation_op, crossover_op,\\n options, reporter)).optimise(max_capital)\",\n \"def test_maximax():\\n f = np.asarray([\\n [0.99, 1.0, 0.5],\\n [0.69, 0.6, 0.6]])\\n R = common_metrics.maximax(f, maximise=True)\\n expected = np.asarray(\\n [1.0, 0.69])\\n assert np.allclose(R, expected)\\n R = common_metrics.maximax(f, maximise=False)\\n expected = np.asarray(\\n [-0.5, -0.6])\\n assert np.allclose(R, expected)\",\n \"def optimize(self, max_iters=1e3, messages=False, use_counter=False,\\\\\\n factr=1e7, pgtol=1e-05):\\n logger.debug('Beginning MLE to optimize hyperparams. grad_method=%s'\\\\\\n % self.grad_method)\\n\\n # setup the optimization\\n try:\\n x0 = self._transform_parameters(self.parameters)\\n assert np.all(np.isfinite(x0))\\n except:\\n logger.error('Transformation failed for initial values. '\\\\\\n + 'Ensure constraints are met or the value is not too small.')\\n raise\\n\\n # filter out the fixed parameters\\n free = np.logical_not(self._fixed_indicies)\\n x0 = x0[free]\\n\\n # setup the counter\\n if use_counter:\\n self._counter = solver_counter(disp=True)\\n else:\\n self._counter = None\\n\\n # run the optimization\\n try:\\n x_opt, f_opt, opt = fmin_l_bfgs_b(func=self._objective_grad, x0=x0,\\\\\\n factr=factr, pgtol=pgtol, maxiter=max_iters, disp=messages)\\n except (KeyboardInterrupt,IndexError):\\n logger.info('Keyboard interrupt raised. Cleaning up...')\\n if self._counter is not None and self._counter.backup is not None:\\n self.parameters = self._counter.backup[1]\\n logger.info('will return best parameter set with'\\\\\\n + 'log-likelihood = %.4g' % self._counter.backup[0])\\n else:\\n logger.info('Function Evals: %d. Exit status: %s' % (f_opt, opt['warnflag']))\\n # extract the optimal value and set the parameters to this\\n transformed_parameters = self._previous_parameters \\n transformed_parameters[free] = x_opt\\n self.parameters = self._untransform_parameters(transformed_parameters)\\n return opt\",\n \"def poll(target, step, args=(), kwargs=None, timeout=None, max_tries=None, check_success=is_truthy,\\n step_function=step_constant, ignore_exceptions=(), poll_forever=False, collect_values=None, *a, **k):\\n\\n logging.info('Starting Polling')\\n\\n assert (timeout is not None or max_tries is not None) or poll_forever, \\\\\\n ('You did not specify a maximum number of tries or a timeout. Without either of these set, the polling '\\n 'function will poll forever. If this is the behavior you want, pass \\\"poll_forever=True\\\"')\\n\\n assert not ((timeout is not None or max_tries is not None) and poll_forever), \\\\\\n 'You cannot specify both the option to poll_forever and max_tries/timeout.'\\n\\n kwargs = kwargs or dict()\\n values = collect_values or Queue()\\n\\n max_time = Time.time() + timeout if timeout else None\\n tries = 0\\n logging.debug('Max Time: ' + str(max_time))\\n logging.debug('Max Tries: ' + str(max_tries))\\n\\n last_item = None\\n while True:\\n\\n if max_tries is not None and tries >= max_tries:\\n raise MaxCallException(values, last_item)\\n\\n try:\\n logging.debug('Arguments: ' + str(args))\\n val = target(*args, **kwargs)\\n logging.debug('Results from Target running: ' + str(val))\\n last_item = val\\n logging.info('Try #:' + str(tries))\\n DisplayMessage('Try #:' + str(tries))\\n except ignore_exceptions as e:\\n logging.error(str(e))\\n last_item = e\\n else:\\n # Condition passes, this is the only \\\"successful\\\" exit from the polling function\\n if check_target_success(val):\\n return val\\n\\n logging.debug('last result from poll: ' + str(last_item))\\n # Condition passes, this is the only \\\"successful\\\" exit from the polling function\\n if check_target_success(val):\\n return val\\n else:\\n values.put(last_item)\\n tries += 1\\n # Check the time after to make sure the poll function is called at least once\\n if max_time is not None and Time.time() >= max_time:\\n # raise TimeoutException(values, last_item)\\n logging.info('Time out reached.')\\n logging.info('Checking status of job: ' + val)\\n logging.info('Job will now sleep for an additional: ' + step)\\n logging.debug('Step value: ' + str(step))\\n Time.sleep(step)\\n step = step_function(step)\",\n \"def adaptive_scan(detectors, target_field, motor, start, stop,\\n min_step, max_step, target_delta, backstep,\\n threshold=0.8, *, md=None):\\n _md = {'detectors': [det.name for det in detectors],\\n 'motors': [motor.name],\\n 'plan_args': {'detectors': list(map(repr, detectors)),\\n 'motor': repr(motor),\\n 'start': start,\\n 'stop': stop,\\n 'min_step': min_step,\\n 'max_step': max_step,\\n 'target_delta': target_delta,\\n 'backstep': backstep,\\n 'threshold': threshold},\\n 'plan_name': 'adaptive_scan',\\n }\\n _md.update(md or {})\\n\\n @stage_decorator(list(detectors) + [motor])\\n @run_decorator(md=_md)\\n def adaptive_core():\\n next_pos = start\\n step = (max_step - min_step) / 2\\n past_I = None\\n cur_I = None\\n cur_det = {}\\n while next_pos < stop:\\n yield Msg('checkpoint')\\n yield Msg('set', motor, next_pos, group='A')\\n yield Msg('wait', None, 'A')\\n yield Msg('create', None, name='primary')\\n for det in detectors:\\n yield Msg('trigger', det, group='B')\\n yield Msg('wait', None, 'B')\\n for det in separate_devices(detectors + [motor]):\\n cur_det = yield Msg('read', det)\\n if cur_det is not None and target_field in cur_det:\\n cur_I = cur_det[target_field]['value']\\n yield Msg('save')\\n\\n # special case first first loop\\n if past_I is None:\\n past_I = cur_I\\n next_pos += step\\n continue\\n\\n dI = np.abs(cur_I - past_I)\\n\\n slope = dI / step\\n if slope:\\n new_step = np.clip(target_delta / slope, min_step, max_step)\\n else:\\n new_step = np.min([step * 1.1, max_step])\\n\\n # if we over stepped, go back and try again\\n if backstep and (new_step < step * threshold):\\n next_pos -= step\\n step = new_step\\n else:\\n past_I = cur_I\\n step = 0.2 * new_step + 0.8 * step\\n next_pos += step\\n\\n return (yield from adaptive_core())\",\n \"def mod_space_opt(\\n *,\\n space,\\n dryness_method,\\n fuel_build_up_method,\\n include_temperature,\\n discrete_params,\\n defaults=None,\\n basinhopping_options=None,\\n minimizer_options=None,\\n mode=\\\"basinhopping\\\",\\n x0=None,\\n):\\n to_optimise = gen_to_optimise(\\n fail_func=fail_func,\\n success_func=success_func,\\n # Init (data) params.\\n dryness_method=dryness_method,\\n fuel_build_up_method=fuel_build_up_method,\\n include_temperature=include_temperature,\\n _uncached_data=False,\\n **discrete_params,\\n )\\n\\n defaults_dict = defaults if defaults is not None else {}\\n\\n def to_optimise_with_discrete(x):\\n return to_optimise(\\n **space.inv_map_float_to_0_1(dict(zip(space.continuous_param_names, x))),\\n **defaults_dict,\\n )\\n\\n def basinhopping_callback(x, f, accept):\\n # NOTE: Parameters recorded here are authoritative, since hyperopt will not\\n # properly report values modified as in e.g. `mod_quniform`.\\n values = {\\n **space.inv_map_float_to_0_1(dict(zip(space.continuous_param_names, x))),\\n **discrete_params,\\n **defaults_dict,\\n }\\n values[\\\"dryness_method\\\"] = dryness_method\\n values[\\\"fuel_build_up_method\\\"] = fuel_build_up_method\\n values[\\\"include_temperature\\\"] = include_temperature\\n\\n minimizer_options_dict = minimizer_options if minimizer_options is not None else {}\\n basinhopping_options_dict = (\\n basinhopping_options if basinhopping_options is not None else {}\\n )\\n\\n if x0 is None:\\n x0 = space.continuous_x0_mid\\n\\n if mode == \\\"basinhopping\\\":\\n res = basinhopping(\\n to_optimise_with_discrete,\\n x0=x0,\\n seed=0,\\n callback=basinhopping_callback,\\n take_step=BoundedSteps(\\n stepsize=0.3, rng=np.random.default_rng(0), verbose=True\\n ),\\n **{\\n \\\"disp\\\": True,\\n \\\"minimizer_kwargs\\\": dict(\\n method=\\\"L-BFGS-B\\\",\\n jac=None,\\n bounds=[(0, 1)] * len(space.continuous_param_names),\\n options={\\n \\\"maxiter\\\": 60,\\n \\\"ftol\\\": 1e-5,\\n \\\"eps\\\": 1e-3,\\n **minimizer_options_dict,\\n },\\n ),\\n \\\"T\\\": 0.05,\\n \\\"niter\\\": 100,\\n \\\"niter_success\\\": 15,\\n **basinhopping_options_dict,\\n },\\n )\\n elif mode == \\\"minimize\\\":\\n res = minimize(\\n to_optimise_with_discrete,\\n x0=x0,\\n method=\\\"L-BFGS-B\\\",\\n jac=None,\\n bounds=[(0, 1)] * len(space.continuous_param_names),\\n options={\\n \\\"maxiter\\\": 60,\\n \\\"ftol\\\": 1e-5,\\n \\\"eps\\\": 1e-3,\\n **minimizer_options_dict,\\n },\\n )\\n else:\\n raise ValueError\\n\\n return res\",\n \"def fit(self, start_params=None, method='newton', maxiter=100,\\n full_output=True, disp=True, fargs=(), callback=None, retall=False,\\n skip_hessian=False, **kwargs):\\n Hinv = None # JP error if full_output=0, Hinv not defined\\n\\n start_params = self._get_start_params(start_params)\\n\\n # TODO: separate args from nonarg taking score and hessian, ie.,\\n # user-supplied and numerically evaluated estimate frprime doesn't take\\n # args in most (any?) of the optimize function\\n\\n nobs = self.endog.shape[0]\\n # f = lambda params, *args: -self.loglike(params, *args) / nobs\\n\\n def f(params, *args):\\n return -self.loglike(params, *args) / nobs\\n\\n if method == 'newton':\\n # TODO: why are score and hess positive?\\n def score(params, *args):\\n return self.score(params, *args) / nobs\\n\\n def hess(params, *args):\\n return self.hessian(params, *args) / nobs\\n else:\\n def score(params, *args):\\n return -self.score(params, *args) / nobs\\n\\n def hess(params, *args):\\n return -self.hessian(params, *args) / nobs\\n\\n warn_convergence = kwargs.pop('warn_convergence', True)\\n optimizer = Optimizer()\\n xopt, retvals, optim_settings = optimizer._fit(f, score, start_params,\\n fargs, kwargs,\\n hessian=hess,\\n method=method,\\n disp=disp,\\n maxiter=maxiter,\\n callback=callback,\\n retall=retall,\\n full_output=full_output)\\n\\n # NOTE: this is for fit_regularized and should be generalized\\n cov_params_func = kwargs.setdefault('cov_params_func', None)\\n if cov_params_func:\\n Hinv = cov_params_func(self, xopt, retvals)\\n elif method == 'newton' and full_output:\\n Hinv = np.linalg.inv(-retvals['Hessian']) / nobs\\n # TODO: try/except for non-invertible hessian?\\n elif not skip_hessian:\\n H = -1 * self.hessian(xopt)\\n invertible = False\\n if np.all(np.isfinite(H)):\\n eigvals, eigvecs = np.linalg.eigh(H)\\n if np.min(eigvals) > 0:\\n invertible = True\\n\\n if invertible:\\n Hinv = eigvecs.dot(np.diag(1.0 / eigvals)).dot(eigvecs.T)\\n Hinv = np.asfortranarray((Hinv + Hinv.T) / 2.0)\\n else:\\n warnings.warn('Inverting hessian failed, no bse or cov_params '\\n 'available', HessianInversionWarning)\\n Hinv = None\\n\\n if 'cov_type' in kwargs:\\n cov_kwds = kwargs.get('cov_kwds', {})\\n kwds = {'cov_type': kwargs['cov_type'], 'cov_kwds': cov_kwds}\\n else:\\n kwds = {}\\n if 'use_t' in kwargs:\\n kwds['use_t'] = kwargs['use_t']\\n # TODO: add Hessian approximation and change the above if needed\\n mlefit = LikelihoodModelResults(self, xopt, Hinv, scale=1., **kwds)\\n\\n # TODO: hardcode scale?\\n if isinstance(retvals, dict):\\n mlefit.mle_retvals = retvals\\n if warn_convergence and not retvals['converged']:\\n warnings.warn(\\\"Maximum Likelihood optimization failed to \\\"\\n \\\"converge. Check mle_retvals\\\",\\n ConvergenceWarning)\\n\\n mlefit.mle_settings = optim_settings\\n return mlefit\",\n \"def _call_max(vecObj):\\n res = vecObj.max()\\n return res\",\n \"def optimize(start, stop, step):\\n #Go through every angle\\n rot_angle_list = np.arange(start, stop, step)\\n fitness_list = []\\n best_angles_list = []\\n for (i, rot_angle) in enumerate(rot_angle_list):\\n (fitness, best_angles) = self._angle_fitness(rot_angle, initial_R, ending_vec, starting_vec)\\n fitness_list.append(fitness)\\n best_angles_list.append(best_angles)\\n #Find the best result\\n best_index = np.argmin(fitness_list)\\n best_rot_angle = rot_angle_list[best_index]\\n best_angles = best_angles_list[best_index]\\n return (best_rot_angle, best_angles)\",\n \"def run_method(trial, method,\\n cl_ctx=None,\\n queue=None,\\n clear_memoized_objects=False,\\n true_sol_name=\\\"True Solution\\\",\\n comp_sol_name=\\\"Computed Solution\\\", **kwargs):\\n if clear_memoized_objects:\\n global memoized_objects\\n memoized_objects = {}\\n\\n if cl_ctx is None:\\n raise ValueError(\\\"Missing cl_ctx\\\")\\n if queue is None:\\n raise ValueError(\\\"Missing queue\\\")\\n\\n # Get boundary ids\\n scatterer_bdy_id = kwargs['scatterer_bdy_id']\\n outer_bdy_id = kwargs['outer_bdy_id']\\n\\n # Get degree and wave number\\n degree = trial['degree']\\n wave_number = trial['kappa']\\n\\n # Get options prefix and solver parameters, if any\\n options_prefix = kwargs.get('options_prefix', None)\\n solver_parameters = dict(kwargs.get('solver_parameters', None))\\n\\n # Get prepared trial args in kwargs\\n prepared_trial = prepare_trial(trial, true_sol_name, cl_ctx, queue)\\n mesh, fspace, vfspace, true_sol, true_sol_grad_expr = prepared_trial\\n\\n # Create a place to memoize any objects if necessary\\n tuple_trial = trial_to_tuple(trial)\\n memo_key = tuple_trial[:2]\\n if memo_key not in memoized_objects:\\n memoized_objects[memo_key] = {}\\n\\n comp_sol = None\\n\\n # Handle any special kwargs and get computed solution\\n if method == 'pml':\\n # Get required objects\\n pml_max = kwargs['pml_max']\\n pml_min = kwargs['pml_min']\\n\\n # Get optional argumetns\\n pml_type = kwargs.get('pml_type', None)\\n quad_const = kwargs.get('quad_const', None)\\n speed = kwargs.get('speed', None)\\n\\n # Make tensor function space\\n if 'tfspace' not in memoized_objects[memo_key]:\\n memoized_objects[memo_key]['tfspace'] = \\\\\\n TensorFunctionSpace(mesh, 'CG', degree)\\n\\n tfspace = memoized_objects[memo_key]['tfspace']\\n\\n snes, comp_sol = pml(mesh, scatterer_bdy_id, outer_bdy_id, wave_number,\\n options_prefix=options_prefix,\\n solver_parameters=solver_parameters,\\n fspace=fspace, tfspace=tfspace,\\n true_sol_grad_expr=true_sol_grad_expr,\\n pml_type=pml_type, quad_const=quad_const,\\n speed=speed,\\n pml_min=pml_min,\\n pml_max=pml_max,\\n )\\n snes_or_ksp = snes\\n\\n elif method == 'nonlocal':\\n # Build DG spaces if not already built\\n if 'dgfspace' not in memoized_objects[memo_key]:\\n memoized_objects[memo_key]['dgfspace'] = \\\\\\n FunctionSpace(mesh, 'DG', degree)\\n if 'dgvfspace' not in memoized_objects[memo_key]:\\n memoized_objects[memo_key]['dgvfspace'] = \\\\\\n VectorFunctionSpace(mesh, 'DG', degree)\\n\\n dgfspace = memoized_objects[memo_key]['dgfspace']\\n dgvfspace = memoized_objects[memo_key]['dgvfspace']\\n\\n # Get opencl array context\\n from meshmode.array_context import PyOpenCLArrayContext\\n actx = PyOpenCLArrayContext(queue)\\n\\n # Build connection fd -> meshmode if not already built\\n if 'meshmode_src_connection' not in memoized_objects[memo_key]:\\n from meshmode.interop.firedrake import build_connection_from_firedrake\\n memoized_objects[memo_key]['meshmode_src_connection'] = \\\\\\n build_connection_from_firedrake(\\n actx,\\n dgfspace,\\n grp_factory=None,\\n restrict_to_boundary=scatterer_bdy_id)\\n\\n meshmode_src_connection = memoized_objects[memo_key]['meshmode_src_connection']\\n\\n # Set defaults for qbx kwargs\\n qbx_order = kwargs.get('qbx_order', degree+2)\\n fine_order = kwargs.get('fine_order', 4 * degree)\\n fmm_order = kwargs.get('FMM Order', None)\\n fmm_tol = kwargs.get('FMM Tol', None)\\n # make sure got either fmm_order xor fmm_tol\\n if fmm_order is None and fmm_tol is None:\\n raise ValueError(\\\"At least one of 'fmm_order', 'fmm_tol' must not \\\"\\n \\\"be *None*\\\")\\n if fmm_order is not None and fmm_tol is not None:\\n raise ValueError(\\\"At most one of 'fmm_order', 'fmm_tol' must not \\\"\\n \\\"be *None*\\\")\\n # if got fmm_tol, make a level-to-order\\n fmm_level_to_order = None\\n if fmm_tol is not None:\\n if not isinstance(fmm_tol, float):\\n raise TypeError(\\\"fmm_tol of type '%s' is not of type float\\\" % type(fmm_tol))\\n if fmm_tol <= 0.0:\\n raise ValueError(\\\"fmm_tol of '%s' is less than or equal to 0.0\\\" % fmm_tol)\\n from sumpy.expansion.level_to_order import SimpleExpansionOrderFinder \\n fmm_level_to_order = SimpleExpansionOrderFinder(fmm_tol)\\n # Otherwise, make sure we got a valid fmm_order\\n else:\\n if not isinstance(fmm_order, int):\\n if fmm_order != False:\\n raise TypeError(\\\"fmm_order of type '%s' is not of type int\\\" % type(fmm_order))\\n if fmm_order != False and fmm_order < 1:\\n raise ValueError(\\\"fmm_order of '%s' is less than 1\\\" % fmm_order)\\n\\n qbx_kwargs = {'qbx_order': qbx_order,\\n 'fine_order': fine_order,\\n 'fmm_order': fmm_order,\\n 'fmm_level_to_order': fmm_level_to_order,\\n 'fmm_backend': 'fmmlib',\\n }\\n # }}}\\n\\n ksp, comp_sol = nonlocal_integral_eq(\\n mesh, scatterer_bdy_id, outer_bdy_id,\\n wave_number,\\n options_prefix=options_prefix,\\n solver_parameters=solver_parameters,\\n fspace=fspace, vfspace=vfspace,\\n true_sol_grad_expr=true_sol_grad_expr,\\n actx=actx,\\n dgfspace=dgfspace,\\n dgvfspace=dgvfspace,\\n meshmode_src_connection=meshmode_src_connection,\\n qbx_kwargs=qbx_kwargs,\\n )\\n\\n snes_or_ksp = ksp\\n\\n elif method == 'transmission':\\n\\n snes, comp_sol = transmission(mesh, scatterer_bdy_id, outer_bdy_id,\\n wave_number,\\n options_prefix=options_prefix,\\n solver_parameters=solver_parameters,\\n fspace=fspace,\\n true_sol_grad_expr=true_sol_grad_expr,\\n )\\n snes_or_ksp = snes\\n else:\\n raise ValueError(\\\"Invalid method\\\")\\n\\n comp_sol.rename(name=comp_sol_name)\\n return true_sol, comp_sol, snes_or_ksp\",\n \"def optimize(self, objective_sense=None, **kwargs):\\n\\n if objective_sense:\\n self.objective.direction = objective_sense\\n\\n try:\\n # self._hidden_optimize_call(kwargs)\\n Model.optimize(self, **kwargs)\\n solution = self.get_solution()\\n self.solution = solution\\n return solution\\n except SolverError as SE:\\n status = self.solver.status\\n self.logger.error(SE)\\n self.logger.warning('Solver status: {}'.format(status))\\n raise (SE)\",\n \"def step_func_cat(X, args, Y, info, Ytarget, err, tols, iter, maxIter):\\n [XF, ZF, L, EA, W, CB, WL, WEA, L_EA, CB_EA] = args[\\\"cat\\\"]\\n\\n # if abs( err[1] + ZF ) < 0.0001:\\n # breakpoint()\\n\\n [alpha_min, alpha0, alphaR] = args[\\n \\\"step\\\"\\n ] # get minimum alpha, initial alpha, and alpha reduction rate from passed arguments\\n\\n # J = info['jacobian']\\n # dX = -np.matmul(np.linalg.inv(J), err)\\n dX = -np.matmul(info[\\\"stiffnessB\\\"], err)\\n\\n # ! Reduce dHF by factor (between 1 at I = 1 and 0 at I = MaxIter) that reduces linearly with iteration count\\n # to ensure that we converge on a solution even in the case were we obtain a nonconvergent cycle about the\\n # correct solution (this happens, for example, if we jump to quickly between a taut and slack catenary)\\n\\n alpha = 1.0 # M<<<<<<<< np.max([alpha_min, alpha0*(1.0 - alphaR*iter/maxIter)])\\n\\n # exponential approach alpha = alpha0 * np.exp( iter/maxIter * np.log(alpha_min/alpha0 ) )\\n\\n dX[0] = dX[0] * alpha # dHF*( 1.0 - Tol*I )\\n dX[1] = dX[1] * alpha # dVF*( 1.0 - Tol*I )\\n\\n # To avoid an ill-conditioned situation, make sure HF does not go less than or equal to zero by having a lower limit of Tol*HF\\n # [NOTE: the value of dHF = ( Tol - 1.0 )*HF comes from: HF = HF + dHF = Tol*HF when dHF = ( Tol - 1.0 )*HF]\\n # dX[0] = max( dX[0], ( tol - 1.0 )*info['HF']);\\n\\n # To avoid an ill-conditioned situation, make sure HF does not get too close to zero, by forcing HF >= tols[0]\\n # if info['HF'] + dX[0] <= tol*abs(info['VF']+dX[1]):\\n # if info['HF'] + dX[0] <= tols[0]\\n if X[0] + dX[0] <= tols[0]:\\n # dX[0] = tol*abs(info['VF']+dX[1]) - info['HF']\\n # dX[0] = tols[0] - info['HF']\\n dX[0] = tols[0] - X[0]\\n\\n # To avoid an ill-conditioned situation where the line is nearly all on the seabed but the solver gets stuck,\\n # if np.abs(err[1] + ZF)/ZF < tol:\\n # breakpoint()\\n # deltaHFVF = info['HF'] - info['VF']\\n # dX[0] = dX[0] - 0.5*deltaHFVF\\n # dX[1] = dX[1] + 0.5*deltaHFVF\\n\\n # prevent silly situation where a line with weight and positive ZF considers a negative VF\\n if info[\\\"ProfileType\\\"] == 2:\\n if X[1] + dX[1] <= tols[1]: # if vertical force is within tolerance of being zero/negative\\n VFtarget = (L - info[\\\"LBot\\\"]) * W # set next VF value to be the weight of portion of line that's suspended\\n dX[1] = VFtarget - X[1]\\n\\n return dX # returns dX (step to make)\",\n \"def optimise_fn(self, x):\\n\\n success = self._set_material_parameters(x)\\n if not success:\\n return self._bad_metric()\\n\\n # some iterations are repeated so cache the results to avoid unnecessary iterations\\n cached_result_key = tuple(x)\\n metric_value = self.cached_results.get(cached_result_key)\\n\\n if metric_value is None:\\n print('--> Optimiser: {}'.format(self.material_model))\\n\\n sim_result = fs.run_simulation(stoma_cfg=self.stoma_cfg,\\n from_optimiser=True)\\n\\n # when the simulation fails we want a non-constant measure for the optimiser to use\\n metric_value = sim_result.metric_value if sim_result.success else self._bad_metric()\\n\\n self.cached_results[cached_result_key] = metric_value\\n\\n print('--> Optimiser: {} - metric={}'.format(self.material_model, metric_value))\\n else:\\n print('--> Optimiser: {} - metric={} (cached result)'.format(self.material_model, metric_value))\\n\\n return metric_value\",\n \"def my_max(*args):\\n def sorter(sequence):\\n \\\"\\\"\\\"\\n This function find max in given sequence of simple numbers\\n \\\"\\\"\\\"\\n def bubble_sort(a):\\n \\\"\\\"\\\"\\n This function sort the list\\n \\\"\\\"\\\"\\n for i in reversed(range(len(a))):\\n for j in range(1, i + 1):\\n if a[j-1] > a[j]:\\n a[j], a[j-1] = a[j-1], a[j]\\n return a\\n\\n listed_seq = list(sequence)\\n for number in listed_seq:\\n if not isinstance(number, int):\\n raise ValueError(\\\"Can't find max, wrong data format\\\")\\n return bubble_sort(listed_seq)[-1]\\n\\n if not args:\\n raise ValueError(\\\"Can't find max, no data given\\\")\\n if len(args) == 1:\\n thing = args[0]\\n if isinstance(thing, (list, tuple)):\\n return sorter(thing)\\n if isinstance(thing, int):\\n return thing\\n raise ValueError(\\\"Can't find max, wrong data format\\\")\\n return sorter(args)\",\n \"def maximize(self):\\n raise NotImplementedError\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # AlphaBetaAgent.callsCount = 0\\n # If the game state is lost or win then just return the evaluation value\\n if gameState.isLose() or gameState.isWin():\\n return self.evaluationFunction(gameState)\\n\\n # This part is almost the same with MinimaxAgent other than two additional parameters of alpha and beta values\\n # by recursion calls in MiniMax tree to make a decision\\n # alpha = the best choice of the highest values we have found so far along the path for MAX.\\n # (initializes -9999999)\\n # beta = the best choice of the lowest values we have found so far along the path for MIN.\\n # (initializes +9999999)\\n\\n finalDirection = self.maxValueAlphaBeta(gameState, self.depth * gameState.getNumAgents(), gameState.getNumAgents(), 0, -9999999, 9999999)\\n # print(\\\"Number of Calls: \\\", AlphaBetaAgent.callsCount)\\n return finalDirection[1]\\n\\n # The helper function to remove STOP action to improve efficiency\\n def removeStop(self, legalMoves):\\n stopDirection = Directions.STOP\\n if stopDirection in legalMoves:\\n legalMoves.remove(stopDirection)\\n\\n # The maxValue method for PacMan whose agent index is zero\\n def maxValueAlphaBeta(self, gameState, depth, numOfAgents, agentIndex, alpha, beta):\\n # AlphaBetaAgent.callsCount += 1\\n legalMoves = gameState.getLegalActions(agentIndex)\\n self.removeStop(legalMoves)\\n # The next states, either passed in to getAction or generated via GameState.generateSuccessor\\n nextStates = [gameState.generateSuccessor(agentIndex, action) for action in legalMoves]\\n if depth == 0 or len(nextStates) == 0:\\n return (self.evaluationFunction(gameState), Directions.STOP)\\n\\n maxValue = -9999999\\n action = legalMoves[0]\\n moveIndex = 0\\n chooseMax = []\\n\\n # There are only one case to call minValue from Pacman perspective\\n for nextState in nextStates:\\n res = self.minValueAlphaBeta(nextState, depth-1, numOfAgents-2, numOfAgents, (agentIndex+1)%numOfAgents, alpha, beta)\\n chooseMax.append(res)\\n if res > maxValue:\\n maxValue = res\\n action = legalMoves[moveIndex]\\n # Check \\\"cut-off\\\" condition\\n if res > alpha: # If alpha is smaller than the current Max value\\n alpha = res # Then replace alpha with the current Max value\\n if alpha >= beta: # When alpha value is larger than beta value\\n return (alpha, action) # beta cut-off\\n moveIndex = moveIndex + 1\\n return (maxValue, action)\",\n \"def run_step_blackbox_optimizer(config,\\n current_input,\\n blackbox_optimizer,\\n proposed_perturbations,\\n finished_dnas,\\n results,\\n logging_data=None):\\n core_hyperparameters = blackbox_optimizer.get_hyperparameters()\\n function_values = [0.0] * len(proposed_perturbations)\\n rewards_for_controller = []\\n perturbations = proposed_perturbations\\n evaluation_stats = []\\n current_value_exact = 0.0\\n current_value_exact_counter = 0\\n\\n for i in range(len(results)):\\n rewards_for_controller.append(results[i]['function_value'])\\n tag = results[i]['tag']\\n index = 0\\n if tag > 0:\\n if config.est_type == 'antithetic':\\n index = (tag - 1) * 2\\n function_values[index] += results[i]['function_value']\\n else:\\n index = tag - 1\\n function_values[index] += results[i]['function_value']\\n if tag < 0:\\n index = (-tag - 1) * 2 + 1\\n function_values[index] += results[i]['function_value']\\n if tag == 0:\\n current_value_exact += results[i]['function_value']\\n current_value_exact_counter += 1\\n current_value_exact /= float(current_value_exact_counter)\\n\\n for result in results:\\n evaluation_stat = list(result['evaluation_stat'])\\n evaluation_stats.append(evaluation_stat)\\n\\n function_values_reshaped = np.array(function_values)\\n perturbations_reshaped = np.array(perturbations)\\n\\n logging.info('LIST OF FUNCTION VALUES')\\n logging.info(function_values_reshaped)\\n\\n logging.info('MAX VALUE SEEN CURRENTLY')\\n logging.info(np.max(function_values_reshaped))\\n\\n logging.info('MEAN OF VALUES')\\n logging.info(np.mean(function_values_reshaped))\\n\\n if logging_data is not None:\\n iteration = logging_data['iteration']\\n best_value = logging_data['best_value']\\n iteration = logging_data['iteration']\\n best_input = logging_data['best_input']\\n best_core_hyperparameters = logging_data['best_core_hyperparameters']\\n optimizer_state = blackbox_optimizer.get_state()\\n\\n if current_value_exact > best_value[0]:\\n best_value[0] = current_value_exact\\n best_input = current_input\\n best_core_hyperparameters = core_hyperparameters\\n\\n # Writing logs.\\n if iteration % config.log_frequency == 0:\\n util.log_row(config.params_file, current_input)\\n util.log_row(config.best_params_file, best_input)\\n util.log_row(config.best_core_hyperparameters_file,\\n best_core_hyperparameters)\\n util.log_row(config.best_value_file, best_value)\\n util.log_row(config.optimizer_internal_state_file, optimizer_state)\\n util.log_row(config.current_values_list_file, [current_value_exact])\\n util.log_row(config.best_values_list_file, [best_value[0]])\\n util.log_row(config.fvalues_file, function_values_reshaped)\\n util.log_row(config.iteration_file, [iteration])\\n\\n print('Current exact value estimate:')\\n print(current_value_exact)\\n sys.stdout.flush()\\n\\n new_current_input = blackbox_optimizer.run_step(perturbations_reshaped,\\n function_values_reshaped,\\n current_input,\\n current_value_exact)\\n config.controller.collect_rewards_and_train(rewards_for_controller,\\n finished_dnas)\\n\\n evaluation_stats_reduced = [sum(x) for x in zip(*evaluation_stats)]\\n blackbox_optimizer.update_state(evaluation_stats_reduced)\\n\\n return [True, new_current_input]\",\n \"def _optimize_f(self,x0,type,method,**kwargs):\\n from scipy.optimize import fmin,fmin_powell\\n\\n if type == 'min':\\n g=lambda *args,**kwargs:self.f(*args,**kwargs)\\n elif type == 'max':\\n g=lambda *args,**kwargs:-1*self.f(*args,**kwargs)\\n elif type == 'root':\\n g=lambda *args,**kwargs:np.abs(self.f(*args,**kwargs))\\n elif type == 'val':\\n val = kwargs.pop('valtofind')\\n g=lambda *args,**kwargs:np.abs(self.f(*args,**kwargs)-val)\\n elif type == 'saddle':\\n raise NotImplementedError\\n else:\\n raise ValueError('Unrecognized optimization type')\\n\\n if method == 'fmin':\\n res = fmin(g,x0,tuple(self.parvals),**kwargs)\\n elif method == 'fmin_powell':\\n res = fmin_powell(g,x0,tuple(self.parvals),**kwargs)\\n else:\\n raise ValueError('Unrecognized method')\\n\\n self.lastOpt = res\\n return res[0]\",\n \"def maxlikelihood(self):\\n\\n chi2 = lambda *args: -2 * lnlikelihood.lnlike(*args) \\n # print('***DEBUGGING*** chi2 = ', chi2)\\n # print('***DEBUGGING*** self.theta_guess = ', self.theta_guess)\\n # print('***DEBUGGING*** self.transinfo = ', self.transinfo)\\n # print('***DEBUGGING*** self.wave_b = ', self.wave_b)\\n # print('***DEBUGGING*** self.flux_b = ', self.flux_b)\\n # print('***DEBUGGING*** self.err_b = ', self.err_b)\\n # print('***DEBUGGING*** self.wave_r = ', self.wave_r)\\n # print('***DEBUGGING*** self.flux_r = ', self.flux_r)\\n # print('***DEBUGGING*** self.err_r = ', self.err_r)\\n # print('***DEBUGGING*** self.velres = ', self.velres)\\n result = op.minimize(chi2, self.theta_guess,\\n args=(self.transinfo, self.wave_b, self.flux_b, self.err_b,\\n self.wave_r, self.flux_r, self.err_r, self.velres))\\n\\n self.theta_ml = result[\\\"x\\\"]\",\n \"def optimiseOne(paramOption, row, extractdata, start, stop, step):\\n stockname = row[0]\\n exclAttribs = row[1]\\n bestNu = row[2]\\n\\n tryParam = start\\n bestParam = tryParam\\n (trialError, trialCorrelation, trailAttrCsv) = common.lsCalcModel(\\n stockname, exclAttribs, common.cv, extractdata, bestNu, \\\"{0} {1}\\\".format(paramOption, tryParam))\\n\\n print \\\"Starting correlation={0}, with param={1}\\\".format(trialCorrelation, bestParam)\\n bestCorrelation = trialCorrelation\\n\\n tryParam = start + step\\n while tryParam < stop:\\n print \\\"Trial {0}={1}\\\".format(paramOption, tryParam)\\n (trialError, trialCorrelation, trailAttrCsv) = common.lsCalcModel(\\n stockname, exclAttribs, common.cv, extractdata, tryParam)\\n print \\\"Result: correlation={0} for trial Nu={1} with current bestCorrelation={2}\\\".\\\\\\n format(trialCorrelation, tryParam, bestCorrelation)\\n if trialCorrelation >= bestCorrelation:\\n bestCorrelation = trialCorrelation\\n bestParam = tryParam\\n print \\\"Found better or same correlation=\\\" + str(bestCorrelation) + \\\" with Nu={0}\\\".format(bestParam)\\n else:\\n print \\\"Not better. Best parameter value = {0} with correlation={1}\\\".format(bestParam, bestCorrelation)\\n break\\n\\n tryParam = tryParam + step\\n\\n return (bestParam, bestCorrelation)\",\n \"def maximum(x1, x2, *args, **kwargs):\\n raise NotImplementedError\",\n \"def test_optimalagentfinder () :\\n def valNetwork (s) : \\n s = s.float()\\n v = reduce(model.withReluDropout, model.v[:-1], s)\\n v = model.v[-1](v)\\n return v\\n acrobotBases = acrobotRewardBases(np.pi / 8, np.pi / 8)\\n fn = random.sample(acrobotBases, k=1).pop()\\n agent = findOptimalAgent(fn)\\n model = agent.model\\n toExternal = lambda x, y : toExternalStateRep([x, y, 0, 0])\\n valFn = reduce(compose, [float, valNetwork, torch.tensor, toExternal])\\n RFn = compose(fn, toExternal)\\n xRange = np.arange(-np.pi, np.pi, 0.1)\\n yRange = np.arange(-np.pi, np.pi, 0.1)\\n plotFunction(RFn, xRange, yRange, 'theta1', 'theta2', 'R')\\n plotFunction(valFn, xRange, yRange, 'theta1', 'theta2', 'V')\",\n \"def _maximize(self, board, possible_actions, depth_limit, alpha, beta):\\r\\n pass\",\n \"def solve(self, example_name, max_iter = 100, is_check_stop = True, maximum_line_search = 10):\\n logger.debug(\\\"[+ +] Initial Obj.Val.: %.5e\\\"%(self.get_obj_fun_value()))\\n start_time = tm.time()\\n for i in range(max_iter):\\n if i == 1: # skip the compiling time \\n start_time = tm.time()\\n iter_start_time = tm.time()\\n self.backward_pass()\\n backward_time = tm.time()\\n obj, isStop = self.forward_pass(max_line_search=maximum_line_search)\\n forward_time = tm.time()\\n logger.debug(\\\"[+ +] Iter.No.%3d BWTime:%.3e FWTime:%.3e Obj.Val.:%.5e\\\"%(\\n i, backward_time-iter_start_time,forward_time-backward_time,obj))\\n result_path = os.path.join(\\\"logs\\\", example_name, str(i) +\\\".mat\\\")\\n io.savemat(result_path,{\\\"trajectory\\\": self.get_traj()})\\n if isStop and is_check_stop:\\n break\\n end_time = tm.time()\\n logger.debug(\\\"[+ +] Completed! All Time:%.5e\\\"%(end_time-start_time))\",\n \"def optimise(\\n cls,\\n species: \\\"Species\\\",\\n method: \\\"Method\\\",\\n n_cores: Optional[int] = None,\\n coords: Optional[OptCoordinates] = None,\\n **kwargs,\\n ) -> None:\",\n \"def _objective(self, trial, X, y, weights=None, split=None):\\n\\n # Generate even weights if none\\n if weights is None:\\n weights = pd.Series(np.ones(len(y)), index=y.index)\\n else:\\n weights = pd.Series(weights, index=y.index)\\n\\n # Execute trial function\\n try:\\n res = eval(self.function)\\n except:\\n raise RuntimeError(f\\\"Optuna execution error: {self.function}\\\")\\n\\n # If indicator result is tuple, select the one of interest\\n if isinstance(res, tuple):\\n res = res[self.idx]\\n\\n # Ensure result is a dataframe with same index as X\\n res = pd.DataFrame(res, index=X.index)\\n\\n # If indicator result is dataframe, select the one of interest\\n if len(res.columns) > 1:\\n res = pd.DataFrame(res.iloc[:, self.idx])\\n\\n # y may be a subset of X, so reduce result to y and convert to series\\n res_y = res.reindex(y.index).iloc[:, 0].replace([np.inf, -np.inf], np.nan)\\n\\n # Save all trial results for pruning and reporting\\n # Only the best trial will eventually be saved to limit storage requirements\\n self.res_y.append(res_y) # Save results\\n\\n # Indicator result may be all NANs based on parameter set\\n # Return FALSE and alert\\n if np.isnan(res_y).sum() / len(res_y) > .95: # Most or all NANs\\n self.res_y_corr.append(np.zeros(len(y)))\\n if split is not None:\\n return tuple([False] * (len(split) - 1))\\n else:\\n return False\\n\\n # Obtain correlation for entire dataset\\n if self.spearman:\\n corr = _weighted_spearman(np.array(y), np.array(res_y), np.array(weights))\\n else:\\n corr = _weighted_pearson(np.array(y), np.array(res_y), np.array(weights))\\n\\n # Save correlation for res_y\\n self.res_y_corr.append(corr)\\n\\n # Multi-objective optimization\\n # Obtain correlation to target for each split for Optuna to maximize\\n if split is not None:\\n mo = []\\n for i, e in enumerate(split):\\n if i == 0:\\n s = e\\n continue\\n\\n # y could be a subset of X, use index of X to filter y\\n idx = X[s:e].index\\n\\n # Filter y based on X split\\n y_se = np.array(y[y.index.isin(idx)]).astype('float64')\\n\\n # Filter y predictions based on X split\\n res_y_se = np.array(res_y[res_y.index.isin(idx)]).astype('float64')\\n\\n # Filter weights based on X split\\n weights_se = np.array(weights[weights.index.isin(idx)]).astype('float64')\\n\\n if np.isnan(res_y_se).sum() / len(res_y_se) > .95:\\n return tuple([False]*(len(split)-1))\\n\\n if self.spearman:\\n mo.append(_weighted_spearman(y_se, res_y_se, weights_se))\\n else:\\n mo.append(_weighted_pearson(y_se, res_y_se, weights_se))\\n s = e\\n return tuple(mo)\\n\\n # Single objective optimization return corr for entire dataset\\n else:\\n return corr\",\n \"def downhill(F, xStart, args=None, side=0.1, ftol=1.0e-6, xtol=1.0e-6, maxiter=1000, maxfunc=1000, maxiternochange=10):\\n # TODO: check the types of the input ???\\n\\n # print \\\"Entering downhill\\\"\\n n = len(xStart)\\n x = np.zeros((n+1, n), dtype=float) #point null matrix, n+1 rows, n columns\\n f = np.zeros(n+1, dtype=float) # null vector, n+1 columns\\n p_count = 0 # counter for detecting a plateau\\n f_count = 0 # counter for the number of function call\\n f_best_count = 0 # counter for the number of iterations in which the best solution does not change\\n f_best_prev = 0.0 # holds the best value from the previous iteration\\n epsilon = 0.001 # tolerance for considering two values as equal\\n # max_iter_no_change = 10 # maximum number of accepted iterations with no change in the optimal solution\\n precision = 2\\n round_map = partial(round, ndigits=precision) # partial function for rounding purposes\\n\\n # initial simplex\\n x[0] = xStart\\n for i in xrange(1, n+1):\\n x[i] = xStart\\n x[i,i-1] = xStart[i-1] + side\\n\\n # print \\\"Evaluate the starting points\\\"\\n # compute the value of F at the vertices of the simplex\\n for i in xrange(n+1):\\n f[i] = F(x[i], args)\\n # p_count += 1\\n\\n # main loop\\n # print \\\"Start iterating\\\"\\n for k in xrange(maxiter):\\n\\n # check the number of function calls\\n if f_count > maxfunc:\\n print \\\"Stopping criteria: maximum number of function calls\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXFUNCALL'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXFUNCALL'}\\n\\n # find the best and worst vertex (consider a minimization problem)\\n iLo = np.argmin(f) # best vertex\\n iHi = np.argmax(f) # worst vertex\\n\\n # print k,\\\" \\\", f[iLo]\\n #\\n # if f[iLo] < -0.310000:\\n # print f[iLo]\\n # print x[iLo]\\n # print x\\n # sys.exit(1)\\n # print \\\"k: \\\", k, \\\" f_best_prev: \\\", f_best_prev, \\\" f[iLo]: \\\", f[iLo], \\\" f_best_count: \\\", f_best_count\\n # print \\\"Beginning of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\\\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\\n # print \\\"x: \\\", x, \\\" f: \\\", f\\n # print \\\"=========================================================================================\\\"\\n # check if the solution has changed from the previous iterations\\n if f[iLo] < f_best_prev:\\n f_best_prev = f[iLo]\\n f_best_count = 0\\n else:\\n f_best_count += 1\\n\\n if f_best_count > maxiternochange:\\n print \\\"Stopping criteria: maximum number of iterations with no improvement in the best solution\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'NOIMPROVEMENT'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'NOIMPROVEMENT'}\\n\\n if abs(f[iLo] - f[iHi]) < ftol: # If difference between highest and lowest is smaller than ftol, return\\n print \\\"Stopping criteria: difference between highest and lowest points is smaller than tolerance\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXTOLERANCE'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXTOLERANCE'}\\n # compute the move vector d\\n d = (-(n+1) * x[iHi] + np.sum(x, axis=0)) / n\\n # print \\\"d: \\\", d\\n\\n # check for convergence\\n if sqrt(np.dot(d, d)/n) < xtol: # length of the vector d\\n print \\\"Stopping criteria: length of step d smaller than tolerance\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'SMALLSTEP'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'SMALLSTEP'}\\n # try reflection\\n xNew = np.array(map(round_map, x[iHi] + 2 * d))\\n fNew = F(xNew, args)\\n f_count += 1\\n # print \\\"Reflected point: \\\", xNew, \\\" value: \\\", fNew\\n\\n # check for no improvement over the worst point\\n # and for plateau condition\\n if f[iHi] - epsilon <= fNew <= f[iHi] + epsilon:\\n p_count += 1\\n # print \\\"No improvement here\\\"\\n\\n if p_count == n+2: # we reflected all vertices with no improvement\\n print \\\"Stopping criteria: Probably we landed on a plateau... exiting\\\" # TODO: restart instead of exiting\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'PLATEAU'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'PLATEAU'}\\n\\n\\n else:\\n p_count = 0\\n\\n\\n if fNew <= f[iLo]: # if the new value is better than the best so far,\\n x[iHi] = xNew # substitute the worst vertex with the new one\\n f[iHi] = fNew\\n\\n # try to expand the reflection\\n xNew = np.array(map(round_map, x[iHi] + d))\\n fNew = F(xNew, args)\\n f_count += 1\\n # print \\\"Expanded point: \\\", xNew, \\\" value: \\\", fNew\\n\\n if fNew <= f[iHi]: # in the original source version it is f[iLo] (?)\\n x[iHi] = xNew\\n f[iHi] = fNew\\n else:\\n # try reflection again\\n if fNew <= f[iHi]:\\n x[iHi] = xNew\\n f[iHi] = fNew\\n else:\\n # try contraction\\n xNew = np.array(map(round_map, x[iHi] + 0.5 * d))\\n fNew = F(xNew, args)\\n f_count += 1\\n # print \\\"Contracted point: \\\", xNew, \\\" value: \\\", fNew\\n\\n if fNew <= f[iHi]: # accept contraction\\n x[iHi] = xNew\\n f[iHi] = fNew\\n else:\\n # shrink\\n for i in xrange(len(x)):\\n if i != iLo:\\n x[i] = np.array(map(round_map, x[i] - x[iLo] * 0.5))\\n f[i] = F(x[i], args)\\n f_count += 1\\n\\n # print \\\"End of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\\\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\\n # print \\\"x: \\\", x, \\\" f: \\\", f\\n # print \\\"*\\\"*50\\n # print \\\"\\\"\\n\\n\\n\\n print \\\"Stopping criteria: maximum number of iterations\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXITERATION'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXITERATION'}\",\n \"def optimize(self, X, y, *args):\\n self.loss_function.set_space(X, y, *args)\\n self.betas_ = fastgradalgo(\\n self.loss_function,\\n t_init=self.eta_init,\\n max_iter=self.max_iter\\n )\\n return self.betas_\",\n \"def heuristics(e, z, z0, direction):\\n\\n from sympy.calculus.util import AccumBounds\\n rv = None\\n if abs(z0) is S.Infinity:\\n rv = limit(e.subs(z, 1 / z), z, S.Zero, 1 if z0 is S.Infinity else -1)\\n if isinstance(rv, Limit):\\n return\\n elif e.is_Mul or e.is_Add or e.is_Pow or e.is_Function:\\n r = []\\n for a in e.args:\\n l = limit(a, z, z0, direction)\\n if l.has(S.Infinity) and l.is_finite is None:\\n if isinstance(e, Add):\\n m = factor_terms(e)\\n if not isinstance(m, Mul): # try together\\n m = together(m)\\n if not isinstance(m, Mul): # try factor if the previous methods failed\\n m = factor(e)\\n if isinstance(m, Mul):\\n return heuristics(m, z, z0, direction)\\n return\\n return\\n elif isinstance(l, Limit):\\n return\\n elif l is S.NaN:\\n return\\n else:\\n r.append(l)\\n if r:\\n rv = e.func(*r)\\n if rv is S.NaN and e.is_Mul and any(isinstance(rr, AccumBounds) for rr in r):\\n r2 = []\\n e2 = []\\n for ii in range(len(r)):\\n if isinstance(r[ii], AccumBounds):\\n r2.append(r[ii])\\n else:\\n e2.append(e.args[ii])\\n\\n if len(e2) > 0:\\n from sympy import simplify\\n e3 = simplify(Mul(*e2))\\n l = limit(e3, z, z0, direction)\\n rv = l * Mul(*r2)\\n\\n if rv is S.NaN:\\n try:\\n rat_e = ratsimp(e)\\n except PolynomialError:\\n return\\n if rat_e is S.NaN or rat_e == e:\\n return\\n return limit(rat_e, z, z0, direction)\\n return rv\",\n \"def act(self, q_values, *args, **kwargs):\\n return np.array([np.argmax(q_values)])\",\n \"def _autolag(mod, endog, exog, startlag, maxlag, method, modargs=(),\\n fitargs=(), regresults=True):\\n if not regresults: # pragma: no cover\\n # TODO: update docstring\\n raise NotImplementedError(\\\"option `regresults=False` not ported \\\"\\n \\\"from upstream. _autolag always returns \\\"\\n \\\"a tuple (icbest, bestlag, results)\\\")\\n\\n # TODO: can tcol be replaced by maxlag + 2?\\n # TODO: This could be changed to laggedRHS and exog keyword arguments if\\n # this will be more general.\\n\\n results = {}\\n method = method.lower()\\n for lag in range(startlag, startlag + maxlag + 1):\\n mod_instance = mod(endog, exog[:, :lag], *modargs)\\n results[lag] = mod_instance.fit()\\n\\n if method == \\\"aic\\\":\\n icbest, bestlag = min((v.aic, k) for k, v in results.items())\\n elif method == \\\"bic\\\":\\n icbest, bestlag = min((v.bic, k) for k, v in results.items())\\n elif method == \\\"t-stat\\\":\\n # stop = stats.norm.ppf(.95)\\n stop = 1.6448536269514722\\n for lag in range(startlag + maxlag, startlag - 1, -1):\\n icbest = np.abs(results[lag].tvalues[-1])\\n if np.abs(icbest) >= stop:\\n bestlag = lag\\n icbest = icbest\\n break\\n else: # pragma: no cover\\n raise ValueError(\\\"Information Criterion %s not understood.\\\" % method)\\n\\n return icbest, bestlag, results\",\n \"def maximizer(evaluate):\\n def strategy(player, board):\\n def score_move(move):\\n return evaluate(player, Othello.make_move(move, player, list(board)))\\n return max(Othello.legal_moves(player, board), key=score_move)\\n return strategy\",\n \"def MidpointFnBuilder(max_speed = 26.8, gain = 0.1, beta = 0.5, duration = 500, bias = 1.0, ratio = 0.5):\\n\\n def MidpointFn((idx, car), sim, step):\\n \\\"\\\"\\\"\\n :param idx:\\n :param car:\\n :param sim:\\n :param step:\\n :return:\\n \\\"\\\"\\\"\\n vehID = car[\\\"id\\\"]\\n\\n try:\\n [back_car, front_car] = sim.getCars(idx, numBack=1, numForward=1, lane=car[\\\"lane\\\"])\\n except ValueError:\\n # Not enough cars on lane\\n return\\n\\n front_dist = (front_car[\\\"x\\\"] - car[\\\"x\\\"]) % sim.length\\n back_dist = (car[\\\"x\\\"] - back_car[\\\"x\\\"]) % sim.length\\n\\n curr_speed = car[\\\"v\\\"]\\n front_speed = front_car[\\\"v\\\"]\\n follow_dist = (front_dist + back_dist) * ratio\\n delta = front_dist - follow_dist\\n # print delta, curr_speed, front_speed, curr_speed-front_speed\\n if follow_dist < front_dist and curr_speed < max_speed:\\n # speed up\\n new_speed = min(curr_speed + beta * (front_speed-curr_speed) + gain * delta + bias, max_speed)\\n traci.vehicle.slowDown(vehID, new_speed, duration) # 2.5 sec\\n # print \\\"t=%d, FASTER, %0.1f -> %0.1f (%0.1f) | d=%0.2f = %0.2f vs %0.2f\\\" % \\\\\\n # (step, curr_speed, new_speed, front_speed, delta, front_dist, follow_dist)\\n elif follow_dist > front_dist:\\n # slow down\\n new_speed = max(curr_speed + beta * (front_speed-curr_speed) + gain * delta + bias, 0)\\n traci.vehicle.slowDown(vehID, new_speed, duration) # 2.5 sec\\n # print \\\"t=%d, SLOWER, %0.1f -> %0.1f (%0.1f) | d=%0.2f = %0.2f vs %0.2f\\\" % \\\\\\n # (step, curr_speed, new_speed, front_speed, delta, front_dist, follow_dist)\\n\\n return MidpointFn\",\n \"def optimize(self, iterations=1000):\\r\\n prev = None\\r\\n finalx = None\\r\\n finaly = None\\r\\n while iterations:\\r\\n maxei, eis = self.acquisition()\\r\\n new_y = self.f(maxei)\\r\\n if maxei == prev:\\r\\n break\\r\\n self.gp.update(maxei, new_y)\\r\\n pycodehack = finaly is None or self.minimize and finaly > new_y\\r\\n if ((pycodehack or not self.minimize and finaly < new_y)):\\r\\n finaly = new_y\\r\\n finalx = maxei\\r\\n prev = maxei\\r\\n iterations -= 1\\r\\n return finalx, finaly\",\n \"def _generic_minimize(method, loss, x0,\\n verbose=False,\\n num_iters=1000,\\n tol=1e-4,\\n state=None,\\n full_output=False,\\n suppress_warnings=False,\\n **kwargs):\\n # Flatten the loss\\n _x0, unflatten = flatten(x0)\\n _objective = lambda x_flat, itr: loss(unflatten(x_flat), itr)\\n\\n if verbose:\\n print(\\\"Fitting with {}.\\\".format(method))\\n\\n # Specify callback for fitting\\n itr = [0]\\n def callback(x_flat):\\n itr[0] += 1\\n print(\\\"Iteration {} loss: {:.3f}\\\".format(itr[0], loss(unflatten(x_flat), -1)))\\n\\n # Wrap the gradient to avoid NaNs\\n def safe_grad(x, itr):\\n g = grad(_objective)(x, itr)\\n g[~np.isfinite(g)] = 1e8\\n return g\\n\\n # Call the optimizer. Pass in -1 as the iteration since it is unused.\\n result = minimize(_objective, _x0, args=(-1,),\\n jac=safe_grad,\\n method=method,\\n callback=callback if verbose else None,\\n options=dict(maxiter=num_iters, disp=verbose),\\n tol=tol,\\n **kwargs)\\n if verbose:\\n print(\\\"{} completed with message: \\\\n{}\\\".format(method, result.message))\\n\\n if not suppress_warnings and not result.success:\\n warn(\\\"{} failed with message:\\\\n{}\\\".format(method, result.message))\\n\\n if full_output:\\n return unflatten(result.x), result\\n else:\\n return unflatten(result.x)\",\n \"def tune_parameters(self, parameters, search_alg, num_trials=5, metric=\\\"f1\\\", direction=\\\"maximize\\\", train_ratio=0.7, num_times=1, export_metrics=True):\\n self._clear_cache()\\n model_id = self.model_id\\n if self.comet_key != None:\\n exp = init_experiment(self.comet_key, \\\"model-performance\\\", \\\"covid-vaccine\\\")\\n exp.log_parameters({\\n \\\"model_id\\\":model_id,\\n \\\"model_type\\\":self.embedding_type,\\n \\\"multiclass\\\":self.class_label,\\n \\\"train_ratio\\\":train_ratio,\\n \\\"num_samples\\\":num_trials,\\n \\\"metric\\\":metric,\\n \\\"direction\\\":direction,\\n \\\"search_alg\\\":search_alg\\n })\\n log_fixed_params(parameters, exp)\\n exp.add_tag(\\\"multi\\\" if self.class_label == \\\"Multiclass\\\" else \\\"binary\\\")\\n start = time.time()\\n tr_text, tr_label, self.tr_meta, te_text, te_label, self.te_meta, _ = get_train_test_data(self.seed_fp, self.label_fp, train_ratio=train_ratio, meta_cols=self.meta_cols, drop_irrelevant=self.drop_irrelevant, visualize=False, verbose=self.verbose)\\n self._transform_labels(tr_label, te_label)\\n print(\\\"data loading:\\\", time.time() - start, \\\"seconds\\\\n\\\")\\n start = time.time()\\n self._prepare_feature_components(tr_text, te_text, parameters)\\n print(\\\"total preprocessing:\\\", time.time() - start, \\\"seconds\\\\n\\\")\\n metric_df_parts = []\\n def objective(trial):\\n config = suggest_config(parameters, trial)\\n instances = []\\n for _ in range(num_times):\\n instance_df = self._run_single_config(train_ratio, config)\\n instance_df = instance_df[instance_df[\\\"part\\\"] == \\\"test\\\"]\\n instances.append(instance_df)\\n tmp_df = pd.concat(instances, axis=0)\\n print(\\\"metrics 1\\\", tmp_df.shape)\\n group_cols = list(tmp_df.drop(\\\"score\\\", axis=1).columns)\\n print(group_cols)\\n tmp_df = tmp_df.groupby(group_cols)[\\\"score\\\"].agg([\\\"mean\\\",\\\"std\\\"]).reset_index()\\n print(\\\"metrics 2\\\", tmp_df.shape)\\n metric_df_parts.append(tmp_df)\\n metrics = dict(zip(tmp_df[\\\"metric\\\"],tmp_df[\\\"mean\\\"]))\\n return metrics[metric]\\n if search_alg == \\\"GRID\\\":\\n algo = GridSampler(extract_grid(parameters))\\n elif search_alg == \\\"RND\\\":\\n algo = RandomSampler()\\n elif search_alg == \\\"TPE\\\":\\n algo = TPESampler(n_startup_trials=int(num_trials*0.3))\\n else:#default optuna setting\\n algo = None\\n study = optuna.create_study(direction=\\\"maximize\\\", sampler=algo)\\n study.optimize(objective, n_trials=num_trials, n_jobs=1)\\n metrics_df = pd.concat(metric_df_parts)\\n best_config = study.best_params\\n print(\\\"Best config: \\\", best_config)\\n if export_metrics:\\n result_dir = os.path.join(self.model_dir, \\\"results\\\")\\n if not os.path.exists(result_dir):\\n os.makedirs(result_dir)\\n study_fp = os.path.join(result_dir, \\\"%s.pkl\\\" % model_id)\\n print(\\\"Study file:\\\", study_fp)\\n joblib.dump(study, study_fp)\\n result_fp = os.path.join(result_dir, \\\"%s.csv\\\" % model_id)\\n print(\\\"Output file:\\\", result_fp)\\n metrics_df.to_csv(result_fp, index=False)\\n if self.comet_key != None:\\n exp.log_parameters(best_config)\\n exp.log_metrics({\\n \\\"train_size\\\":len(tr_text),\\n \\\"test_size\\\":len(te_text)\\n })\\n best_results = dict(metrics_df.groupby(\\\"metric\\\")[\\\"mean\\\"].max()[[\\\"f1\\\",\\\"acc\\\",\\\"auc\\\"]])\\n exp.log_metrics(best_results)\\n exp.end()\\n return best_config\",\n \"def optimize(self, state, algorithm, distances):\\n\\n if self.__current_job is not None:\\n raise ServiceError('Optimization in progress. Wait till the end, before submitting next state.', 3)\\n\\n assert isinstance(state, State)\\n assert isinstance(algorithm, Algorithm)\\n assert isinstance(distances, Distances)\\n\\n data = {\\n 'state': json.dumps(state.to_dict()),\\n 'key': self.key,\\n 'distances': json.dumps(distances.to_dict()),\\n 'algorithm': json.dumps(algorithm.to_dict()),\\n 'previous_task': self.__previous_job\\n }\\n\\n try:\\n response = requests.post('{}/api/v1/solve'.format(self.URL), data=data, timeout=10)\\n except (Timeout, ConnectionError):\\n raise ServiceError('Service unavailable: timeout.', 4)\\n\\n result = self._validate(response)\\n self.__current_job = result.get('jid')\\n return self.__current_job\",\n \"def evaluate(Agent, rules, wrappers, params_path=None, steps=1024):\\n\\n score = 0.0\\n\\n agent = Agent()\\n\\n if params_path is not None:\\n agent.load_state_dict(params_path)\\n\\n env = CARLE()\\n\\n\\n for wrapper in wrappers:\\n env = wrapper[0](env)\\n env.reward_scale = wrapper[1]\\n\\n env.batch_size = steps*len(rules)\\n\\n if wrapper[2] is not None:\\n env.load_state_dict(torch.load(wrapper[2]))\\n\\n env.eval()\\n\\n #env.set_no_grad()\\n\\n total_steps = 0\\n score_trace = []\\n for ruleset in rules:\\n\\n env.inner_env.birth = ruleset[0]\\n env.inner_env.survive = ruleset[0]\\n\\n obs = env.reset()\\n\\n for step in range(steps):\\n\\n action = agent(obs)\\n\\n obs, reward, done, info = env.step(action)\\n\\n score += reward.detach().sum().cpu().numpy()\\n score_trace.append(reward.detach().sum().cpu().numpy())\\n\\n total_steps += 1\\n\\n print(\\\"cumulative score = {:.3e} at total steps = {}, rulset = {}\\\".format(\\\\\\n score, total_steps, ruleset))\\n\\n score /= total_steps\\n \\n return score, score_trace\",\n \"def get_optbins(data, method='freedman', ret='N'):\\n x = np.asarray(data)\\n n = x.size\\n r = x.max() - x.min()\\n\\n def sturge():\\n if (n <= 30):\\n print(\\\"Warning: Sturge estimator can perform poorly for small samples\\\")\\n k = int(np.log(n) + 1)\\n h = r / k\\n return h, k\\n\\n def scott():\\n h = 3.5 * np.std(x) * float(n) ** (-1. / 3.)\\n k = int(r / h)\\n return h, k\\n\\n def freedman():\\n q = quantiles(x, [25, 75])\\n h = 2 * (q[75] - q[25]) * float(n) ** (-1. / 3.)\\n k = int(r / h)\\n return h, k\\n\\n def bayesian():\\n r = bayesian_blocks(x)\\n return np.diff(r),r\\n\\n m = {'sturge': sturge, 'scott': scott, 'freedman': freedman,\\n 'bayesian': bayesian}\\n\\n if method.lower() in m:\\n s = m[method.lower()]()\\n if ret.lower() == 'n':\\n return s[1]\\n elif ret.lower() == 'w':\\n return s[0]\\n else:\\n return None\",\n \"def max(x):\\n pass\",\n \"def solve(self, topology, algorithm=\\\"SLSQP\\\", grad=\\\"AD\\\", step_size=1e-6, iters=100, eps=1e-6, kappa=1e-8, tmax=100, eta=1e-6, verbose=False):\\n if verbose:\\n print(\\\"----------\\\")\\n print(\\\"Optimization with {} started!\\\".format(algorithm))\\n print(f\\\"# Parameters: {self.number_of_parameters()}, # Constraints {self.number_of_constraints()}\\\")\\n\\n # test for bad stuff before going any further\\n self.check_optimization_sanity()\\n\\n # compose gradient and objective functions\\n if grad not in (\\\"AD\\\", \\\"FD\\\"):\\n raise ValueError(f\\\"Gradient method {grad} is not supported!\\\")\\n if grad == \\\"AD\\\":\\n if verbose:\\n print(\\\"Computing gradients using automatic differentiation!\\\")\\n x_func = partial(self._optimize_form, topology=topology.copy(), tmax=tmax, eta=eta)\\n grad_func = partial(grad_autograd, grad_func=agrad(x_func)) # x, grad, x_func\\n\\n elif grad == \\\"FD\\\":\\n if verbose:\\n print(f\\\"Warning: Calculating gradients using finite differences with step size {step_size}. This may take a while...\\\")\\n grad_func = self.gradient_func(grad_finite_differences, topology.copy(), tmax, eta, step_size)\\n\\n # grad_func = self.gradient_func(grad_func, topology.copy(), tmax, eta, step_size)\\n obj_func = self.objective_func(topology, grad_func, tmax, eta)\\n\\n # generate optimization variables\\n x = self.optimization_parameters(topology)\\n\\n # extract the lower and upper bounds to optimization variables\\n bounds_low, bounds_up = self.optimization_bounds(topology)\\n\\n # stack keyword arguments\\n hyper_parameters = {\\\"f\\\": obj_func,\\n \\\"algorithm\\\": algorithm,\\n \\\"dims\\\": self.number_of_parameters(),\\n \\\"bounds_low\\\": bounds_low,\\n \\\"bounds_up\\\": bounds_up,\\n \\\"iters\\\": iters,\\n \\\"eps\\\": eps,\\n \\\"ftol\\\": kappa}\\n\\n # assemble optimization solver\\n solver = nlopt_solver(**hyper_parameters)\\n\\n # solve optimization problem\\n x_opt = None\\n start = time()\\n try:\\n x_opt = solver.optimize(x)\\n if verbose:\\n print(\\\"Optimization ended correctly!\\\")\\n except RoundoffLimited:\\n print(\\\"Optimization was halted because roundoff errors limited progress\\\")\\n print(\\\"Results may still be useful though!\\\")\\n x_opt = self.optimization_parameters(topology)\\n except RuntimeError:\\n print(\\\"Optimization failed due to a runtime error!\\\")\\n print(f\\\"Optimization total runtime: {round(time() - start, 4)} seconds\\\")\\n return static_equilibrium(topology)\\n\\n # fetch last optimum value of loss function\\n time_opt = time() - start\\n loss_opt = solver.last_optimum_value()\\n evals = solver.get_numevals()\\n status = nlopt_status(solver.last_optimize_result())\\n\\n # set optimizer attributes\\n self.time_opt = time_opt\\n self.x_opt = x_opt\\n self.penalty = loss_opt\\n self.evals = evals\\n self.status = status\\n\\n # set norm of the gradient\\n # NOTE: np.zeros is a dummy array (signature requirement set by nlopt)\\n self.gradient = grad_func(x_opt, np.zeros(x_opt.size))\\n self.gradient_norm = np.linalg.norm(self.gradient)\\n\\n if verbose:\\n print(f\\\"Optimization total runtime: {round(time_opt, 6)} seconds\\\")\\n print(\\\"Number of evaluations incurred: {}\\\".format(evals))\\n print(f\\\"Final value of the objective function: {round(loss_opt, 6)}\\\")\\n print(f\\\"Norm of the gradient of the objective function: {round(self.gradient_norm, 6)}\\\")\\n print(f\\\"Optimization status: {status}\\\".format(status))\\n print(\\\"----------\\\")\\n\\n # exit like a champion\\n return static_equilibrium(topology)\",\n \"def fit(args):\\n\\n config_file = args.setupfn\\n conf_base = os.path.basename(config_file).split('.')[0]\\n print(\\\"Performing maximum a posteriori fitting for {}\\\".format(conf_base))\\n\\n P, post = radvel.utils.initialize_posterior(config_file, decorr=args.decorr)\\n\\n post = radvel.fitting.maxlike_fitting(post, verbose=True)\\n\\n postfile = os.path.join(args.outputdir,\\n '{}_post_obj.pkl'.format(conf_base))\\n post.writeto(postfile)\\n\\n savestate = {'run': True,\\n 'postfile': os.path.relpath(postfile)}\\n save_status(os.path.join(args.outputdir,\\n '{}_radvel.stat'.format(conf_base)),\\n 'fit', savestate)\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n def MaxValue(gameState, currentDepth, agentNumber):\\n \\n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\\n \\n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\\n return (self.evaluationFunction(gameState), Directions.NORTH)\\n #print 'depth ',currentDepth\\n \\n largestValue = float(\\\"-inf\\\")\\n bestAction = Directions.NORTH\\n for action in gameState.getLegalActions(agentNumber):\\n #print 'analyzing ',action,' for pacman ',agentNumber\\n successor = gameState.generateSuccessor(agentNumber, action)\\n successorValue = MinValue(successor, currentDepth, (agentNumber + 1) % gameState.getNumAgents())[0]\\n if(successorValue > largestValue):\\n largestValue = successorValue\\n bestAction = action\\n return (largestValue, bestAction)\\n \\n def MinValue(gameState, currentDepth, agentNumber):\\n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\\n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\\n return (self.evaluationFunction(gameState), Directions.NORTH)\\n \\n #print 'depth ',currentDepth\\n \\n smallestValue = float(\\\"inf\\\")\\n bestAction = Directions.NORTH \\n for action in gameState.getLegalActions(agentNumber):\\n #print 'analyzing ',action,' for ghost ',agentNumber\\n successor = gameState.generateSuccessor(agentNumber, action)\\n nextAgentNumber = (agentNumber + 1) % gameState.getNumAgents()\\n if nextAgentNumber is 0:\\n successorValue = MaxValue(successor, currentDepth + 1, nextAgentNumber)[0]\\n else:\\n successorValue = MinValue(successor, currentDepth, nextAgentNumber)[0]\\n if(successorValue < smallestValue):\\n smallestValue = successorValue\\n bestAction = action\\n return (smallestValue, bestAction)\\n\\n result = MaxValue(gameState, 0, 0)\\n resultActionToTake = result[1]\\n #print 'Minimax value for depth ', self.depth,' ',result[0]\\n #import time\\n #time.sleep(1000000)\\n return resultActionToTake\",\n \"def test_minimax_regret():\\n f = np.asarray([\\n [0.99, 1.0, 0.5],\\n [0.69, 0.6, 0.6]])\\n R = common_metrics.minimax_regret(f, maximise=True)\\n expected = np.asarray(\\n [-0.1, -0.4])\\n assert np.allclose(R, expected)\\n R = common_metrics.minimax_regret(f, maximise=False)\\n expected = np.asarray(\\n [-0.4, -0.1])\\n assert np.allclose(R, expected)\",\n \"def get_result_function(test_case):\\n if (test_case.direction == 'grad'):\\n return get_grad_results\\n elif (test_case.direction == 'forward'):\\n return get_forward_results\\n else:\\n raise Exception(\\\"Direction provided not recognised\\\")\",\n \"def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\\r\\n\\r\\n\\t\\r\\n\\tif grad == 'NO':\\r\\n\\t\\tif method == 'Powell' :\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'Nelder-Mead':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t options = {'ftol': 0.0001})\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'default':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, \\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\r\\n\\telif grad == 'YES':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \\r\\n \\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\\r\\n\\t\\treturn res.x, res.nit \\r\\n\\t\\t\\t\\r\\n\\t\\t\\r\\n\\telif grad == 'HESS':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\\r\\n\\t\\t\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t\\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \\r\\n\\t\\treturn res.x, res.nit\",\n \"def optimize_svr(data, targets):\\r\\n def svc_crossval(C,epsilon,loss_n):\\r\\n\\r\\n return svc_cv(C=C, epsilon=epsilon,loss_n=loss_n, data=data, targets=targets)\\r\\n\\r\\n optimizer = BayesianOptimization(\\r\\n f=svc_crossval,\\r\\n pbounds={\\\"C\\\": (0.0001, 1000), \\\"epsilon\\\": (0, 0.2),'loss_n':(0,1)},\\r\\n random_state=1234,\\r\\n verbose=2\\r\\n )\\r\\n logger=JSONLogger(path=\\\"./linsvrlogs.json\\\")\\r\\n optimizer.subscribe(Events.OPTMIZATION_STEP,logger)\\r\\n optimizer.maximize(init_points=50,n_iter=300)\\r\\n with open('./linsvrlogs.json','a',encoding='utf-8')as f:\\r\\n f.write(str(optimizer.max))\",\n \"def optimize(self, num_restarts=1, max_iters=100, max_f_eval=300.0, method='Anneal'):\\n dic = DictVectorizer()\\n # flatten the parameters\\n init_params,bounds=dic.fit_transform(self.params)\\n #we minimise minus the marginal likelihood\\n def objective(params_flatten):\\n self.params=dic.inverse_transform(params_flatten,bounds)\\n val = -self.log_marginal_likelihood()\\n return val# we want to maximize it\\n \\n \\n #run ptimisation with multiple restarts\\n optml=np.inf\\n for i in range(num_restarts):\\n #minimise function\\n if method=='Anneal':\\n res=dual_annealing(objective,bounds, maxiter=max_iters, maxfun=max_f_eval, x0=init_params)\\n else:\\n \\n res = minimize(objective, init_params, \\n bounds=bounds, method=method,options={'maxiter': max_iters, 'disp': False})\\n #print(\\\"Iteration \\\"+str(i)+\\\" \\\",-res.fun)\\n if res.fun<optml:\\n params_best=res.x #init_params \\n optml=res.fun\\n init_params=bounds[:,0]+(bounds[:,1]-bounds[:,0])*np.random.rand(len(bounds[:,0]))\\n print(\\\"Iteration \\\"+str(i)+\\\" \\\",-res.fun)\\n #params_best=res.x\\n #optml=res.fun\\n self.params=dic.inverse_transform(params_best,bounds)\\n return -optml\",\n \"def max_hybrid(func: Callable[[Tuple], np.ndarray], over: Tuple[Tuple],\\\\\\n state: Tuple[Union[int, float]], cont: Tuple[bool],\\\\\\n actions: Iterable[Tuple]) -> Tuple[float, Tuple[Union[int, float]], None]:\\n best = -np.inf\\n bestarg = None\\n funcarg = lambda x: -func(np.asarray(x).reshape(1, -1))[0, 0]\\n statebounds = tuple(zip(state, state))\\n for act in actions:\\n actbounds = [b if c else (a, a) for a, c, b in zip(act, cont, over)]\\n init = tuple([*state, *np.random.uniform(*zip(*over))])\\n res = minimize(funcarg, x0=init, bounds=(*statebounds, *actbounds))\\n val = -funcarg(res.x)\\n if val > best:\\n best = val\\n bestarg = res.x\\n return (best, tuple([float(v) if c else int(v) for v, c in \\\\\\n zip(bestarg[len(state):], cont)]), None)\",\n \"def checkgrad(self, target_param=None, verbose=False, step=1e-6, tolerance=1e-3):\\r\\n\\r\\n x = self._get_params_transformed().copy()\\r\\n\\r\\n if not verbose:\\r\\n # just check the global ratio\\r\\n\\r\\n #choose a random direction to find the linear approximation in\\r\\n if x.size==2:\\r\\n dx = step * np.ones(2) # random direction for 2 parameters can fail dure to symmetry\\r\\n else:\\r\\n dx = step * np.sign(np.random.uniform(-1, 1, x.size))\\r\\n\\r\\n # evaulate around the point x\\r\\n f1, g1 = self.objective_and_gradients(x + dx)\\r\\n f2, g2 = self.objective_and_gradients(x - dx)\\r\\n gradient = self.objective_function_gradients(x)\\r\\n\\r\\n numerical_gradient = (f1 - f2) / (2 * dx)\\r\\n global_ratio = (f1 - f2) / (2 * np.dot(dx, np.where(gradient==0, 1e-32, gradient)))\\r\\n\\r\\n return (np.abs(1. - global_ratio) < tolerance) or (np.abs(gradient - numerical_gradient).mean() < tolerance)\\r\\n else:\\r\\n # check the gradient of each parameter individually, and do some pretty printing\\r\\n try:\\r\\n names = self._get_param_names_transformed()\\r\\n except NotImplementedError:\\r\\n names = ['Variable %i' % i for i in range(len(x))]\\r\\n\\r\\n # Prepare for pretty-printing\\r\\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\\r\\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\\r\\n float_len = 10\\r\\n cols = [max_names]\\r\\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\\r\\n cols = np.array(cols) + 5\\r\\n header_string = [\\\"{h:^{col}}\\\".format(h=header[i], col=cols[i]) for i in range(len(cols))]\\r\\n header_string = map(lambda x: '|'.join(x), [header_string])\\r\\n separator = '-' * len(header_string[0])\\r\\n print '\\\\n'.join([header_string[0], separator])\\r\\n\\r\\n if target_param is None:\\r\\n param_list = range(len(x))\\r\\n else:\\r\\n param_list = self.grep_param_names(target_param, transformed=True, search=True)\\r\\n if not np.any(param_list):\\r\\n print \\\"No free parameters to check\\\"\\r\\n return\\r\\n\\r\\n\\r\\n for i in param_list:\\r\\n xx = x.copy()\\r\\n xx[i] += step\\r\\n f1, g1 = self.objective_and_gradients(xx)\\r\\n xx[i] -= 2.*step\\r\\n f2, g2 = self.objective_and_gradients(xx)\\r\\n gradient = self.objective_function_gradients(x)[i]\\r\\n\\r\\n numerical_gradient = (f1 - f2) / (2 * step)\\r\\n ratio = (f1 - f2) / (2 * step * np.where(gradient==0, 1e-312, gradient))\\r\\n difference = np.abs((f1 - f2) / 2 / step - gradient)\\r\\n\\r\\n if (np.abs(1. - ratio) < tolerance) or np.abs(difference) < tolerance:\\r\\n formatted_name = \\\"\\\\033[92m {0} \\\\033[0m\\\".format(names[i])\\r\\n else:\\r\\n formatted_name = \\\"\\\\033[91m {0} \\\\033[0m\\\".format(names[i])\\r\\n r = '%.6f' % float(ratio)\\r\\n d = '%.6f' % float(difference)\\r\\n g = '%.6f' % gradient\\r\\n ng = '%.6f' % float(numerical_gradient)\\r\\n grad_string = \\\"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\\\".format(formatted_name, r, d, g, ng, c0=cols[0] + 9, c1=cols[1], c2=cols[2], c3=cols[3], c4=cols[4])\\r\\n print grad_string\",\n \"def checkgrad(self, target_param = None, verbose=False, step=1e-6, tolerance = 1e-3):\\n\\n x = self._get_params_transformed().copy()\\n\\n if not verbose:\\n #just check the global ratio\\n dx = step*np.sign(np.random.uniform(-1,1,x.size))\\n\\n #evaulate around the point x\\n f1, g1 = self.objective_and_gradients(x+dx)\\n f2, g2 = self.objective_and_gradients(x-dx)\\n gradient = self.objective_function_gradients(x)\\n\\n numerical_gradient = (f1-f2)/(2*dx)\\n global_ratio = (f1-f2)/(2*np.dot(dx,gradient))\\n\\n if (np.abs(1.-global_ratio)<tolerance) and not np.isnan(global_ratio):\\n return True\\n else:\\n return False\\n else:\\n #check the gradient of each parameter individually, and do some pretty printing\\n try:\\n names = self._get_param_names_transformed()\\n except NotImplementedError:\\n names = ['Variable %i'%i for i in range(len(x))]\\n\\n # Prepare for pretty-printing\\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\\n float_len = 10\\n cols = [max_names]\\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\\n cols = np.array(cols) + 5\\n header_string = [\\\"{h:^{col}}\\\".format(h = header[i], col = cols[i]) for i in range(len(cols))]\\n header_string = map(lambda x: '|'.join(x), [header_string])\\n separator = '-'*len(header_string[0])\\n print '\\\\n'.join([header_string[0], separator])\\n\\n if target_param is None:\\n param_list = range(len(x))\\n else:\\n param_list = self.grep_param_names(target_param)\\n\\n for i in param_list:\\n xx = x.copy()\\n xx[i] += step\\n f1, g1 = self.objective_and_gradients(xx)\\n xx[i] -= 2.*step\\n f2, g2 = self.objective_and_gradients(xx)\\n gradient = self.objective_function_gradients(x)[i]\\n\\n numerical_gradient = (f1-f2)/(2*step)\\n ratio = (f1-f2)/(2*step*gradient)\\n difference = np.abs((f1-f2)/2/step - gradient)\\n\\n if (np.abs(ratio-1)<tolerance):\\n formatted_name = \\\"\\\\033[92m {0} \\\\033[0m\\\".format(names[i])\\n else:\\n formatted_name = \\\"\\\\033[91m {0} \\\\033[0m\\\".format(names[i])\\n r = '%.6f' % float(ratio)\\n d = '%.6f' % float(difference)\\n g = '%.6f' % gradient\\n ng = '%.6f' % float(numerical_gradient)\\n grad_string = \\\"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\\\".format(formatted_name,r,d,g, ng, c0 = cols[0]+9, c1 = cols[1], c2 = cols[2], c3 = cols[3], c4 = cols[4])\\n print grad_string\",\n \"def __call__(self, parameters) -> ValueEstimate:\\n # Encode params to json string\\n save_circuit_template_params(parameters, \\\"current_optimization_params.json\\\")\\n with open(\\\"current_optimization_params.json\\\", \\\"r\\\") as f:\\n current_params_string = f.read()\\n\\n # POST params to proxy\\n evaluation_id = self.client.post_argument_values(current_params_string)\\n\\n # POST status to EVALUATING\\n self.client.post_status(\\\"EVALUATING\\\")\\n\\n # WAIT for status to be OPTIMIZING\\n while self.client.get_status() != \\\"OPTIMIZING\\\":\\n time.sleep(1)\\n\\n # GET cost function evaluation from proxy\\n evaluation_string = self.client.get_evaluation_result(evaluation_id)\\n value_estimate = load_value_estimate(io.StringIO(evaluation_string))\\n\\n return value_estimate\",\n \"def optimizing(theta, data = data, target = target):\\n # num = (sin(individual[0] - individual[1] / 8))**2 + (sin(individual[1] + individual[0] / 8))**2\\n # denum = ((individual[0] - 8.6998)**2 + (individual[1] - 6.7665)**2)**0.5 + 1\\n learner = MLPClassifier(hidden_layer_sizes=theta[0], learning_rate_init=theta[1], alpha=theta[2], verbose=True, early_stopping=True, n_iter_no_change=6)\\n\\n model = learner.fit(data, target)\\n return model.best_loss_ # return the best error/residual (best error is cloes to zero) The error of a model is the difference between your predicted outcome and the real observed outcome and therefore 0 is desired\\n\\n # individual as a factor containing x, y = to tetha which \",\n \"def compute_optimalReward(task):\\n\\n\\tT = 15.0\\n\\tweights = 0\\n\\tif task == TABLE_TASK or task == COFFEE_TASK:\\n\\t\\tweights = 1\\n\\telif task == LAPTOP_TASK:\\n\\t\\tweights = 10\\n\\n\\t# initialize start/goal based on task \\n\\tif task == COFFEE_TASK or task == HUMAN_TASK:\\n\\t\\tpick = pick_shelf\\n\\telse:\\n\\t\\tpick = pick_basic\\n\\n\\tif task == LAPTOP_TASK:\\n\\t\\tplace = place_higher\\n\\telse:\\n\\t\\tplace = place_lower\\n\\t\\t\\n\\tstartRad = np.array(pick)*(math.pi/180.0)\\n\\tgoalRad = np.array(place)*(math.pi/180.0)\\n\\tstart = startRad\\n\\tgoal = goalRad\\n\\n\\tplan = Planner(task)\\t\\n\\tfilename = None\\n\\tif task == 1:\\n\\t\\tfilename = \\\"task1.csv\\\"\\n\\telif task == 2:\\n\\t\\tfilename = \\\"task2.csv\\\"\\n\\telif task == 3:\\n\\t\\tfilename = \\\"task3.csv\\\"\\n\\t\\t\\n\\t# get optimal waypts from file\\n\\twaypts = get_opt_waypts(filename)\\n\\tr = plan.featurize(waypts)\\n\\tRvel = r[0]\\n\\tRfeat = np.sum(r[1])\\n\\n\\tplan.kill_planner()\\n\\treturn (Rvel, Rfeat)\",\n \"def get_calculator(self, mode, step=500, ftol=1e-3, FixAngles=False, eVperA=True, md_params={}):\\n if eVperA: ftol *= 0.194469064593167E-01\\n atom_types = set(self.struc.get_chemical_symbols())\\n kwargs = make_Hamiltonian(self.skf_dir, atom_types, self.disp, self.kpts, use_omp=self.use_omp)\\n \\n if mode in ['relax', 'vc-relax']:\\n #kwargs['Driver_'] = 'ConjugateGradient'\\n kwargs['Driver_'] = 'GeometryOptimization'\\n kwargs['Driver_Optimizer'] = 'FIRE {}'\\n #kwargs['Driver_MaxForceComponent'] = ftol\\n kwargs['Driver_MaxSteps'] = step\\n kwargs['Driver_OutputPrefix'] = self.prefix\\n kwargs['Driver_Convergence_'] = ''\\n kwargs['Driver_Convergence_GradElem'] = ftol\\n \\n if mode == 'vc-relax':\\n kwargs['Driver_MovedAtoms'] = \\\"1:-1\\\"\\n kwargs['Driver_LatticeOpt'] = \\\"Yes\\\"\\n if FixAngles:\\n kwargs['Driver_FixAngles'] = \\\"Yes\\\"\\n\\n elif mode in ['nve', 'nvt', 'npt']:\\n # 1fs = 41.3 au\\n # 1000K = 0.0031668 au\\n dicts = {\\n 'temperature': 300,\\n 'pressure': 1e+5, #1atm\\n 'timestep': 1,\\n 'Thermostat': 'NoseHoover',\\n 'MDRestartFrequency': 1000,\\n 'band': 'No',\\n }\\n dicts.update(md_params)\\n\\n kwargs['Analysis_WriteBandOut'] = dicts['band']\\n kwargs['Driver_'] = 'VelocityVerlet'\\n kwargs['Driver_Steps'] = step\\n kwargs['Driver_TimeStep [fs]'] = dicts['timestep']\\n kwargs['Driver_MDRestartFrequency'] = dicts['MDRestartFrequency']\\n kwargs['Driver_MovedAtoms'] = \\\"1:-1\\\"\\n kwargs['Driver_OutputPrefix'] = self.prefix\\n\\n if mode in ['nvt', 'npt']:\\n kwargs['Driver_Thermostat_'] = dicts['Thermostat']\\n kwargs['Driver_Thermostat_Temperature [Kelvin]'] = dicts['temperature']\\n kwargs['Driver_Thermostat_CouplingStrength [cm^-1]'] = 3200\\n\\n if mode == 'npt':\\n kwargs['Driver_Barostat_'] = ''\\n kwargs['Driver_Barostat_Pressure [Pa]'] = dicts['pressure']\\n kwargs['Driver_Barostat_Timescale [ps]'] = 0.1\\n\\n \\n calc = Dftb(label=self.label,\\n #run_manyDftb_steps=True,\\n atoms=self.struc,\\n kpts=self.kpts,\\n **kwargs,\\n )\\n return calc\",\n \"def fit(self, X, y, weights=None, idx=0, verbose=False, early_stop=None, split=None):\\n\\n start_time = timer()\\n self.idx = idx\\n self.split = split\\n\\n # Display Optuna trial messages\\n if not verbose:\\n optuna.logging.set_verbosity(optuna.logging.ERROR)\\n\\n # Single objective optimization\\n if split is None:\\n\\n # Create optuna study maximizing correlation\\n self.study = optuna.create_study(direction='maximize', study_name=self.function)\\n\\n # Set required early stopping variables\\n self.study.early_stop = early_stop\\n self.study.early_stop_count = 0\\n self.study.best_score = None\\n\\n # Start optimization trial\\n try:\\n self.study.optimize(lambda trial: _objective(self, trial, X, y, weights),\\n n_trials=self.n_trials, callbacks=[_single_early_stopping_opt])\\n\\n # Early stopping (not officially supported by Optuna)\\n except optuna.exceptions.OptunaError:\\n pass\\n\\n # Keep only results of best trial for prune and reporting\\n self.res_y = self.res_y[self.study.best_trial.number]\\n self.res_y.name = col_name(self.function, self.study.best_trial.params)\\n self.res_y_corr = self.res_y_corr[self.study.best_trial.number]\\n\\n # Multi objective optimization\\n else:\\n\\n # Create study to maximize eash split\\n sampler = optuna.samplers.NSGAIISampler()\\n self.study = optuna.create_study(directions=(len(split)-1) * ['maximize'], sampler=sampler,\\n study_name=self.function)\\n\\n # Early stopping variables\\n self.study.early_stop = early_stop\\n self.study.early_stop_count = 0\\n\\n # Custom best trial variables (Optuna \\\"best\\\" are immutable)\\n self.study.top_trial = 0\\n self.study.top_params = None\\n self.study.top_value = None\\n\\n # Start optimization trial\\n try:\\n self.study.optimize(lambda trial: _objective(self, trial, X, y, weights, split),\\n n_trials=self.n_trials, callbacks=[_multi_early_stopping_opt])\\n\\n # Early stopping (not officially supported by Optuna)\\n except optuna.exceptions.OptunaError:\\n pass\\n\\n # Validation checks\\n if np.mean(self.study.trials[self.study.top_trial].values) != self.study.top_value:\\n raise RuntimeError(\\\"Top trial score invalid\\\")\\n if len(self.res_y) != len(self.study.trials) or len(self.res_y) != len(self.res_y_corr):\\n raise RuntimeError(\\\"Total results does not equal trials\\\")\\n\\n # Keep only results of best trial for prune and reporting\\n self.res_y = self.res_y[self.study.top_trial]\\n self.res_y.name = col_name(self.function, self.study.trials[self.study.top_trial].params)\\n self.res_y_corr = self.res_y_corr[self.study.top_trial]\\n\\n end_time = timer()\\n self.time = round(end_time - start_time, 2)\\n\\n return self\",\n \"def do_optimisation(self):\\n\\n print('--> Parameters for optimisation:')\\n print('--> Using measurements : {}'.format(self.stoma_cfg.comparison_helper.optimisation_keys))\\n print('')\\n\\n x0 = self.initial_guess()\\n\\n tol, eps = 1e-4, 0.001\\n\\n print('--> Using SLSQP with tol={} and eps={}'.format(tol, eps))\\n\\n soln = opt.minimize(fun=self.optimise_fn,\\n x0=x0,\\n method='SLSQP',\\n tol=tol,\\n options={'eps': eps})\\n\\n print('*' * 120)\\n print('--> Optimisation procedure has finished...')\\n print(soln)\\n print('*' * 120)\\n\\n if soln.success:\\n print('--> Optimisation succeeded. Result is...')\\n self._set_material_parameters(soln.x)\\n print('--> {}'.format(self.material_model))\\n else:\\n print('--> The optimisation failed!')\\n\\n print('*' * 120)\\n\\n return soln\",\n \"def __init__(self, direction, max_momentum, current_momentum=None, max_speed=2, current_speed=0, rowing=False):\\n self.direction = direction\\n self.max_momentum = max_momentum\\n if current_momentum is None:\\n self.current_momentum = self.max_momentum\\n else:\\n self.current_momentum = current_momentum\\n self.max_speed = max_speed\\n self.current_speed = current_speed\\n self.rowing = rowing\",\n \"def quality_control(self, method = \\\"mv\\\", **kwargs):\\n input_col = \\\"result\\\"\\n if input_col not in self.cols:\\n raise Exception(\\\"There is no result for quality control. \\\"\\n \\\"Pease call get_result() to get results first.\\\")\\n\\n output_col = None\\n if method == \\\"mv\\\":\\n output_col = \\\"mv\\\"\\n self.data[output_col] = self.__mv_col(self.data[input_col], **kwargs)\\n elif method == \\\"em\\\":\\n output_col = \\\"em\\\"\\n self.data[output_col] = self.__em_col(self.data[input_col], **kwargs)\\n\\n if output_col == None:\\n raise Exception(str(method)+\\\" is not a valid input.\\\")\\n\\n if output_col not in self.cols:\\n self.cols.append(output_col)\\n\\n return self\",\n \"def optimal_max(board):\\n # Board full?\\n if terminal(board):\\n return [None, utility(board)]\\n\\n available_actions = list(actions(board))\\n\\n # Naive baseline comparison is negative infinity\\n global_optimum = [None, -math.inf]\\n\\n # For each move, what would opponent do next? Update best move.\\n for action in available_actions:\\n # Anticipates optimal adversarial moves\\n local_optimum = optimal_min(result(board, action))\\n\\n # Compares local vs global optima\\n if global_optimum[1] <= local_optimum[1]:\\n global_optimum = [action, local_optimum[1]]\\n\\n return global_optimum\",\n \"def __max_step(self, batch):\\n\\n # short hand and optimizer\\n policy = self.mc.get('policy', target=False)\\n policy_parameters = list(policy.parameters())\\n opt_outer = optim.Adam(policy_parameters, lr=self.outer_lr)\\n\\n # optimize\\n opt_outer.zero_grad()\\n obj = -self.obj(batch)\\n obj.backward()\\n opt_outer.step()\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\n def miniMaxAgent(state, depth, agentIndex):\\n \\n #return evaluation function if game is won or lost or the depth is reached\\n if state.isLose() or state.isWin() or depth == self.depth:\\n return self.evaluationFunction(state)\\n \\n #if agent index is 0 that is pacman so get the maximum value\\n if agentIndex == 0:\\n maximum = float(\\\"-inf\\\")\\n actions = state.getLegalActions(agentIndex) #pacmans legal actions\\n \\n #get successor from all actions and set maximum as the largest value found\\n for action in actions:\\n successor = state.generateSuccessor(agentIndex, action)\\n maximum = max(maximum, miniMaxAgent(successor, depth, 1)) #pass agent index as 1 to move onto the ghosts (min)\\n \\n return maximum\\n \\n #if agent index is greater than 0 it is a ghost so get the minimum value\\n else:\\n minimum = float(\\\"inf\\\")\\n actions = state.getLegalActions(agentIndex)\\n \\n #get successor from all actions and set the minimum to the smallest value found\\n for action in actions:\\n successor = state.generateSuccessor(agentIndex, action) #ghosts legal actions\\n \\n #if all ghosts have found a min, increase depth and set agent back to pacman (max)\\n if state.getNumAgents() -1 == agentIndex:\\n minimum = min(minimum, miniMaxAgent(successor, depth + 1, 0))\\n \\n #increase agent index to get the next ghost\\n else:\\n minimum = min(minimum, miniMaxAgent(successor, depth, agentIndex + 1))\\n return minimum\\n \\n score = float(\\\"-inf\\\")\\n direction = None\\n \\n #get all the legal actions in the game state\\n legalActions = gameState.getLegalActions()\\n \\n #get successor from each action in the game\\n for action in legalActions:\\n successor = gameState.generateSuccessor(0, action)\\n \\n #start at depth 0 and agent index 1\\n value = miniMaxAgent(successor, 0, 1)\\n \\n #find the largest value and set direction to the action that returned that value\\n if score < value:\\n score = value\\n direction = action\\n \\n return direction\\n util.raiseNotDefined()\",\n \"def minimax(self, game, depth):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n\\n \\\"\\\"\\\"\\n From AIMA psuedocode:\\n\\n function MINIMAX-DECISION(state) returns an action\\n return arg max a is in ACTIONS(s) MIN-VALUE(RESULT(state, a))\\n \\\"\\\"\\\"\\n\\n best_move = (-1,-1)\\n best_score = float(\\\"-inf\\\")\\n actions = game.get_legal_moves()\\n\\n if not actions:\\n return best_move\\n else:\\n best_move = actions[randint(0, len(actions) - 1)]\\n\\n try:\\n # The try/except block will automatically catch the exception\\n # raised when the timer is about to expire.\\n # return max(actions, key=lambda action: self._min_value(game.forecast_move(action), 1))\\n for action in actions:\\n score = self._min_value(game.forecast_move(action), 1)\\n if score > best_score:\\n best_score = score\\n best_move = action\\n\\n except SearchTimeout:\\n pass\\n\\n return best_move\",\n \"def optimization_step(self):\\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\\n \\n var_list = [self.x_tilda, self.minibatch_set]\\n \\n if (self.num_samples > 0) and (not self.mixture):\\n \\n if ((self.mf_steps > 0) and self.alpha >0) or\\\\\\n self.gibbs_steps > 0: \\n \\n var_list.append(self.sampler_theta)\\n \\n elif \\\"CD\\\" in self.algorithm:\\n \\n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \\n \\n var_list = [self.minibatch_set]\\n \\n var_list.append(self.learning_rate)\\n \\n if self.use_momentum:\\n \\n var_list.append(self.momentum)\\n \\n output_vars = [self.pseudo_cost]\\n \\n if self.report_p_tilda:\\n \\n output_vars.append(self.p_tilda)\\n \\n else:\\n \\n output_vars.append(theano.shared(0))\\n \\n opt_step = theano.function(inputs = var_list,\\n outputs = output_vars,\\n updates = self.updates,\\n givens = input_dict,\\n on_unused_input='warn')\\n \\n return opt_step\",\n \"def optimize(opt, target, n_agents, n_variables, n_iterations, lb, ub, hyperparams):\\n\\n # Creating the SearchSpace\\n space = SearchSpace(n_agents=n_agents, n_variables=n_variables,\\n n_iterations=n_iterations, lower_bound=lb, upper_bound=ub)\\n\\n # Creating the Function\\n function = Function(pointer=target)\\n\\n # Creating Optimizer\\n if opt.__name__ is not 'BH':\\n optimizer = opt(hyperparams=hyperparams)\\n else:\\n optimizer = opt()\\n\\n # Creating the optimization task\\n task = Opytimizer(space=space, optimizer=optimizer, function=function)\\n\\n return task.start(store_best_only=True)\",\n \"def minimize(fun, \\n bounds = None, \\n value_limit = math.inf,\\n num_retries = 1000,\\n logger = None,\\n workers = mp.cpu_count(),\\n popsize = 31, \\n max_evaluations = 50000, \\n capacity = 500,\\n stop_fittness = None,\\n optimizer = None,\\n ):\\n\\n if optimizer is None:\\n optimizer = de_cma(max_evaluations, popsize, stop_fittness) \\n store = Store(bounds, capacity = capacity, logger = logger)\\n return retry(fun, store, optimizer.minimize, num_retries, value_limit, workers)\",\n \"def optimize(\\n self, n, tol=None, jac=True, hessp=False, optlib=\\\"scipy\\\", **options\\n ):\\n return {\\\"scipy\\\": self.optimize_scipy, \\\"nlopt\\\": self.optimize_nlopt,}[\\n optlib\\n ](n=n, tol=tol, jac=jac, hessp=hessp, **options)\",\n \"def optimize(maxiter: int = 1000,\\n tol = None,\\n save_steps: int = 1,\\n c0: float = 0.62,\\n c1: float = 0.1,\\n c2: float = 0.602,\\n c3: float = 0.101,\\n c4: float = 0):\\n _spsa_vars = [c0, c1, c2, c3, c4]\\n theta = self.vectorizer.vector\\n nb_params = len(theta)\\n use_exact_grads = 'grads' in self._method\\n \\n if save_steps:\\n theta_vec = [theta]\\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\\n \\n \\n pbar = tqdm(total=maxiter, disable=not self.progbar)\\n def callback(_):\\n pbar.clear()\\n pbar.update()\\n val = round(self.loss, 5)\\n pbar.set_description(str(val))\\n\\n if self.loss_target is not None:\\n if self.loss < self.loss_target:\\n # returning True doesn't terminate optimization\\n pbar.close()\\n raise KeyboardInterrupt\\n \\n for ii in range(maxiter):\\n \\n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\\n delta = 2 * randint(0, 2, size=nb_params) - 1\\n # plus and minus directions\\n \\n if use_exact_grads:\\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\\n else:\\n theta_plus = theta + c_spsa * delta\\n theta_minus = theta - c_spsa * delta\\n\\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\\n # derivative estimate\\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\\n # updated theta\\n theta = theta - a_spsa * g_spsa\\n \\n callback(ii)\\n \\n if tol is not None:\\n if (cost_plus + cost_minus)/2 < tol:\\n pbar.close()\\n break\\n \\n if save_steps:\\n theta_vec.append(theta)\\n cost_vec.append(cost_plus/2+cost_minus/2)\\n \\n \\n result_dict = {'hyper_parameters':_spsa_vars,\\n 'maxiter':maxiter,\\n 'theta_opt':theta,\\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\\n if save_steps:\\n result_dict['theta_history'] = theta_vec\\n result_dict['cost_history'] = cost_vec\\n self.result_dict = result_dict\\n pbar.close()\\n\\n return self.inject_res_vector_and_return_tn()\",\n \"def hyperopt_fmin(\\n fn,\\n space,\\n algo,\\n max_evals=sys.maxsize,\\n timeout=None,\\n loss_threshold=None,\\n trials=None,\\n rstate=None,\\n allow_trials_fmin=True,\\n pass_expr_memo_ctrl=None,\\n catch_eval_exceptions=False,\\n verbose=True,\\n return_argmin=True,\\n points_to_evaluate=None,\\n max_queue_len=1,\\n show_progressbar=True,\\n # early_stop_fn=None,\\n):\\n if rstate is None:\\n env_rseed = os.environ.get(\\\"HYPEROPT_FMIN_SEED\\\", \\\"\\\")\\n if env_rseed:\\n rstate = np.random.RandomState(int(env_rseed))\\n else:\\n rstate = np.random.RandomState()\\n\\n validate_timeout(timeout)\\n validate_loss_threshold(loss_threshold)\\n\\n if allow_trials_fmin and hasattr(trials, \\\"fmin\\\"):\\n assert False\\n # return trials.fmin(\\n # fn,\\n # space,\\n # algo=algo,\\n # max_evals=max_evals,\\n # timeout=timeout,\\n # loss_threshold=loss_threshold,\\n # max_queue_len=max_queue_len,\\n # rstate=rstate,\\n # pass_expr_memo_ctrl=pass_expr_memo_ctrl,\\n # verbose=verbose,\\n # catch_eval_exceptions=catch_eval_exceptions,\\n # return_argmin=return_argmin,\\n # show_progressbar=show_progressbar,\\n # early_stop_fn=early_stop_fn,\\n # )\\n\\n if trials is None:\\n if points_to_evaluate is None:\\n trials = base.Trials()\\n else:\\n assert type(points_to_evaluate) == list\\n trials = generate_trials_to_calculate(points_to_evaluate)\\n\\n domain = base.Domain(fn, space, pass_expr_memo_ctrl=pass_expr_memo_ctrl)\\n\\n rval = FMinIter(\\n algo,\\n domain,\\n trials,\\n max_evals=max_evals,\\n timeout=timeout,\\n loss_threshold=loss_threshold,\\n rstate=rstate,\\n verbose=verbose,\\n max_queue_len=max_queue_len,\\n show_progressbar=show_progressbar,\\n # early_stop_fn=early_stop_fn,\\n )\\n rval.catch_eval_exceptions = catch_eval_exceptions\\n\\n # next line is where the fmin is actually executed\\n rval.exhaust()\\n\\n if len(trials.trials) == 0:\\n raise Exception(\\n \\\"There are no evaluation tasks, cannot return argmin of task losses.\\\"\\n )\\n return trials\",\n \"def optimize(self, args):\\n\\n ############################\\n # Get the data\\n ############################\\n\\n # Read the CSV file ignoring the header and the first column (which\\n # contains the file name of the image used for extracting the data in\\n # a row)\\n try:\\n data = np.genfromtxt(args.featuresFile, delimiter=',',\\n skip_header=1)\\n data = data[:, 1:]\\n except:\\n print('Could not read CSV file: {}'.format(args.featuresFile))\\n return -1\\n\\n x = data[:, :-1]\\n y = np.squeeze(data[:, -1:])\\n\\n ############################\\n # Execute the optimization\\n ############################\\n\\n tunningParams = [\\n {\\n 'kernel': ['linear'],\\n 'C': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3]\\n },\\n {\\n 'kernel': ['rbf'],\\n 'gamma': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3],\\n 'C': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3]\\n },\\n ]\\n\\n scores = ['precision', 'recall']\\n\\n for score in scores:\\n print('# Tuning hyper-parameters for {}\\\\n'.format(score))\\n\\n clf = GridSearchCV(svm.SVC(C=1), tunningParams, cv=5,\\n scoring=format('{}_macro'.format(score)))\\n clf.fit(x, y)\\n\\n print('Best parameters set found on development set:\\\\n')\\n print(clf.best_params_)\\n\\n print('\\\\nGrid scores on development set:\\\\n')\\n means = clf.cv_results_['mean_test_score']\\n stds = clf.cv_results_['std_test_score']\\n for mean, std, params in zip(means, stds, clf.cv_results_['params']):\\n print('{:.3f} (+/-{:.3f}) for {}'.format(mean, std * 2, params))\\n\\n #print('\\\\nDetailed classification report:\\\\n')\\n #print('The model is trained on the full development set.')\\n #print('The scores are computed on the full evaluation set.\\\\n')\\n #y_true, y_pred = y_test, clf.predict(X_test)\\n #print(classification_report(y_true, y_pred))\\n #print()\\n\\n return 0\",\n \"def smooth_objective(self, x, mode='both', check_feasibility=False):\\n\\n x = self.apply_offset(x)\\n if self.Q is None:\\n if mode == 'both':\\n f, g = self.scale(np.linalg.norm(x)**2) / 2., self.scale(x)\\n return f, g\\n elif mode == 'grad':\\n f, g = None, self.scale(x)\\n return g\\n elif mode == 'func':\\n f, g = self.scale(np.linalg.norm(x)**2) / 2., None\\n return f\\n else:\\n raise ValueError(\\\"mode incorrectly specified\\\")\\n else:\\n if mode == 'both':\\n f, g = self.scale(np.sum(x * self.Q_transform.linear_map(x))) / 2., self.scale(self.Q_transform.linear_map(x))\\n return f, g\\n elif mode == 'grad':\\n f, g = None, self.scale(self.Q_transform.linear_map(x))\\n return g\\n elif mode == 'func':\\n f, g = self.scale(np.sum(x * self.Q_transform.linear_map(x))) / 2., None\\n return f\\n else:\\n raise ValueError(\\\"mode incorrectly specified\\\")\",\n \"def _optimize(self, X, y, W, steps):\\n\\n X = X.flatten(1)\\n\\n min_x, max_x = X.min(), X.max()\\n len_x = max_x - min_x\\n \\n bestd = 1\\n bestp = min_x\\n minerr = W.sum()\\n\\n if len_x > 0.0:\\n for p in np.arange(min_x, max_x, len_x/steps):\\n for d in [-1, 1]:\\n gy = np.ones((y.size))\\n gy[X*d < p*d] = -1\\n err = np.sum((gy != y)*W)\\n if err < minerr:\\n minerr = err\\n bestd = d\\n bestp = p\\n\\n return minerr, bestd, bestp\",\n \"def maximize_scalar(max_func, *args, **kwargs):\\n def min_func(*args):\\n return -max_func(*args)\\n\\n res = minimize_scalar(min_func, *args, **kwargs)\\n\\n # we have to negate the function value before returning res\\n res.fun = -res.fun\\n return res\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7191519","0.6706924","0.62114525","0.5192495","0.513346","0.5125227","0.5031708","0.5031085","0.49857607","0.4900932","0.4900832","0.48536816","0.48484892","0.48352584","0.47795326","0.4738466","0.47372732","0.4712714","0.47082347","0.46975875","0.46776056","0.46617213","0.46198747","0.46082246","0.46049652","0.45998055","0.45998055","0.459973","0.45942575","0.45911443","0.45870975","0.45712292","0.45703897","0.45621946","0.45416775","0.44833645","0.44448864","0.44421008","0.44287887","0.44245195","0.44222125","0.4419324","0.4418649","0.44148538","0.44096664","0.4393647","0.43907708","0.4389955","0.43793526","0.43784168","0.43692392","0.43582","0.43348995","0.43295544","0.4323695","0.43134767","0.43049172","0.42920327","0.42795235","0.4277862","0.42671573","0.42664927","0.4265488","0.42634907","0.4257535","0.4249081","0.42446166","0.42427802","0.42422438","0.42302474","0.42269227","0.42208806","0.42200273","0.42158663","0.42011994","0.41946754","0.41900873","0.41821098","0.41722193","0.41654646","0.41512775","0.41491294","0.41411236","0.41409004","0.413662","0.41337866","0.412173","0.41215858","0.41159394","0.411504","0.41103283","0.41046515","0.41027045","0.4099583","0.40980396","0.40908608","0.4088149","0.4087087","0.40865126","0.40796027"],"string":"[\n \"0.7191519\",\n \"0.6706924\",\n \"0.62114525\",\n \"0.5192495\",\n \"0.513346\",\n \"0.5125227\",\n \"0.5031708\",\n \"0.5031085\",\n \"0.49857607\",\n \"0.4900932\",\n \"0.4900832\",\n \"0.48536816\",\n \"0.48484892\",\n \"0.48352584\",\n \"0.47795326\",\n \"0.4738466\",\n \"0.47372732\",\n \"0.4712714\",\n \"0.47082347\",\n \"0.46975875\",\n \"0.46776056\",\n \"0.46617213\",\n \"0.46198747\",\n \"0.46082246\",\n \"0.46049652\",\n \"0.45998055\",\n \"0.45998055\",\n \"0.459973\",\n \"0.45942575\",\n \"0.45911443\",\n \"0.45870975\",\n \"0.45712292\",\n \"0.45703897\",\n \"0.45621946\",\n \"0.45416775\",\n \"0.44833645\",\n \"0.44448864\",\n \"0.44421008\",\n \"0.44287887\",\n \"0.44245195\",\n \"0.44222125\",\n \"0.4419324\",\n \"0.4418649\",\n \"0.44148538\",\n \"0.44096664\",\n \"0.4393647\",\n \"0.43907708\",\n \"0.4389955\",\n \"0.43793526\",\n \"0.43784168\",\n \"0.43692392\",\n \"0.43582\",\n \"0.43348995\",\n \"0.43295544\",\n \"0.4323695\",\n \"0.43134767\",\n \"0.43049172\",\n \"0.42920327\",\n \"0.42795235\",\n \"0.4277862\",\n \"0.42671573\",\n \"0.42664927\",\n \"0.4265488\",\n \"0.42634907\",\n \"0.4257535\",\n \"0.4249081\",\n \"0.42446166\",\n \"0.42427802\",\n \"0.42422438\",\n \"0.42302474\",\n \"0.42269227\",\n \"0.42208806\",\n \"0.42200273\",\n \"0.42158663\",\n \"0.42011994\",\n \"0.41946754\",\n \"0.41900873\",\n \"0.41821098\",\n \"0.41722193\",\n \"0.41654646\",\n \"0.41512775\",\n \"0.41491294\",\n \"0.41411236\",\n \"0.41409004\",\n \"0.413662\",\n \"0.41337866\",\n \"0.412173\",\n \"0.41215858\",\n \"0.41159394\",\n \"0.411504\",\n \"0.41103283\",\n \"0.41046515\",\n \"0.41027045\",\n \"0.4099583\",\n \"0.40980396\",\n \"0.40908608\",\n \"0.4088149\",\n \"0.4087087\",\n \"0.40865126\",\n \"0.40796027\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63557446"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":10487,"cells":{"query":{"kind":"string","value":"optimizes the current library to maximize the result of the target function using gradient descent. By default, the function returns the best value and the associated interaction matrix as result. `direction` is either 'min' or 'max' and determines whether a minimum or a maximum is sought. `steps` determines how many optimization steps we try `multiprocessing` is a flag deciding whether multiple processes are used to calculate the result. Note that this has an overhead and might actually decrease overall performance for small problems `ret_info` determines whether extra information is returned from the optimization `args` is a dictionary of additional arguments that is passed to the target function"},"document":{"kind":"string","value":"def optimize_library_descent(self, target, direction='max', steps=100,\n multiprocessing=False, ret_info=False,\n args=None):\n # get the target function to call\n target_function = getattr(self, target)\n if args is not None:\n target_function = functools.partial(target_function, **args)\n\n # initialize the optimizer\n value = target_function()\n value_best, state_best = value, self.sens_mat.copy()\n \n if ret_info:\n # store extra information\n start_time = time.time()\n info = {'values': {}}\n values_count = self.parameters['optimizer_values_count']\n values_step = max(1, steps // values_count)\n \n if multiprocessing:\n # run the calculations in multiple processes\n pool_size = self.get_number_of_cores()\n pool = mp.Pool(processes=pool_size)\n if ret_info:\n values_step = max(1, values_step // pool_size)\n \n # iterate for given number of steps\n for step in range(int(steps) // pool_size):\n joblist = []\n init_arguments = self.init_arguments\n for _ in range(pool_size):\n # modify the current state and add it to the job list\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n params = init_arguments['parameters'] \n params['sensitivity_matrix'] = self.sens_mat\n params['initialize_state']['sensitivity'] = 'exact'\n \n joblist.append((copy.deepcopy(init_arguments), target))\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # run all the jobs\n results = pool.map(_run_job, joblist)\n \n # find the best result \n if direction == 'max':\n res_best = np.argmax(results)\n if results[res_best] > value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n elif direction == 'min':\n res_best = np.argmin(results)\n if results[res_best] < value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n else:\n raise ValueError('Unsupported direction `%s`' % direction)\n \n if ret_info and step % values_step == 0:\n info['values'][step * pool_size] = results[res_best]\n \n else:\n # run the calculations in this process\n for step in range(int(steps)):\n # modify the current state\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # get the value of the new state\n value = target_function()\n \n improved = ((direction == 'max' and value > value_best) or\n (direction == 'min' and value < value_best))\n if improved:\n # save the state as the new best value\n value_best, state_best = value, self.sens_mat.copy()\n else:\n # undo last change\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n if ret_info and step % values_step == 0:\n info['values'][step] = value_best\n\n # sort the best state and store it in the current object\n state_best = self.sort_sensitivity_matrix(state_best)\n self.sens_mat = state_best.copy()\n\n if ret_info:\n info['total_time'] = time.time() - start_time \n info['states_considered'] = steps\n info['performance'] = steps / info['total_time']\n return value_best, state_best, info\n else:\n return value_best, state_best"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def optimize_library_descent_multiple(self, target, direction='max',\n trials=4, multiprocessing=False,\n ret_error=False, **kwargs):\n \n # pass some parameters down to the optimization function to call\n kwargs['target'] = target\n kwargs['direction'] = direction\n \n # initialize the list of jobs with an optimization job starting from the\n # current interaction matrix\n joblist = [(self.init_arguments, 'optimize_library_descent', kwargs)]\n sens_mat = self.sens_mat #< store matrix to restore it later\n\n # set the ensemble of sensitivity matrices to try\n self.choose_sensitivity_matrix(density='auto')\n self.parameters['initialize_state']['sensitivity'] = 'ensemble'\n\n # add additional jobs with random initial interaction matrices\n init_arguments = self.init_arguments\n for _ in range(trials - 1):\n joblist.append((copy.deepcopy(init_arguments),\n 'optimize_library_descent', kwargs))\n \n # restore interaction matrix of this object\n self.sens_mat = sens_mat\n \n if multiprocessing:\n # calculate all results in parallel\n pool = mp.Pool(processes=self.get_number_of_cores())\n result_iter = pool.imap_unordered(_run_job, joblist)\n \n else:\n # create a generator over which we iterate later\n result_iter = (_run_job(job) for job in joblist)\n \n # find the best result by iterating over all results\n result_best, values = None, []\n for result in result_iter:\n values.append(result[0])\n # check whether this run improved the result\n if result_best is None:\n result_best = result\n elif ((direction == 'max' and result[0] > result_best[0]) or\n (direction == 'min' and result[0] < result_best[0])):\n result_best = result\n \n # sort the best state and store it in the current object\n state = self.sort_sensitivity_matrix(result_best[1])\n self.sens_mat = state.copy()\n\n if ret_error:\n # replace the best value by a tuple of the best value and its error\n value_best = result_best[0]\n value_err = np.abs(value_best - np.median(values))\n result_best = ((value_best, value_err), ) + result_best[1:]\n return result_best","def optimize_library_anneal(self, target, direction='max', steps=100,\n ret_info=False, args=None):\n # lazy import\n from .optimizer import ReceptorOptimizerAnnealer # @UnresolvedImport\n \n # prepare the class that manages the simulated annealing\n annealer = ReceptorOptimizerAnnealer(self, target, direction, args,\n ret_info=ret_info)\n annealer.steps = int(steps)\n annealer.Tmax = self.parameters['anneal_Tmax']\n annealer.Tmin = self.parameters['anneal_Tmin']\n if self.parameters['verbosity'] == 0:\n annealer.updates = 0\n\n # do the optimization\n MI, state = annealer.optimize()\n\n # sort the best state and store it in the current object\n state = self.sort_sensitivity_matrix(state)\n self.sens_mat = state.copy()\n \n if ret_info:\n return MI, state, annealer.info\n else:\n return MI, state","def optimize_library(self, target, method='descent', direction='max',\n **kwargs):\n if method == 'descent':\n return self.optimize_library_descent(target, direction, **kwargs)\n elif method == 'descent_multiple' or method == 'descent-multiple':\n return self.optimize_library_descent_multiple(target, direction,\n **kwargs)\n elif method == 'anneal':\n return self.optimize_library_anneal(target, direction, **kwargs)\n \n else:\n raise ValueError('Unknown optimization method `%s`' % method)","def Optimization(*args, **kwargs):\n from warnings import warn\n\n warn(\n \"Optimization has been renamed to OptimizationResult and will be removed as soon as v0.13.0\", DeprecationWarning\n )\n return OptimizationResult(*args, **kwargs)","def optimize(self, max_iters=1e3, messages=False, use_counter=False,\\\n factr=1e7, pgtol=1e-05):\n logger.debug('Beginning MLE to optimize hyperparams. grad_method=%s'\\\n % self.grad_method)\n\n # setup the optimization\n try:\n x0 = self._transform_parameters(self.parameters)\n assert np.all(np.isfinite(x0))\n except:\n logger.error('Transformation failed for initial values. '\\\n + 'Ensure constraints are met or the value is not too small.')\n raise\n\n # filter out the fixed parameters\n free = np.logical_not(self._fixed_indicies)\n x0 = x0[free]\n\n # setup the counter\n if use_counter:\n self._counter = solver_counter(disp=True)\n else:\n self._counter = None\n\n # run the optimization\n try:\n x_opt, f_opt, opt = fmin_l_bfgs_b(func=self._objective_grad, x0=x0,\\\n factr=factr, pgtol=pgtol, maxiter=max_iters, disp=messages)\n except (KeyboardInterrupt,IndexError):\n logger.info('Keyboard interrupt raised. Cleaning up...')\n if self._counter is not None and self._counter.backup is not None:\n self.parameters = self._counter.backup[1]\n logger.info('will return best parameter set with'\\\n + 'log-likelihood = %.4g' % self._counter.backup[0])\n else:\n logger.info('Function Evals: %d. Exit status: %s' % (f_opt, opt['warnflag']))\n # extract the optimal value and set the parameters to this\n transformed_parameters = self._previous_parameters \n transformed_parameters[free] = x_opt\n self.parameters = self._untransform_parameters(transformed_parameters)\n return opt","def Optimise(LogLikelihood,par,func_args,fixed=None,type='max',method='NM',maxiter=10000, maxfun=10000, verbose=True):\n \n if fixed==None:\n var_par = np.copy(par)\n #otherwise construct the parameter vector from var_par and fixed_par_val\n else:\n par = np.array(par)\n fixed = np.array(fixed) #ensure fixed is a np array\n #assign parameters to normal param vector\n fixed_par = par[np.where(fixed==True)]\n var_par = par[np.where(fixed!=True)]\n \n #set the algorithm to use - CG and P not working (at least not well)\n add_kwords = {'verbose':verbose}\n if method == 'NM':\n Algorithm = NelderMead\n add_kwords = {'maxiter':maxiter, 'maxfun':maxfun,'verbose':verbose}\n elif method == 'CG':\n print \"warning: CG method didn't work properly during testing\"\n Algorithm = ConjugateGradient\n elif method == 'P':\n print \"warning: Powell algorithm didn't work properly during testing\"\n Algorithm = Powell\n else:\n print \"error: optimisation function not found\"\n return par\n \n #set the optimisation function to pos or neg for the fmin funcitons\n if type == 'max': OptFunc = NegFixedPar_func\n elif type == 'min': OptFunc = FixedPar_func\n else:\n print \"error: %s not a valid option\" % type\n return par\n \n #call the optimser with the appropriate function\n fitted_par = Algorithm(OptFunc, var_par, (LogLikelihood,func_args,fixed,fixed_par), \\\n **add_kwords)\n \n #now return the params in the correct order...\n if fixed==None:\n return_par = fitted_par\n else:\n return_par = np.copy(par) \n return_par[np.where(fixed!=True)] = fitted_par\n \n return return_par","def opt_wrapper(m, **kwargs):\r\n m.optimize(**kwargs)\r\n return m.optimization_runs[-1]","def opt_wrapper(m, **kwargs):\n m.optimize(**kwargs)\n return m.optimization_runs[-1]","def __call__(self, origin, state, **kwargs):\n fun = kwargs['function']\n d = state['direction']/np.linalg.norm(state['direction'])\n # filter directions that are too large\n if self.filter:\n ndabs_log = -np.log10(np.abs(d))\n mean_log = np.mean(ndabs_log)\n #print \"\\n ** MEAN =\", mean_log\n direction = (ndabs_log > mean_log-1.5).astype(int)*d\n else:\n direction = d\n state['direction'] = direction\n## for pos, d in enumerate(direction):\n## use_dir = self.use_dirs[pos]\n## if use_dir * d < 0:\n## # directions don't match so don't move in this direction\n## direction[pos] = 0\n maxStepSize = self.maxStepSize\n if np.isscalar(maxStepSize):\n stepSize = maxStepSize\n else:\n stepfacs = np.zeros(self.dim)\n for d in range(self.dim):\n # explicit loop so as to catch any ZeroDivisionErrors\n try:\n stepfacs[d] = abs(maxStepSize[d] / direction[d])\n except ZeroDivisionError:\n # Direction is orthogonal to this parameter direction,\n # so ensure won't choose this as the minimum step size\n stepfacs[d] = Inf\n # Stop stepping with giant sizes if direction vector has strong\n # separation of scales\n stepSize = min(stepfacs)\n# print \"direction = \", direction\n# print \"step = \", step\n i = 1\n old_value = state['old_value']\n not_done = True\n# print \"** TEMP: Hardwiring step size to be 0.0005\"\n# stepSize = 0.0005\n init_step = stepSize\n while not_done:\n print(\"\\nLinestep: i =\", i, \"step size =\", stepSize, \"direction =\\n\", end='')\n print(direction)\n p = origin + i * stepSize * direction\n print(\"Testing p = \", p)\n new_value = fun(p)\n if new_value < old_value:\n i += 1\n old_value = new_value\n else:\n if i == 1:\n # don't shrink step size to be less than 1/maxReduceFac of initial\n if stepSize*self.maxReduceFac < init_step:\n not_done = False\n p = origin + (i-1) * stepSize * direction\n else:\n stepSize /= self.stepMod\n else:\n # had found a working step but it's no longer stepping to lower residuals\n not_done = False\n p = origin + (i-1) * stepSize * direction\n state['alpha_step'] = stepSize\n return p","def optimization_step(self):\n \n if \"CSS\" in self.algorithm:\n \n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\n \n var_list = [self.x_tilda, self.minibatch_set]\n \n if (self.num_samples > 0) and (not self.mixture):\n \n if ((self.mf_steps > 0) and self.alpha >0) or\\\n self.gibbs_steps > 0: \n \n var_list.append(self.sampler_theta)\n \n elif \"CD\" in self.algorithm:\n \n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \n \n var_list = [self.minibatch_set]\n \n var_list.append(self.learning_rate)\n \n if self.use_momentum:\n \n var_list.append(self.momentum)\n \n output_vars = [self.pseudo_cost]\n \n if self.report_p_tilda:\n \n output_vars.append(self.p_tilda)\n \n else:\n \n output_vars.append(theano.shared(0))\n \n opt_step = theano.function(inputs = var_list,\n outputs = output_vars,\n updates = self.updates,\n givens = input_dict,\n on_unused_input='warn')\n \n return opt_step","def optimize(maxiter: int = 1000,\n tol = None,\n save_steps: int = 1,\n c0: float = 0.62,\n c1: float = 0.1,\n c2: float = 0.602,\n c3: float = 0.101,\n c4: float = 0):\n _spsa_vars = [c0, c1, c2, c3, c4]\n theta = self.vectorizer.vector\n nb_params = len(theta)\n use_exact_grads = 'grads' in self._method\n \n if save_steps:\n theta_vec = [theta]\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\n \n \n pbar = tqdm(total=maxiter, disable=not self.progbar)\n def callback(_):\n pbar.clear()\n pbar.update()\n val = round(self.loss, 5)\n pbar.set_description(str(val))\n\n if self.loss_target is not None:\n if self.loss < self.loss_target:\n # returning True doesn't terminate optimization\n pbar.close()\n raise KeyboardInterrupt\n \n for ii in range(maxiter):\n \n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\n delta = 2 * randint(0, 2, size=nb_params) - 1\n # plus and minus directions\n \n if use_exact_grads:\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\n else:\n theta_plus = theta + c_spsa * delta\n theta_minus = theta - c_spsa * delta\n\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\n # derivative estimate\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\n # updated theta\n theta = theta - a_spsa * g_spsa\n \n callback(ii)\n \n if tol is not None:\n if (cost_plus + cost_minus)/2 < tol:\n pbar.close()\n break\n \n if save_steps:\n theta_vec.append(theta)\n cost_vec.append(cost_plus/2+cost_minus/2)\n \n \n result_dict = {'hyper_parameters':_spsa_vars,\n 'maxiter':maxiter,\n 'theta_opt':theta,\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\n if save_steps:\n result_dict['theta_history'] = theta_vec\n result_dict['cost_history'] = cost_vec\n self.result_dict = result_dict\n pbar.close()\n\n return self.inject_res_vector_and_return_tn()","def optimize(self, X, y, *args):\n self.loss_function.set_space(X, y, *args)\n self.betas_ = fastgradalgo(\n self.loss_function,\n t_init=self.eta_init,\n max_iter=self.max_iter\n )\n return self.betas_","def optimize(self, coords_batch: SameSizeCoordsBatch, energy_helper):\n\n a_coords = coords_batch.coords\n n_total_confs = a_coords.shape[0]\n n_atoms = a_coords.shape[1]\n \n func_evals = 0\n\n # evaluate initial f(x) and df/dx\n loss, std = energy_helper.compute_energy() # loss[nConf]\n st = OptState(self, n_total_confs, n_atoms, loss.dtype)\n st.loss = loss\n st.std = std\n min_loss = st.loss.detach().clone()\n \n minE_no_constraints = energy_helper.energy_no_constraint().detach().clone()\n min_std = torch.full_like(minE_no_constraints, -1)\n st.flat_grad = energy_helper.compute_grad().reshape(st.n_confs,-1)\n min_grad_square_max = torch.full((n_total_confs,), 9e20, dtype=a_coords.dtype, device=self.device)\n #st.abs_grad_sum = st.flat_grad.abs().sum(1)\n \n status = torch.zeros((n_total_confs,),dtype=torch.uint8, device=self.device)\n is_active = torch.ones((n_total_confs,), dtype=torch.uint8, device=self.device).bool()\n conf_steps = torch.full((n_total_confs,), -1, dtype=torch.int16, device=self.device)\n minE_coords = a_coords.detach().clone()\n minE_grad = torch.full((n_total_confs,n_atoms*3), -999, dtype=a_coords.dtype, device=self.device)\n \n current_evals = 1\n func_evals += 1\n n_iter = 0\n\n # optimize for a max of max_iter iterations\n while n_iter < self.convergence_opts.max_iter:\n # keep track of nb of iterations\n n_iter += 1\n\n ############################################################\n # compute gradient descent direction\n ############################################################\n if n_iter == 1:\n st.d = st.flat_grad.neg()\n else:\n # d: direction of step\n # s: step = direction * trust of step\n # y: delta gradient in step (grad - prev_grad) = vector of gradient change\n # ys: sum(y * step) \n # do lbfgs update (update memory)\n y = st.flat_grad.sub(st.prev_flat_grad)\n \n s = st.d*st.t.reshape(-1,1)\n \n ys = torch.sum(y * s, dim=1)\n \n is_valid_step = ys > 1e-10 # DIAL BACK TO 10E-6,4,5, look at RFO, rational function optimization\n # reach out to lee-ping or roland king (optking)\n # try occasionally setting h_diag to 1\n # look into getting code from psi4 to convert, (little bit of a mess) cartesian to internal pyoptking\n # pyberny: has nicer code for internal coordinates\n # maybe can get initial hessian guess in internal coordinates and project back to xyz and use as first guess\n st.old_dirs.push_if(is_valid_step, y)\n st.old_stps.push_if(is_valid_step, s)\n y = y[is_valid_step] \n st.H_diag[is_valid_step] = ys[is_valid_step] / torch.sum(y * y, dim=1)\n d_not_valid_steps = st.flat_grad[~is_valid_step].neg() #d[~is_valid_step]\n \n # compute the approximate (L-BFGS) inverse Hessian\n # multiplied by the gradient\n \n ro = 1. / torch.sum(st.old_dirs.container * st.old_stps.container, dim=2)\n ro[torch.isinf(ro)] = 1e-10\n\n al = torch.zeros((self.history_size,st.n_confs), dtype=loss.dtype, device=self.device)\n \n num_old = st.old_dirs.count_hist.max()\n# log.debug(\"old_dirs {}\\n{}\".format(num_old, st.old_dirs.container[0:num_old]))\n \n q = st.flat_grad.neg()\n for i in range(num_old):\n al[i] = torch.sum(st.old_stps.container[i]* q, dim=1) * ro[i]\n q.add_(-al[i].reshape(-1,1) * st.old_dirs.container[i])\n st.d = r = q * st.H_diag.reshape(-1,1) \n# log.debug(\"al {}\".format(al[0:num_old]))\n# log.debug(\"q {}\".format(q))\n# log.debug(\"d {}\".format(st.d))\n# log.debug(\"H_diag {}\".format(st.H_diag))\n# \n for i in range(num_old - 1, -1, -1):\n be_i = torch.sum(st.old_dirs.container[i] * r, dim=1) * ro[i]\n# log.debug(\"{} od {}\".format(i,st.old_dirs.container[i]))\n# log.debug(\"{} r {}\".format(i,r))\n# log.debug(\"{} ro {}\".format(i,ro[i]))\n# log.debug(\"{} bei {}\".format(i,be_i))\n r.add_((al[i] - be_i).reshape(-1,1) * st.old_stps.container[i])\n# log.debug(\"{} r {}\".format(i,r))\n# st.d[~is_valid_step] = d_not_valid_steps\n\n if st.prev_flat_grad is None:\n st.prev_flat_grad = st.flat_grad.clone()\n else:\n st.prev_flat_grad.copy_(st.flat_grad)\n st.prev_loss = st.loss\n\n ############################################################\n # compute step length\n ############################################################\n # reset initial guess for trust\n if n_iter == 1:\n st.t = self.trust_by_step_size(a_coords, st.d, 0.1) \n else:\n# log.debug(lr)\n st.t = st.lr.clone()\n #if n_iter > 10: st.t = st.t + st.t * random.gauss(0, 0.1)\n\n if self.line_search_fn == \"Armijo\":\n ls_func_evals = self.armijo_line_search(n_iter, a_coords, st, energy_helper)\n \n elif self.line_search_fn == \"Wolfe\":\n ls_func_evals =self.wolfe_lineSearch(n_iter, a_coords, st, energy_helper)\n \n else:\n # directional derivative\n #gtd = torch.sum(st.flat_grad * st.d, dim=1) # g * d\n\n # no line search, simply move with fixed-step\n st.t = self._add_grad(a_coords, st.t, st.d)\n \n if n_iter != self.convergence_opts.max_iter:\n # re-evaluate function only if not in last iteration\n # the reason we do this: in a stochastic setting,\n # no use to re-evaluate that function here\n st.loss, st.std = energy_helper.compute_energy()\n st.flat_grad = energy_helper.compute_grad().reshape(st.n_confs,-1)\n #st.abs_grad_sum = st.flat_grad.abs().sum(1) # not needed\n ls_func_evals = 1\n\n\n # update func eval\n current_evals += ls_func_evals\n func_evals += ls_func_evals\n\n\n ############################################################\n # check conditions\n ############################################################\n #\n # active conformers are conformers that have not convereged\n # all variable in st. (OptState) are limited to active conformers\n #\n # local variables that have only elements for active conformers in the following evaluation\n # code have an \"a_\" prefix\n #\n \n status[is_active] = 0\n \n \n # a_ prefix flags tensors on active conformers only, just as st.\n a_flat_grad_sqare = st.flat_grad.pow(2)\n a_flat_grad_MSE = a_flat_grad_sqare.sum(1) / n_atoms \n a_flat_grad_square_max = a_flat_grad_sqare.max(1)[0]\n\n if log.isEnabledFor(logging.DEBUG):\n log.debug('{} loss: {}, max_grad: {} a_coords[0:5,1,0] {}'.format(\n n_iter, \n st.loss[0:5].detach().cpu().numpy(),\n a_flat_grad_square_max.sqrt().detach().cpu().numpy(),\n a_coords[0:5,0,0].detach().cpu().numpy()))\n\n a_deltaLoss = st.loss - min_loss[is_active]\n st.last_decreased[a_deltaLoss < 0] = n_iter\n\n # check if energy is converged\n a_e_decreased = a_deltaLoss * a_deltaLoss < self.convergence_opts.convergence_es\n e_decreased_idx = st.in_confIdx[a_e_decreased]\n status[e_decreased_idx] |= Status.ENERGY_CONVERGED\n \n # flag geometry as \"decreased\" if it went down or stated ~ same but gradient decreased \n # allow for 10x more tolerance because if forces are decreased\n a_deltaGrad = a_flat_grad_square_max - min_grad_square_max[is_active]\n a_e_decreased = ( (a_deltaLoss < 0)\n | ((a_deltaLoss <= self.convergence_opts.convergence_es * 10) \n &(a_deltaGrad < 0))) \n e_decreased_idx = st.in_confIdx[a_e_decreased]\n \n # store best geometry when geom is found\n if e_decreased_idx:\n minE_coords[e_decreased_idx] = a_coords[a_e_decreased].detach_()\n minE_no_constraints[e_decreased_idx] = \\\n energy_helper.energy_no_constraint()[a_e_decreased].detach_()\n minE_grad[e_decreased_idx] = st.flat_grad[a_e_decreased].detach_()\n min_loss [e_decreased_idx] = st.loss[a_e_decreased].detach().clone()\n if not st.std is None: min_std[e_decreased_idx] = st.std[a_e_decreased]\n min_grad_square_max[e_decreased_idx] = a_flat_grad_square_max[a_e_decreased]\n \n dummy = n_iter - st.last_decreased >= self.convergence_opts.max_it_without_decrease\n status[st.in_confIdx[dummy]] |= Status.ENERGY_NOT_DECREASING\n \n dummy = (a_flat_grad_MSE < self.convergence_opts.convergence_gms) \\\n & (a_flat_grad_square_max < self.convergence_opts.convergence_gmaxs)\n status[st.in_confIdx[dummy]] |= Status.GRADIENT_CONVERGED \n\n dt_square = st.d*st.t.reshape(-1,1)\n dt_square *= dt_square\n dummy = (dt_square.sum(1)/ n_atoms <= self.convergence_opts.convergence_dms) \\\n & (dt_square.max(1)[0] <= self.convergence_opts.convergence_dmaxs)\n status[st.in_confIdx[dummy]] |= Status.GEOMETRY_CONVERGED\n \n if self.plot_data is not None:\n rec = torch.full((n_total_confs,), float('nan'), dtype=st.loss.dtype, device=self.device)\n rec[is_active] = st.loss\n self.plot_data.append([n_iter, rec])\n \n actives_finished = (status[is_active] >= Status.ALL_CONVERGED) \n\n actives_finished_in_idx = st.in_confIdx[actives_finished]\n # set conf_steps for not-finished conformations\n conf_steps[actives_finished_in_idx] = n_iter\n\n if (~actives_finished).sum() == 0:\n log.info(f\"all finished (nIter={n_iter}): {minE_no_constraints}\") \n break\n\n if n_iter == self.convergence_opts.max_iter:\n log.info(f\"MAX_ITER reached: {minE_no_constraints}\")\n status[ st.in_confIdx[~actives_finished] ] |= Status.ITERATIONS_EXCEEDED\n break\n if current_evals >= self.convergence_opts.max_iter * 3: \n status[ st.in_confIdx[~actives_finished] ] |= Status.ITERATIONS_EXCEEDED \n log.info(f\"MAX_EVAL reached: {minE_no_constraints}\") \n break\n \n # filter out completed conformations\n if actives_finished.sum() > 0:\n a_future_actives = ~actives_finished\n is_active[actives_finished_in_idx] = 0\n st.filter_(a_future_actives)\n energy_helper.filter_(a_future_actives) # also filters coords_batch\n a_coords = coords_batch.coords\n\n if n_iter % self.prune_high_energy_freq == 0 and n_iter > 5:\n # this is a global minimum search, to speed up: prune \n # conformations with the highest energy\n drop_count = int(st.loss.shape[0] * self.prune_high_energy_fract)\n if drop_count < 1: continue\n a_to_drop = st.loss.argsort(descending=True)[0:int(st.loss.shape[0] * self.prune_high_energy_fract)]\n to_drop_idx = st.in_confIdx[a_to_drop]\n is_active[to_drop_idx] = 0\n status[to_drop_idx] = Status.HIGH_ENERGY\n conf_steps[to_drop_idx] = n_iter\n a_future_actives = torch.ones_like(st.loss, dtype=torch.uint8).bool()\n a_future_actives[a_to_drop] = 0\n st.filter_(a_future_actives)\n energy_helper.filter_(a_future_actives) # also filters coords_batch\n a_coords = coords_batch.coords\n \n if self.plot_data:\n self.plot(n_total_confs)\n\n # set conf_steps for not-finished conformations\n conf_steps[conf_steps == -1] = n_iter\n \n if log.isEnabledFor(logging.DEBUG):\n log.debug(f'lbfgs completed e={minE_no_constraints}, maxgrad^2={min_grad_square_max}')\n status[(status > Status.ALL_CONVERGED) & (status < Status.HIGH_ENERGY)] = Status.ALL_CONVERGED\n\n if st.std is None: min_std = None\n return minE_coords, minE_no_constraints, minE_grad, min_std, status, conf_steps","def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\n return x_best, -y_best","def optimize(self):\n \n if self.verbose:\n print('Starting grid search with bounds: [' + \\\n ';'.join(['%5g to %5g']*len(self.steps))%tuple([(self.steps[i][0], self.steps[i][-1]) for i in range(len(self.steps))]) +']')\n\n for params in self._get_next_point():\n self.transform.set_params(params)\n\n v, _ = self.measure.value_and_derivatives(self.transform)\n\n if v < self.best_value:\n self.best_value = v\n self.best_params = params\n# print('New best value %2.4f at ('%v, ', '.join(['%8.3f']*len(params))%tuple(params), ')')\n\n self.value_history.append(v)\n self.last_value = v\n self.iteration += 1\n\n if self.report_freq > 0 and (self.iteration % self.report_freq == 0) and self.report_func is not None:\n self.report_func(self)\n\n # Set the best transform\n self.transform.set_params(self.best_params)\n self.last_value = self.best_value\n return self.best_value","def optimization_manager(config):\n def optimize(state,\n grad,\n warmup=config.optim.warmup,\n grad_clip=config.optim.grad_clip):\n \"\"\"Optimizes with warmup and gradient clipping (disabled if negative).\"\"\"\n lr = state.lr\n if warmup > 0:\n lr = lr * jnp.minimum(state.step / warmup, 1.0)\n if grad_clip >= 0:\n # Compute global gradient norm\n grad_norm = jnp.sqrt(\n sum([jnp.sum(jnp.square(x)) for x in jax.tree_leaves(grad)]))\n # Clip gradient\n clipped_grad = jax.tree_map(\n lambda x: x * grad_clip / jnp.maximum(grad_norm, grad_clip), grad)\n else: # disabling gradient clipping if grad_clip < 0\n clipped_grad = grad\n return state.optimizer.apply_gradient(clipped_grad, learning_rate=lr)\n\n return optimize","def solve(self, topology, algorithm=\"SLSQP\", grad=\"AD\", step_size=1e-6, iters=100, eps=1e-6, kappa=1e-8, tmax=100, eta=1e-6, verbose=False):\n if verbose:\n print(\"----------\")\n print(\"Optimization with {} started!\".format(algorithm))\n print(f\"# Parameters: {self.number_of_parameters()}, # Constraints {self.number_of_constraints()}\")\n\n # test for bad stuff before going any further\n self.check_optimization_sanity()\n\n # compose gradient and objective functions\n if grad not in (\"AD\", \"FD\"):\n raise ValueError(f\"Gradient method {grad} is not supported!\")\n if grad == \"AD\":\n if verbose:\n print(\"Computing gradients using automatic differentiation!\")\n x_func = partial(self._optimize_form, topology=topology.copy(), tmax=tmax, eta=eta)\n grad_func = partial(grad_autograd, grad_func=agrad(x_func)) # x, grad, x_func\n\n elif grad == \"FD\":\n if verbose:\n print(f\"Warning: Calculating gradients using finite differences with step size {step_size}. This may take a while...\")\n grad_func = self.gradient_func(grad_finite_differences, topology.copy(), tmax, eta, step_size)\n\n # grad_func = self.gradient_func(grad_func, topology.copy(), tmax, eta, step_size)\n obj_func = self.objective_func(topology, grad_func, tmax, eta)\n\n # generate optimization variables\n x = self.optimization_parameters(topology)\n\n # extract the lower and upper bounds to optimization variables\n bounds_low, bounds_up = self.optimization_bounds(topology)\n\n # stack keyword arguments\n hyper_parameters = {\"f\": obj_func,\n \"algorithm\": algorithm,\n \"dims\": self.number_of_parameters(),\n \"bounds_low\": bounds_low,\n \"bounds_up\": bounds_up,\n \"iters\": iters,\n \"eps\": eps,\n \"ftol\": kappa}\n\n # assemble optimization solver\n solver = nlopt_solver(**hyper_parameters)\n\n # solve optimization problem\n x_opt = None\n start = time()\n try:\n x_opt = solver.optimize(x)\n if verbose:\n print(\"Optimization ended correctly!\")\n except RoundoffLimited:\n print(\"Optimization was halted because roundoff errors limited progress\")\n print(\"Results may still be useful though!\")\n x_opt = self.optimization_parameters(topology)\n except RuntimeError:\n print(\"Optimization failed due to a runtime error!\")\n print(f\"Optimization total runtime: {round(time() - start, 4)} seconds\")\n return static_equilibrium(topology)\n\n # fetch last optimum value of loss function\n time_opt = time() - start\n loss_opt = solver.last_optimum_value()\n evals = solver.get_numevals()\n status = nlopt_status(solver.last_optimize_result())\n\n # set optimizer attributes\n self.time_opt = time_opt\n self.x_opt = x_opt\n self.penalty = loss_opt\n self.evals = evals\n self.status = status\n\n # set norm of the gradient\n # NOTE: np.zeros is a dummy array (signature requirement set by nlopt)\n self.gradient = grad_func(x_opt, np.zeros(x_opt.size))\n self.gradient_norm = np.linalg.norm(self.gradient)\n\n if verbose:\n print(f\"Optimization total runtime: {round(time_opt, 6)} seconds\")\n print(\"Number of evaluations incurred: {}\".format(evals))\n print(f\"Final value of the objective function: {round(loss_opt, 6)}\")\n print(f\"Norm of the gradient of the objective function: {round(self.gradient_norm, 6)}\")\n print(f\"Optimization status: {status}\".format(status))\n print(\"----------\")\n\n # exit like a champion\n return static_equilibrium(topology)","def step_func_cat(X, args, Y, info, Ytarget, err, tols, iter, maxIter):\n [XF, ZF, L, EA, W, CB, WL, WEA, L_EA, CB_EA] = args[\"cat\"]\n\n # if abs( err[1] + ZF ) < 0.0001:\n # breakpoint()\n\n [alpha_min, alpha0, alphaR] = args[\n \"step\"\n ] # get minimum alpha, initial alpha, and alpha reduction rate from passed arguments\n\n # J = info['jacobian']\n # dX = -np.matmul(np.linalg.inv(J), err)\n dX = -np.matmul(info[\"stiffnessB\"], err)\n\n # ! Reduce dHF by factor (between 1 at I = 1 and 0 at I = MaxIter) that reduces linearly with iteration count\n # to ensure that we converge on a solution even in the case were we obtain a nonconvergent cycle about the\n # correct solution (this happens, for example, if we jump to quickly between a taut and slack catenary)\n\n alpha = 1.0 # M<<<<<<<< np.max([alpha_min, alpha0*(1.0 - alphaR*iter/maxIter)])\n\n # exponential approach alpha = alpha0 * np.exp( iter/maxIter * np.log(alpha_min/alpha0 ) )\n\n dX[0] = dX[0] * alpha # dHF*( 1.0 - Tol*I )\n dX[1] = dX[1] * alpha # dVF*( 1.0 - Tol*I )\n\n # To avoid an ill-conditioned situation, make sure HF does not go less than or equal to zero by having a lower limit of Tol*HF\n # [NOTE: the value of dHF = ( Tol - 1.0 )*HF comes from: HF = HF + dHF = Tol*HF when dHF = ( Tol - 1.0 )*HF]\n # dX[0] = max( dX[0], ( tol - 1.0 )*info['HF']);\n\n # To avoid an ill-conditioned situation, make sure HF does not get too close to zero, by forcing HF >= tols[0]\n # if info['HF'] + dX[0] <= tol*abs(info['VF']+dX[1]):\n # if info['HF'] + dX[0] <= tols[0]\n if X[0] + dX[0] <= tols[0]:\n # dX[0] = tol*abs(info['VF']+dX[1]) - info['HF']\n # dX[0] = tols[0] - info['HF']\n dX[0] = tols[0] - X[0]\n\n # To avoid an ill-conditioned situation where the line is nearly all on the seabed but the solver gets stuck,\n # if np.abs(err[1] + ZF)/ZF < tol:\n # breakpoint()\n # deltaHFVF = info['HF'] - info['VF']\n # dX[0] = dX[0] - 0.5*deltaHFVF\n # dX[1] = dX[1] + 0.5*deltaHFVF\n\n # prevent silly situation where a line with weight and positive ZF considers a negative VF\n if info[\"ProfileType\"] == 2:\n if X[1] + dX[1] <= tols[1]: # if vertical force is within tolerance of being zero/negative\n VFtarget = (L - info[\"LBot\"]) * W # set next VF value to be the weight of portion of line that's suspended\n dX[1] = VFtarget - X[1]\n\n return dX # returns dX (step to make)","def maximize(func, grad_func, x, y, theta_0, alpha_0=0.01, max_it=100):\n return minimize(negate(func), negate_all(grad_func), x, y, theta_0, alpha_0=0.01, max_it=100)","def optimize(self,\n max_grad_norm=0.5,\n learning_rate=7e-4,\n rms_decay=0.99,\n rms_epsilon=1e-5):\n grads = tf.gradients(tf.negative(self.objective), self.variables)\n if max_grad_norm is not None:\n grads, _ = tf.clip_by_global_norm(grads, max_grad_norm)\n trainer = tf.train.RMSPropOptimizer(learning_rate=learning_rate,\n decay=rms_decay,\n epsilon=rms_epsilon)\n return trainer.apply_gradients(list(zip(grads, self.variables)))","def checkgrad(self, target_param = None, verbose=False, step=1e-6, tolerance = 1e-3):\n\n x = self._get_params_transformed().copy()\n\n if not verbose:\n #just check the global ratio\n dx = step*np.sign(np.random.uniform(-1,1,x.size))\n\n #evaulate around the point x\n f1, g1 = self.objective_and_gradients(x+dx)\n f2, g2 = self.objective_and_gradients(x-dx)\n gradient = self.objective_function_gradients(x)\n\n numerical_gradient = (f1-f2)/(2*dx)\n global_ratio = (f1-f2)/(2*np.dot(dx,gradient))\n\n if (np.abs(1.-global_ratio)<tolerance) and not np.isnan(global_ratio):\n return True\n else:\n return False\n else:\n #check the gradient of each parameter individually, and do some pretty printing\n try:\n names = self._get_param_names_transformed()\n except NotImplementedError:\n names = ['Variable %i'%i for i in range(len(x))]\n\n # Prepare for pretty-printing\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\n float_len = 10\n cols = [max_names]\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\n cols = np.array(cols) + 5\n header_string = [\"{h:^{col}}\".format(h = header[i], col = cols[i]) for i in range(len(cols))]\n header_string = map(lambda x: '|'.join(x), [header_string])\n separator = '-'*len(header_string[0])\n print '\\n'.join([header_string[0], separator])\n\n if target_param is None:\n param_list = range(len(x))\n else:\n param_list = self.grep_param_names(target_param)\n\n for i in param_list:\n xx = x.copy()\n xx[i] += step\n f1, g1 = self.objective_and_gradients(xx)\n xx[i] -= 2.*step\n f2, g2 = self.objective_and_gradients(xx)\n gradient = self.objective_function_gradients(x)[i]\n\n numerical_gradient = (f1-f2)/(2*step)\n ratio = (f1-f2)/(2*step*gradient)\n difference = np.abs((f1-f2)/2/step - gradient)\n\n if (np.abs(ratio-1)<tolerance):\n formatted_name = \"\\033[92m {0} \\033[0m\".format(names[i])\n else:\n formatted_name = \"\\033[91m {0} \\033[0m\".format(names[i])\n r = '%.6f' % float(ratio)\n d = '%.6f' % float(difference)\n g = '%.6f' % gradient\n ng = '%.6f' % float(numerical_gradient)\n grad_string = \"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\".format(formatted_name,r,d,g, ng, c0 = cols[0]+9, c1 = cols[1], c2 = cols[2], c3 = cols[3], c4 = cols[4])\n print grad_string","def nn_ga_optimise_from_args(func_caller, worker_manager, max_capital, mode, mutation_op,\n crossover_op=None, options=None, reporter='default'):\n if options is None:\n reporter = get_reporter(reporter)\n options = load_options(ga_opt_args, reporter=reporter)\n options.mode = mode\n return (NNGAOptimiser(func_caller, worker_manager, mutation_op, crossover_op,\n options, reporter)).optimise(max_capital)","def checkgrad(self, target_param=None, verbose=False, step=1e-6, tolerance=1e-3):\r\n\r\n x = self._get_params_transformed().copy()\r\n\r\n if not verbose:\r\n # just check the global ratio\r\n\r\n #choose a random direction to find the linear approximation in\r\n if x.size==2:\r\n dx = step * np.ones(2) # random direction for 2 parameters can fail dure to symmetry\r\n else:\r\n dx = step * np.sign(np.random.uniform(-1, 1, x.size))\r\n\r\n # evaulate around the point x\r\n f1, g1 = self.objective_and_gradients(x + dx)\r\n f2, g2 = self.objective_and_gradients(x - dx)\r\n gradient = self.objective_function_gradients(x)\r\n\r\n numerical_gradient = (f1 - f2) / (2 * dx)\r\n global_ratio = (f1 - f2) / (2 * np.dot(dx, np.where(gradient==0, 1e-32, gradient)))\r\n\r\n return (np.abs(1. - global_ratio) < tolerance) or (np.abs(gradient - numerical_gradient).mean() < tolerance)\r\n else:\r\n # check the gradient of each parameter individually, and do some pretty printing\r\n try:\r\n names = self._get_param_names_transformed()\r\n except NotImplementedError:\r\n names = ['Variable %i' % i for i in range(len(x))]\r\n\r\n # Prepare for pretty-printing\r\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\r\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\r\n float_len = 10\r\n cols = [max_names]\r\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\r\n cols = np.array(cols) + 5\r\n header_string = [\"{h:^{col}}\".format(h=header[i], col=cols[i]) for i in range(len(cols))]\r\n header_string = map(lambda x: '|'.join(x), [header_string])\r\n separator = '-' * len(header_string[0])\r\n print '\\n'.join([header_string[0], separator])\r\n\r\n if target_param is None:\r\n param_list = range(len(x))\r\n else:\r\n param_list = self.grep_param_names(target_param, transformed=True, search=True)\r\n if not np.any(param_list):\r\n print \"No free parameters to check\"\r\n return\r\n\r\n\r\n for i in param_list:\r\n xx = x.copy()\r\n xx[i] += step\r\n f1, g1 = self.objective_and_gradients(xx)\r\n xx[i] -= 2.*step\r\n f2, g2 = self.objective_and_gradients(xx)\r\n gradient = self.objective_function_gradients(x)[i]\r\n\r\n numerical_gradient = (f1 - f2) / (2 * step)\r\n ratio = (f1 - f2) / (2 * step * np.where(gradient==0, 1e-312, gradient))\r\n difference = np.abs((f1 - f2) / 2 / step - gradient)\r\n\r\n if (np.abs(1. - ratio) < tolerance) or np.abs(difference) < tolerance:\r\n formatted_name = \"\\033[92m {0} \\033[0m\".format(names[i])\r\n else:\r\n formatted_name = \"\\033[91m {0} \\033[0m\".format(names[i])\r\n r = '%.6f' % float(ratio)\r\n d = '%.6f' % float(difference)\r\n g = '%.6f' % gradient\r\n ng = '%.6f' % float(numerical_gradient)\r\n grad_string = \"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\".format(formatted_name, r, d, g, ng, c0=cols[0] + 9, c1=cols[1], c2=cols[2], c3=cols[3], c4=cols[4])\r\n print grad_string","def fit(self, start_params=None, method='newton', maxiter=100,\n full_output=True, disp=True, fargs=(), callback=None, retall=False,\n skip_hessian=False, **kwargs):\n Hinv = None # JP error if full_output=0, Hinv not defined\n\n start_params = self._get_start_params(start_params)\n\n # TODO: separate args from nonarg taking score and hessian, ie.,\n # user-supplied and numerically evaluated estimate frprime doesn't take\n # args in most (any?) of the optimize function\n\n nobs = self.endog.shape[0]\n # f = lambda params, *args: -self.loglike(params, *args) / nobs\n\n def f(params, *args):\n return -self.loglike(params, *args) / nobs\n\n if method == 'newton':\n # TODO: why are score and hess positive?\n def score(params, *args):\n return self.score(params, *args) / nobs\n\n def hess(params, *args):\n return self.hessian(params, *args) / nobs\n else:\n def score(params, *args):\n return -self.score(params, *args) / nobs\n\n def hess(params, *args):\n return -self.hessian(params, *args) / nobs\n\n warn_convergence = kwargs.pop('warn_convergence', True)\n optimizer = Optimizer()\n xopt, retvals, optim_settings = optimizer._fit(f, score, start_params,\n fargs, kwargs,\n hessian=hess,\n method=method,\n disp=disp,\n maxiter=maxiter,\n callback=callback,\n retall=retall,\n full_output=full_output)\n\n # NOTE: this is for fit_regularized and should be generalized\n cov_params_func = kwargs.setdefault('cov_params_func', None)\n if cov_params_func:\n Hinv = cov_params_func(self, xopt, retvals)\n elif method == 'newton' and full_output:\n Hinv = np.linalg.inv(-retvals['Hessian']) / nobs\n # TODO: try/except for non-invertible hessian?\n elif not skip_hessian:\n H = -1 * self.hessian(xopt)\n invertible = False\n if np.all(np.isfinite(H)):\n eigvals, eigvecs = np.linalg.eigh(H)\n if np.min(eigvals) > 0:\n invertible = True\n\n if invertible:\n Hinv = eigvecs.dot(np.diag(1.0 / eigvals)).dot(eigvecs.T)\n Hinv = np.asfortranarray((Hinv + Hinv.T) / 2.0)\n else:\n warnings.warn('Inverting hessian failed, no bse or cov_params '\n 'available', HessianInversionWarning)\n Hinv = None\n\n if 'cov_type' in kwargs:\n cov_kwds = kwargs.get('cov_kwds', {})\n kwds = {'cov_type': kwargs['cov_type'], 'cov_kwds': cov_kwds}\n else:\n kwds = {}\n if 'use_t' in kwargs:\n kwds['use_t'] = kwargs['use_t']\n # TODO: add Hessian approximation and change the above if needed\n mlefit = LikelihoodModelResults(self, xopt, Hinv, scale=1., **kwds)\n\n # TODO: hardcode scale?\n if isinstance(retvals, dict):\n mlefit.mle_retvals = retvals\n if warn_convergence and not retvals['converged']:\n warnings.warn(\"Maximum Likelihood optimization failed to \"\n \"converge. Check mle_retvals\",\n ConvergenceWarning)\n\n mlefit.mle_settings = optim_settings\n return mlefit","def _optimize(optimizer, regularization_losses, scope, **kwargs):\n sum_loss = _gather_loss(regularization_losses, scope)\n grad = None\n if sum_loss is not None:\n grad = optimizer.compute_gradients(sum_loss, **kwargs)\n return sum_loss, grad","def minimize(fun, \n bounds = None, \n value_limit = math.inf,\n num_retries = 1000,\n logger = None,\n workers = mp.cpu_count(),\n popsize = 31, \n max_evaluations = 50000, \n capacity = 500,\n stop_fittness = None,\n optimizer = None,\n ):\n\n if optimizer is None:\n optimizer = de_cma(max_evaluations, popsize, stop_fittness) \n store = Store(bounds, capacity = capacity, logger = logger)\n return retry(fun, store, optimizer.minimize, num_retries, value_limit, workers)","def minimizer(f, x, optimizer, grad_f, hess_f=None,\n args=(),\n maxiter=None, tol=1e-5,\n stepsize=1, adaptive=True,\n bounds=None,\n disp=False):\n min_obj = {'steepest': SteepestDescent,\n 'conjugate': ConjugateDescent,\n 'newton': NewtonDescent,\n 'cg': ScipyCG,\n 'ncg': ScipyNCG,\n 'bfgs': ScipyBFGS,\n 'lbfgs': ScipyLBFGS}\n\n if optimizer not in min_obj.keys():\n raise ValueError('unknown optimizer')\n local_meth = optimizer in ('steepest', 'conjugate', 'newton')\n\n if local_meth:\n proj = None\n if not bounds is None:\n if callable(bounds):\n proj = bounds\n else:\n proj = bounds_to_proj(bounds)\n\n return min_obj[optimizer](f, x, grad_f, hess_f=hess_f,\n maxiter=maxiter, tol=tol,\n stepsize=stepsize, adaptive=adaptive,\n proj=proj)\n\n if not bounds is None and optimizer != 'lbfgs':\n raise NotImplementedError('%s optimization method does not accept constraints' % optimizer)\n \n return min_obj[optimizer](f, x, grad_f, hess_f=hess_f,\n maxiter=maxiter, tol=tol,\n bounds=bounds, disp=disp)","def run_step_blackbox_optimizer(config,\n current_input,\n blackbox_optimizer,\n proposed_perturbations,\n finished_dnas,\n results,\n logging_data=None):\n core_hyperparameters = blackbox_optimizer.get_hyperparameters()\n function_values = [0.0] * len(proposed_perturbations)\n rewards_for_controller = []\n perturbations = proposed_perturbations\n evaluation_stats = []\n current_value_exact = 0.0\n current_value_exact_counter = 0\n\n for i in range(len(results)):\n rewards_for_controller.append(results[i]['function_value'])\n tag = results[i]['tag']\n index = 0\n if tag > 0:\n if config.est_type == 'antithetic':\n index = (tag - 1) * 2\n function_values[index] += results[i]['function_value']\n else:\n index = tag - 1\n function_values[index] += results[i]['function_value']\n if tag < 0:\n index = (-tag - 1) * 2 + 1\n function_values[index] += results[i]['function_value']\n if tag == 0:\n current_value_exact += results[i]['function_value']\n current_value_exact_counter += 1\n current_value_exact /= float(current_value_exact_counter)\n\n for result in results:\n evaluation_stat = list(result['evaluation_stat'])\n evaluation_stats.append(evaluation_stat)\n\n function_values_reshaped = np.array(function_values)\n perturbations_reshaped = np.array(perturbations)\n\n logging.info('LIST OF FUNCTION VALUES')\n logging.info(function_values_reshaped)\n\n logging.info('MAX VALUE SEEN CURRENTLY')\n logging.info(np.max(function_values_reshaped))\n\n logging.info('MEAN OF VALUES')\n logging.info(np.mean(function_values_reshaped))\n\n if logging_data is not None:\n iteration = logging_data['iteration']\n best_value = logging_data['best_value']\n iteration = logging_data['iteration']\n best_input = logging_data['best_input']\n best_core_hyperparameters = logging_data['best_core_hyperparameters']\n optimizer_state = blackbox_optimizer.get_state()\n\n if current_value_exact > best_value[0]:\n best_value[0] = current_value_exact\n best_input = current_input\n best_core_hyperparameters = core_hyperparameters\n\n # Writing logs.\n if iteration % config.log_frequency == 0:\n util.log_row(config.params_file, current_input)\n util.log_row(config.best_params_file, best_input)\n util.log_row(config.best_core_hyperparameters_file,\n best_core_hyperparameters)\n util.log_row(config.best_value_file, best_value)\n util.log_row(config.optimizer_internal_state_file, optimizer_state)\n util.log_row(config.current_values_list_file, [current_value_exact])\n util.log_row(config.best_values_list_file, [best_value[0]])\n util.log_row(config.fvalues_file, function_values_reshaped)\n util.log_row(config.iteration_file, [iteration])\n\n print('Current exact value estimate:')\n print(current_value_exact)\n sys.stdout.flush()\n\n new_current_input = blackbox_optimizer.run_step(perturbations_reshaped,\n function_values_reshaped,\n current_input,\n current_value_exact)\n config.controller.collect_rewards_and_train(rewards_for_controller,\n finished_dnas)\n\n evaluation_stats_reduced = [sum(x) for x in zip(*evaluation_stats)]\n blackbox_optimizer.update_state(evaluation_stats_reduced)\n\n return [True, new_current_input]","def solve(self, **kwargs) -> OptimizationResult:\n raise NotImplementedError","def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\r\n\r\n\t\r\n\tif grad == 'NO':\r\n\t\tif method == 'Powell' :\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'Nelder-Mead':\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t options = {'ftol': 0.0001})\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'default':\r\n\t\t\tres = opt.minimize(Ulike,init_par, \r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\r\n\telif grad == 'YES':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \r\n \t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\r\n\t\treturn res.x, res.nit \r\n\t\t\t\r\n\t\t\r\n\telif grad == 'HESS':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\r\n\t\t\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \r\n\t\treturn res.x, res.nit","def _optfn(self, x):\n\n logger.debug(\" optfn(theta=%s)\", str(x))\n\n wmx = max(self.weights) * self.weighttrunc\n\n ip = []\n for i,w in enumerate(self.weights):\n if w < wmx:\n continue\n ip.append((i,w,x))\n\n if self.pool is None:\n itr = map(self.worker.loglik_grad, ip)\n else:\n itr = self.pool.imap_unordered(_pool_loglik_grad, ip, 10)\n\n if self._prior_shape is None:\n ll = 0.\n grad = np.zeros(len(x))\n else:\n ll = sum(sp.special.xlogy(self._prior_shape-1,x)-(x/self._prior_scale))\n grad = (self._prior_shape - 1)/x - 1/self._prior_scale\n\n for l,g in itr:\n ll += l\n grad += g\n\n logger.debug(\" optfn=%g\", ll)\n\n return -ll, -grad","def inner(*args, **kwargs):\n current_var_scope = variable_scope.get_variable_scope()\n with record.stop_recording():\n result = f(*args, **kwargs)\n\n def grad_wrapper(*wrapper_args, variables=None):\n \"\"\"Wrapper function to accomodate lack of kwargs in graph mode custom_gradient.\"\"\"\n\n @custom_gradient\n def inner_recompute_grad(*dresult):\n \"\"\"Nested custom gradient function for computing grads in reverse and forward mode autodiff.\"\"\"\n # Gradient calculation for reverse mode autodiff.\n with backprop.GradientTape() as t:\n id_args = nest.map_structure(gen_array_ops.identity, args)\n # Tuple `dresult` should contain at least one tensor.\n assert len(dresult) >= 1\n\n if not context.executing_eagerly():\n # XLA doesn't respect `tf.control_dependencies`. The code block\n # below manually adds a data dependency to `dresult` to ensure\n # recomputation of `f(*args, **kwargs)` happens after `dresult`.\n\n # This works even if `dresult[0]` is a size 0 tensor as reduce_max\n # of a size 0 tensor returns -inf. Use reshape here to avoid reading\n # the entire `dresult[0]`.\n elem = math_ops.reduce_max(array_ops.reshape(dresult[0], [-1])[:1])\n # Cast elem to bool in case elem is NaN.\n elem_bool = math_ops.cast(elem, dtypes.bool)\n dresult_dep = array_ops.where_v2(\n elem_bool == elem_bool, 0., float(\"nan\")) # pylint: disable=comparison-with-itself\n id_args = nest.map_structure(\n lambda x: x + math_ops.cast(dresult_dep, x.dtype), id_args)\n\n t.watch(id_args)\n if variables is not None:\n t.watch(variables)\n with variable_scope.variable_scope(current_var_scope):\n recomputed_result = f(*id_args, **kwargs)\n kw_vars = []\n if variables is not None:\n kw_vars = list(variables)\n grads = t.gradient(\n recomputed_result,\n list(id_args) + kw_vars,\n output_gradients=dresult,\n unconnected_gradients=UnconnectedGradients.ZERO)\n\n def transpose(*t_args, **t_kwargs):\n \"\"\"Gradient function calculation for forward mode autodiff.\"\"\"\n # Just throw an error since gradients / activations are not stored on\n # tape for recompute.\n raise NotImplementedError(\n \"recompute_grad tried to transpose grad of {}. \"\n \"Consider not using recompute_grad in forward mode\"\n \"autodiff\".format(f.__name__))\n\n return (grads[:len(id_args)], grads[len(id_args):]), transpose\n\n return inner_recompute_grad(*wrapper_args)\n\n return result, grad_wrapper","def _get_step_fn(self) -> Callable:\n\n def loss_fn(\n params: frozen_dict.FrozenDict,\n apply_fn: Callable,\n batch: Dict[str, jnp.ndarray],\n ) -> Tuple[float, Dict[str, float]]:\n \"\"\"Loss function.\"\"\"\n # map samples with the fitted map\n mapped_samples = apply_fn({\"params\": params}, batch[\"source\"])\n\n # compute the loss\n val_fitting_loss = self.fitting_loss(batch[\"target\"], mapped_samples)\n val_regularizer = self.regularizer(batch[\"source\"], mapped_samples)\n val_tot_loss = (\n val_fitting_loss + self.regularizer_strength * val_regularizer\n )\n\n # store training logs\n loss_logs = {\n \"total_loss\": val_tot_loss,\n \"fitting_loss\": val_fitting_loss,\n \"regularizer\": val_regularizer\n }\n\n return val_tot_loss, loss_logs\n\n @functools.partial(jax.jit, static_argnums=3)\n def step_fn(\n state_neural_net: train_state.TrainState,\n train_batch: Dict[str, jnp.ndarray],\n valid_batch: Optional[Dict[str, jnp.ndarray]] = None,\n is_logging_step: bool = False,\n ) -> Tuple[train_state.TrainState, Dict[str, float]]:\n \"\"\"Step function.\"\"\"\n # compute loss and gradients\n grad_fn = jax.value_and_grad(loss_fn, argnums=0, has_aux=True)\n (_, current_train_logs), grads = grad_fn(\n state_neural_net.params, state_neural_net.apply_fn, train_batch\n )\n\n # logging step\n current_logs = {\"train\": current_train_logs, \"eval\": {}}\n if is_logging_step:\n _, current_eval_logs = loss_fn(\n params=state_neural_net.params,\n apply_fn=state_neural_net.apply_fn,\n batch=valid_batch\n )\n current_logs[\"eval\"] = current_eval_logs\n\n # update state\n return state_neural_net.apply_gradients(grads=grads), current_logs\n\n return step_fn","def recompute_grad(f):\n # TODO(cdfreeman) Add is_recomputing functionality from graph mode version\n\n @custom_gradient\n def inner(*args, **kwargs):\n \"\"\"Inner function closure for calculating gradients.\"\"\"\n current_var_scope = variable_scope.get_variable_scope()\n with record.stop_recording():\n result = f(*args, **kwargs)\n\n def grad_wrapper(*wrapper_args, variables=None):\n \"\"\"Wrapper function to accomodate lack of kwargs in graph mode custom_gradient.\"\"\"\n\n @custom_gradient\n def inner_recompute_grad(*dresult):\n \"\"\"Nested custom gradient function for computing grads in reverse and forward mode autodiff.\"\"\"\n # Gradient calculation for reverse mode autodiff.\n with backprop.GradientTape() as t:\n id_args = nest.map_structure(gen_array_ops.identity, args)\n # Tuple `dresult` should contain at least one tensor.\n assert len(dresult) >= 1\n\n if not context.executing_eagerly():\n # XLA doesn't respect `tf.control_dependencies`. The code block\n # below manually adds a data dependency to `dresult` to ensure\n # recomputation of `f(*args, **kwargs)` happens after `dresult`.\n\n # This works even if `dresult[0]` is a size 0 tensor as reduce_max\n # of a size 0 tensor returns -inf. Use reshape here to avoid reading\n # the entire `dresult[0]`.\n elem = math_ops.reduce_max(array_ops.reshape(dresult[0], [-1])[:1])\n # Cast elem to bool in case elem is NaN.\n elem_bool = math_ops.cast(elem, dtypes.bool)\n dresult_dep = array_ops.where_v2(\n elem_bool == elem_bool, 0., float(\"nan\")) # pylint: disable=comparison-with-itself\n id_args = nest.map_structure(\n lambda x: x + math_ops.cast(dresult_dep, x.dtype), id_args)\n\n t.watch(id_args)\n if variables is not None:\n t.watch(variables)\n with variable_scope.variable_scope(current_var_scope):\n recomputed_result = f(*id_args, **kwargs)\n kw_vars = []\n if variables is not None:\n kw_vars = list(variables)\n grads = t.gradient(\n recomputed_result,\n list(id_args) + kw_vars,\n output_gradients=dresult,\n unconnected_gradients=UnconnectedGradients.ZERO)\n\n def transpose(*t_args, **t_kwargs):\n \"\"\"Gradient function calculation for forward mode autodiff.\"\"\"\n # Just throw an error since gradients / activations are not stored on\n # tape for recompute.\n raise NotImplementedError(\n \"recompute_grad tried to transpose grad of {}. \"\n \"Consider not using recompute_grad in forward mode\"\n \"autodiff\".format(f.__name__))\n\n return (grads[:len(id_args)], grads[len(id_args):]), transpose\n\n return inner_recompute_grad(*wrapper_args)\n\n return result, grad_wrapper\n\n return tf_decorator.make_decorator(f, inner)","def minimize_batch(target_fn, gradient_fn, theta_0, tolerance=0.00001):\n\n step_sizes = [100, 10, 1, 0.1, 0.01, 0.001, 0.0001, 0.00001]\n\n theta = theta_0 # set theta to initial value\n target_fn = safe(target_fn) # safe version of target_fn\n value = target_fn(theta) # value we're minimizing\n\n while True:\n gradient = gradient_fn(theta)\n next_thetas = [step(theta, gradient, -step_size)\n for step_size in step_sizes]\n # choose the one that minimizes the error function\n next_theta = min(next_thetas, key=target_fn)\n next_value = target_fn(next_theta)\n\n # stop if we're \"converging\"\n if abs(value - next_value) < tolerance:\n return theta\n else:\n theta, value = next_theta, next_value","def optimize(self, input_val_dict):\n logger.log(\"Start CG optimization\")\n\n logger.log(\"computing loss before\")\n loss_before = self.loss(input_val_dict)\n\n logger.log(\"performing update\")\n\n logger.log(\"computing gradient\")\n gradient = self.gradient(input_val_dict)\n logger.log(\"gradient computed\")\n\n logger.log(\"computing descent direction\")\n Hx = self._hvp_approach.build_eval(input_val_dict)\n descent_direction = conjugate_gradients(Hx, gradient, cg_iters=self._cg_iters)\n\n initial_step_size = np.sqrt(2.0 * self._max_constraint_val *\n (1. / (descent_direction.dot(Hx(descent_direction)) + 1e-8)))\n if np.isnan(initial_step_size):\n logger.log(\"Initial step size is NaN! Rejecting the step!\")\n return\n\n initial_descent_step = initial_step_size * descent_direction\n logger.log(\"descent direction computed\")\n\n prev_params = self._target.get_param_values()\n prev_params_values = _flatten_params(prev_params)\n\n loss, constraint_val, n_iter, violated = 0, 0, 0, False\n for n_iter, ratio in enumerate(self._backtrack_ratio ** np.arange(self._max_backtracks)):\n cur_step = ratio * initial_descent_step\n cur_params_values = prev_params_values - cur_step\n cur_params = _unflatten_params(cur_params_values, params_example=prev_params)\n self._target.set_params(cur_params)\n\n loss, constraint_val = self.loss(input_val_dict), self.constraint_val(input_val_dict)\n if loss < loss_before and constraint_val <= self._max_constraint_val:\n break\n\n \"\"\" ------------------- Logging Stuff -------------------------- \"\"\"\n if np.isnan(loss):\n violated = True\n logger.log(\"Line search violated because loss is NaN\")\n if np.isnan(constraint_val):\n violated = True\n logger.log(\"Line search violated because constraint %s is NaN\" % self._constraint_name)\n if loss >= loss_before:\n violated = True\n logger.log(\"Line search violated because loss not improving\")\n if constraint_val >= self._max_constraint_val:\n violated = True\n logger.log(\"Line search violated because constraint %s is violated\" % self._constraint_name)\n\n if violated and not self._accept_violation:\n logger.log(\"Line search condition violated. Rejecting the step!\")\n self._target.set_params(prev_params)\n\n logger.log(\"backtrack iters: %d\" % n_iter)\n logger.log(\"computing loss after\")\n logger.log(\"optimization finished\")","def train_step(\n self, inputs: Dict[str, torch.Tensor], targets: Dict[str, torch.Tensor], should_step: bool = True\n ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor]]:\n if isinstance(self.optimizer, torch.optim.LBFGS):\n # NOTE: Horovod is not supported for L-BFGS.\n # NOTE: AMP is not supported for L-BFGS yet.\n # NOTE: gradient accumulation is not supported for L-BFGS yet.\n\n def closure():\n # Allows L-BFGS to reevaluate the loss function\n self.distributed.zero_grad(self.optimizer)\n model_outputs = self.dist_model((inputs, targets))\n loss, _ = self.model.train_loss(\n targets, model_outputs, self.regularization_type, self.regularization_lambda\n )\n loss.backward()\n return loss\n\n self.distributed.step(self.optimizer, closure)\n\n # Obtain model predictions and loss\n model_outputs = self.dist_model((inputs, targets))\n loss, all_losses = self.model.train_loss(\n targets, model_outputs, self.regularization_type, self.regularization_lambda\n )\n\n if not self.evaluate_training_set:\n # Update evaluation metrics with current model params:\n # noisy but fast way to get metrics on the training set\n predictions = self.model.outputs_to_predictions(model_outputs)\n self.model.update_metrics(targets, predictions)\n\n return loss, all_losses\n\n with torch.cuda.amp.autocast() if self.use_amp else contextlib.nullcontext():\n with self.distributed.prepare_model_update(self.dist_model, should_step=should_step):\n # Obtain model predictions and loss\n model_outputs = self.dist_model((inputs, targets))\n loss, all_losses = self.model.train_loss(\n targets, model_outputs, self.regularization_type, self.regularization_lambda\n )\n loss = loss / self.gradient_accumulation_steps\n\n # Begin the backward pass\n variables = self.dist_model.parameters()\n if self.use_amp:\n self.scaler.scale(loss).backward()\n else:\n self.distributed.backward(loss, self.dist_model)\n\n if not should_step:\n # Short-circuit the parameter updates if we are still accumulating gradients\n return loss, all_losses\n\n # Wait for gradient aggregation to complete before clipping the gradients\n # When using AMP, we need to do this before unscaling.\n # See: https://github.com/horovod/horovod/blob/master/examples/pytorch/pytorch_mnist.py\n self.distributed.wait_optimizer_synced(self.optimizer)\n\n if self.use_amp:\n # In-place unscaling of all gradients before weights update\n # Do this before gradient clipping per docs:\n # https://pytorch.org/docs/master/notes/amp_examples.html#gradient-clipping\n self.scaler.unscale_(self.optimizer)\n\n if self.distributed.allow_clip_gradients():\n # Clip gradients\n self.clip_grads(variables)\n\n # Apply gradient updates\n with self.distributed.prepare_optimizer_update(self.optimizer):\n # Because we already synchronized above, we skip doing so here\n if self.use_amp:\n self.scaler.step(self.optimizer)\n else:\n self.distributed.step(self.optimizer)\n\n if self.use_amp:\n # Update scaler in case of overflow/underflow\n self.scaler.update()\n\n if not self.evaluate_training_set:\n # Update evaluation metrics with current model params:\n # noisy but fast way to get metrics on the training set\n predictions = self.model.outputs_to_predictions(model_outputs)\n self.model.update_metrics(targets, predictions)\n\n self.distributed.zero_grad(self.optimizer)\n\n return loss, all_losses","def hyperopt_fmin(\n fn,\n space,\n algo,\n max_evals=sys.maxsize,\n timeout=None,\n loss_threshold=None,\n trials=None,\n rstate=None,\n allow_trials_fmin=True,\n pass_expr_memo_ctrl=None,\n catch_eval_exceptions=False,\n verbose=True,\n return_argmin=True,\n points_to_evaluate=None,\n max_queue_len=1,\n show_progressbar=True,\n # early_stop_fn=None,\n):\n if rstate is None:\n env_rseed = os.environ.get(\"HYPEROPT_FMIN_SEED\", \"\")\n if env_rseed:\n rstate = np.random.RandomState(int(env_rseed))\n else:\n rstate = np.random.RandomState()\n\n validate_timeout(timeout)\n validate_loss_threshold(loss_threshold)\n\n if allow_trials_fmin and hasattr(trials, \"fmin\"):\n assert False\n # return trials.fmin(\n # fn,\n # space,\n # algo=algo,\n # max_evals=max_evals,\n # timeout=timeout,\n # loss_threshold=loss_threshold,\n # max_queue_len=max_queue_len,\n # rstate=rstate,\n # pass_expr_memo_ctrl=pass_expr_memo_ctrl,\n # verbose=verbose,\n # catch_eval_exceptions=catch_eval_exceptions,\n # return_argmin=return_argmin,\n # show_progressbar=show_progressbar,\n # early_stop_fn=early_stop_fn,\n # )\n\n if trials is None:\n if points_to_evaluate is None:\n trials = base.Trials()\n else:\n assert type(points_to_evaluate) == list\n trials = generate_trials_to_calculate(points_to_evaluate)\n\n domain = base.Domain(fn, space, pass_expr_memo_ctrl=pass_expr_memo_ctrl)\n\n rval = FMinIter(\n algo,\n domain,\n trials,\n max_evals=max_evals,\n timeout=timeout,\n loss_threshold=loss_threshold,\n rstate=rstate,\n verbose=verbose,\n max_queue_len=max_queue_len,\n show_progressbar=show_progressbar,\n # early_stop_fn=early_stop_fn,\n )\n rval.catch_eval_exceptions = catch_eval_exceptions\n\n # next line is where the fmin is actually executed\n rval.exhaust()\n\n if len(trials.trials) == 0:\n raise Exception(\n \"There are no evaluation tasks, cannot return argmin of task losses.\"\n )\n return trials","def optimize(self, iterations=1000):\r\n prev = None\r\n finalx = None\r\n finaly = None\r\n while iterations:\r\n maxei, eis = self.acquisition()\r\n new_y = self.f(maxei)\r\n if maxei == prev:\r\n break\r\n self.gp.update(maxei, new_y)\r\n pycodehack = finaly is None or self.minimize and finaly > new_y\r\n if ((pycodehack or not self.minimize and finaly < new_y)):\r\n finaly = new_y\r\n finalx = maxei\r\n prev = maxei\r\n iterations -= 1\r\n return finalx, finaly","def calc_gradient(self):\n \n self.setup()\n\n # Create our 2D dictionary the first time we execute.\n if not self.gradient:\n for name in self.param_names:\n self.gradient[name] = {}\n \n # Pull initial state and stepsizes from driver's parameters\n base_param = OrderedDict()\n stepsize = {}\n for key, item in self._parent.get_parameters().iteritems():\n base_param[key] = item.evaluate()\n \n if item.fd_step:\n stepsize[key] = item.fd_step\n else:\n stepsize[key] = self.default_stepsize\n\n # For Forward or Backward diff, we want to save the baseline\n # objective and constraints. These are also needed for the\n # on-diagonal Hessian terms, so we will save them in the class\n # later.\n base_data = self._run_point(base_param)\n \n # Set up problem based on Finite Difference type\n if self.form == 'central':\n deltas = [1, -1]\n func = diff_1st_central\n elif self.form == 'forward':\n deltas = [1, 0]\n func = diff_1st_fwrdbwrd\n else:\n deltas = [0, -1]\n func = diff_1st_fwrdbwrd\n\n self.gradient_case = OrderedDict()\n\n # Assemble input data\n for param in self.param_names:\n \n pcase = []\n for j_step, delta in enumerate(deltas):\n \n case = base_param.copy()\n case[param] += delta*stepsize[param]\n pcase.append({ 'param': case })\n \n self.gradient_case[param] = pcase\n \n # Run all \"cases\".\n # TODO - Integrate OpenMDAO's concurrent processing capability once it\n # is formalized. This operation is inherently paralellizable.\n for key, case in self.gradient_case.iteritems():\n for ipcase, pcase in enumerate(case):\n if deltas[ipcase]:\n pcase['data'] = self._run_point(pcase['param'])\n else:\n pcase['data'] = base_data\n \n \n # Calculate gradients\n for key, case in self.gradient_case.iteritems():\n \n eps = stepsize[key]\n \n for name in list(self.objective_names + \\\n self.eqconst_names + \\\n self.ineqconst_names):\n self.gradient[key][name] = \\\n func(case[0]['data'][name],\n case[1]['data'][name], eps)\n\n # Save these for Hessian calculation\n self.base_param = base_param\n self.base_data = base_data","def hmc(f, x, gradf,\n args=(),\n display=False,\n checkgrad=False,\n steps=1,\n nsamples=1,\n nomit=0,\n persistence=False,\n decay=0.9,\n stepadj=0.2,\n window=1,\n use_cython=True,\n return_energies=False,\n return_diagnostics=False,\n ):\n global HMC_MOM\n\n # check some options\n assert steps >= 1, 'step size has to be >= 1'\n assert nsamples >= 1, 'nsamples has to be >= 1'\n assert nomit >= 0, 'nomit has to be >= 0'\n assert decay >= 0, 'decay has to be >= 0'\n assert decay <= 1, 'decay has to be <= 1'\n assert window >= 0, 'window has to be >= 0'\n if window > steps:\n window = steps\n if display:\n print \"setting window size to step size %d\" % window\n\n if persistence:\n alpha = decay\n salpha = np.sqrt(1-alpha**2);\n else:\n alpha = salpha = 0.\n\n nparams = len(x)\n epsilon = stepadj\n\n # Check the gradient evaluation.\n if checkgrad:\n # Check gradients\n error = check_grad(f, gradf, x, *args)\n if display:\n print \"Energy gradient error: %f\"%error\n return error\n\n # Initialize matrix of returned samples\n samples = np.zeros((nsamples, nparams))\n\n # Return energies?\n if return_energies:\n energies = np.zeros(nsamples)\n else:\n energies = np.zeros(0)\n\n # Return diagnostics?\n if return_diagnostics:\n diagn_pos = np.zeros((nsamples, nparams))\n diagn_mom = np.zeros((nsamples, nparams))\n diagn_acc = np.zeros(nsamples)\n else:\n diagn_pos = np.zeros((0,0))\n diagn_mom = np.zeros((0,0))\n diagn_acc = np.zeros(0)\n\n if not persistence or HMC_MOM is None or nparams != len(HMC_MOM):\n # Initialise momenta at random\n p = np.random.randn(nparams)\n else:\n # Initialise momenta from stored state\n p = HMC_MOM\n \n # Main loop.\n all_args = [f,\n x,\n gradf,\n args,\n p,\n samples,\n energies,\n diagn_pos,\n diagn_mom,\n diagn_acc,\n nsamples,\n nomit,\n window,\n steps,\n display,\n persistence,\n return_energies,\n return_diagnostics,\n alpha,\n salpha,\n epsilon]\n\n if use_cython:\n try:\n os.environ['C_INCLUDE_PATH']=np.get_include()\n import pyximport; pyximport.install()\n from hmc2x import hmc_main_loop as c_hmc_main_loop\n if display:\n print \"Using compiled code\"\n nreject = c_hmc_main_loop(*all_args)\n except:\n if display:\n print \"Using pure python code\"\n nreject = hmc_main_loop(*all_args)\n else:\n if display:\n print \"Using pure python code\"\n nreject = hmc_main_loop(*all_args)\n\n if display:\n if display:\n print '\\nFraction of samples rejected: %g\\n'%(nreject/float(nsamples))\n\n # Store diagnostics\n if return_diagnostics:\n diagn = dict()\n diagn['pos'] = diagn_pos # positions matrix\n diagn['mom'] = diagn_mom # momentum matrix\n diagn['acc'] = diagn_acc # acceptance treshold matrix\n diagn['rej'] = nreject/float(nsamples) # rejection rate\n diagn['stps'] = epsilon # stepsize vector\n\n # Store final momentum value in global so that it can be retrieved later\n if persistence:\n HMC_MOM = p\n else:\n HMC_MOM = None\n\n if return_energies or return_diagnostics:\n out = (samples,)\n else:\n return samples\n \n if return_energies: out += (energies,)\n if return_diagnostics: out += (diagn,)\n return out","def update(self, max_norm=1.0):\n \n theta_prime = []\n\n for i, batch in enumerate(self.tasks):\n y_hat = self.constraint(self.theta, self.f(batch)) # gather predictions to single dimension\n loss = self.criteon( y_hat, self.y )\n #compute gradients\n grad = torch.autograd.grad(loss, self.theta)\n #update params\n theta_prime.append( self.theta - self.alpha * grad[0] )\n\n del loss\n\n #perform meta-update\n m_loss = torch.tensor(0.0, requires_grad=True)\n for i in range(len(self.tasks)):\n theta = theta_prime[i]\n batch = self.tasks[i]\n y_hat = self.constraint(theta, self.f(batch)) # gather predictions to single dimension\n m_loss = m_loss + self.criteon( y_hat, self.y ) # updating meta-loss\n \n #zero gradient before running backward pass\n self.meta_optim.zero_grad()\n\n #backward pass\n m_loss.backward(retain_graph=True)\n\n #clip gradients\n nn.utils.clip_grad_norm_([self.theta], max_norm)\n \n #one-step gradient descent\n self.meta_optim.step()","def cost_lm(params, m, optimize=True, plot=False, initial_cost = False, order = None, **kwargs):\n optimization_dictionary = {'nelder-mead': Optimization.fmin_log_params,\n 'levenburg-marquardt least square': Optimization.leastsq_log_params,\n 'levenburg-marquardt': Optimization.fmin_lm_log_params}\n return_dictionary = {}\n try:\n plot_after = kwargs.pop('plot_after')\n except KeyError:\n plot_after = False\n if initial_cost:\n initial_cost = m.cost(params)\n print(('Initial Cost:', initial_cost))\n try:\n if kwargs.pop('plot_before'):\n initial_plot = Plotting.figure()\n\n f=Plotting.plot_model_results(m)\n Plotting.title('Before Optimization')\n return_dictionary[\"initial\"] = initial_plot\n except KeyError:\n pass\n if optimize:\n order.reverse()\n new_params = params.copy()\n for opt in order:\n routine_dict_n = routine_dict_drier(opt.attrib)\n try:\n opt_type = routine_dict_n.pop('type').lower()\n except KeyError:\n opt_type = 'levenburg-marquardt'\n new_params = optimization_dictionary[opt_type](m, new_params, **routine_dict_n)\n optimized_cost = m.cost(new_params)\n params = new_params\n print(('Optimized cost:', optimized_cost))\n # print 'Optimized parameters:', params\n\n if plot or plot_after:\n if not optimize:\n optimized_cost = m.cost(params)\n print(('Optimized cost:', optimized_cost))\n print(('Optimized parameters:', params))\n Plotting.figure()\n f=Plotting.plot_model_results(m)\n for thing in f[0]:\n thing.set_alpha(.7)\n\n Plotting.title('After Optimization')\n return_dictionary[\"params\"] = params\n return return_dictionary","def gradient_descent(x0,df,rate=0.1,max_iters=1000,min_step=1e-6,max_step=1e5,\n projection=None,trajectory=False,step_history=False,f=None,\n cost_history=False,feedback=False,plot_history=False):\n if feedback is True:\n print(\"gd.gradient_descent():\")\n if f is not None:\n assert callable(f)\n fx0 = f(x0)\n if feedback is True:\n print(f\" initial cost = {fx0:.2e}\")\n if projection is not None:\n assert callable(projection)\n project = True\n else:\n project = False\n if trajectory is True:\n xx = [x0.copy()]\n if step_history is True:\n steps = []\n if cost_history is True:\n assert callable(f)\n fx = [fx0]\n\n x = x0.copy()\n for i in range(max_iters):\n dx = -rate*df(x)\n if project is True:\n x0 = x.copy()\n x = projection(x0+dx)\n dx = x-x0\n else:\n x += dx\n if trajectory is True:\n xx.append(x.copy())\n if cost_history is True:\n fx += [f(x)]\n step_size = np.linalg.norm(dx)\n if step_history is True:\n steps += [step_size]\n if step_size < min_step or step_size > max_step:\n break\n\n results = dict()\n results['output'] = x\n if trajectory is True:\n results['trajectory'] = xx\n if cost_history is True:\n results['cost_history'] = fx\n if step_history is True:\n results['step_history'] = steps\n if plot_history is True:\n assert step_history is True or cost_history is True\n plt.figure()\n if step_history is True:\n plt.semilogy(steps,label='step size')\n if cost_history is True:\n plt.semilogy(fx,label='cost')\n plt.xlabel('iteration number')\n plt.title('Gradient Descent')\n plt.legend()\n results['figure'] = plt\n plt.show(block=False)\n \n if feedback is True:\n if f is not None:\n print(f\" final cost = {f(x):.2e}\")\n \n return results","def step(self, closure=None, found_inf: Tensor = None):\n if found_inf is None:\n return super(AdamW, self).step(closure=closure)\n\n if found_inf.shape:\n raise ValueError(\"The found_inf tensor has to be scalar type\")\n\n loss = None\n if closure is not None:\n with torch.enable_grad():\n loss = closure()\n\n for group in self.param_groups:\n params_with_grad = []\n grads = []\n exp_avgs = []\n exp_avg_sqs = []\n max_exp_avg_sqs = []\n state_steps = []\n beta1, beta2 = group['betas']\n\n for p in group['params']:\n if p.grad is not None:\n params_with_grad.append(p)\n if p.grad.is_sparse:\n raise RuntimeError('AdamW does not support sparse gradients')\n grads.append(p.grad)\n\n state = self.state[p]\n\n # Lazy state initialization\n if not state:\n state['step'] = torch.zeros_like(found_inf)\n # Exponential moving average of gradient values\n state['exp_avg'] = torch.zeros_like(\n p, memory_format=torch.preserve_format)\n # Exponential moving average of squared gradient values\n state['exp_avg_sq'] = torch.zeros_like(\n p, memory_format=torch.preserve_format)\n # Maintains max of all exp. moving avg. of sq. grad. values\n state['max_exp_avg_sq'] = torch.zeros_like(\n p, memory_format=torch.preserve_format)\n\n exp_avgs.append(state['exp_avg'])\n exp_avg_sqs.append(state['exp_avg_sq'])\n max_exp_avg_sqs.append(state['max_exp_avg_sq'])\n\n state_steps.append(state['step'])\n\n F.adam_step(\n found_inf,\n state_steps,\n params_with_grad,\n grads,\n exp_avgs,\n exp_avg_sqs,\n max_exp_avg_sqs,\n amsgrad=group['amsgrad'],\n beta1=beta1,\n beta2=beta2,\n lr=group['lr'],\n weight_decay=group['weight_decay'],\n eps=group['eps'],\n maximize=group['maximize'],\n use_adamw=True)\n\n return loss","def __call__(self, parameters) -> ValueEstimate:\n # Encode params to json string\n save_circuit_template_params(parameters, \"current_optimization_params.json\")\n with open(\"current_optimization_params.json\", \"r\") as f:\n current_params_string = f.read()\n\n # POST params to proxy\n evaluation_id = self.client.post_argument_values(current_params_string)\n\n # POST status to EVALUATING\n self.client.post_status(\"EVALUATING\")\n\n # WAIT for status to be OPTIMIZING\n while self.client.get_status() != \"OPTIMIZING\":\n time.sleep(1)\n\n # GET cost function evaluation from proxy\n evaluation_string = self.client.get_evaluation_result(evaluation_id)\n value_estimate = load_value_estimate(io.StringIO(evaluation_string))\n\n return value_estimate","def approximate_gradient(self, theta, c, iter):\n\n true_theta = utils.true_param(theta)\n\n if self.history_count > 0:\n current_goal, _ = self.average_evaluations(30)\n else:\n current_goal = SPSA_minimization.BAD_GOAL\n\n logging.info(f'{__file__} > current_goal: {current_goal}')\n\n print(f'current optimizer mean goal: {current_goal:0.5f} (low is better, lowest: -1.0, highest: 1.0)')\n # print(f'Sample, optimizer goal = -(engine match score) or -(3.0 pts/4 games) or -0.75')\n\n bernouilli = self.create_bernouilli(theta)\n\n count = 0\n while True:\n logging.info(f'{__file__} Apply bernouilli term to theta, theta={theta}, c={c}, bernouilli={bernouilli}')\n # Calculate two evaluations of f at points M + c * bernouilli and\n # M - c * bernouilli to estimate the gradient. We do not want to\n # use a null gradient, so we loop until the two functions evaluations\n # are different. Another trick is that we use the same seed for the\n # random generator for the two function evaluations, to reduce the\n # variance of the gradient if the evaluations use simulations (like\n # in games).\n state = random.getstate()\n theta1 = utils.linear_combinaison(1.0, theta, c, bernouilli)\n logging.info(f'{__file__} theta1: {theta1}')\n\n # Apply parameter limits\n logging.info(f'{__file__} > Apply limits to theta1 before sending to engine')\n theta1 = utils.apply_limits(theta1)\n logging.info(f'{__file__} theta1 with limits: {theta1}')\n logging.info(f'{__file__} > run 1st match with theta1: {theta1}')\n\n random.setstate(state)\n theta2 = utils.linear_combinaison(1.0, theta, -c, bernouilli)\n logging.info(f'{__file__} theta2: {theta2}')\n\n # Apply parameter limits\n logging.info(f'{__file__} > Apply limits to theta2 before sending to engine')\n theta2 = utils.apply_limits(theta2)\n logging.info(f'{__file__} theta2 with limits: {theta2}')\n logging.info(f'{__file__} > run 2nd match with theta2: {theta2}')\n\n # Run the 2 matches in parallel after iteration 1.\n manager = multiprocessing.Manager()\n res = manager.dict()\n thetas = [theta1, theta2]\n\n if iter < self.iter_parallel_start:\n print('Run match 1 ...')\n true_param = utils.true_param(theta1)\n print('test_engine param:')\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\n print(f' {name}: {val[\"value\"]}, ({val[\"value\"] - val1[\"value\"]:+})')\n\n print('base_engine param:')\n for name, val in utils.true_param(theta).items():\n print(f' {name}: {val[\"value\"]}')\n\n t1 = time.perf_counter()\n f1 = self.evaluate_goal(theta1, theta, 0, res, iter)\n logging.info(f'f1 elapse: {time.perf_counter() - t1:0.2f}s')\n print(f'Done match 1!, elapse: {time.perf_counter() - t1:0.2f}sec')\n print(f'goal after match 1: {f1:0.5f}')\n\n # Run match 2\n print('Run match 2 ...')\n true_param = utils.true_param(theta2)\n print('test_engine param:')\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\n print(f' {name}: {val[\"value\"]}, ({val[\"value\"] - val1[\"value\"]:+})')\n\n print('base_engine param:')\n for name, val in utils.true_param(theta).items():\n print(f' {name}: {val[\"value\"]}')\n\n t1 = time.perf_counter()\n f2 = self.evaluate_goal(theta2, theta, 1, res, iter)\n logging.info(f'f2 elapse: {time.perf_counter() - t1:0.2f}s')\n print(f'Done match 2!, elapse: {time.perf_counter() - t1:0.2f}sec')\n print(f'goal after match 2: {f2:0.5f}')\n\n print('Done engine match!')\n else:\n print('Run 2 matches in parallel ...')\n t1 = time.perf_counter()\n jobs = []\n for i in range(2):\n print(f'Run match {i + 1} ...')\n\n true_param = utils.true_param(thetas[i])\n print('test_engine param:')\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\n print(f' {name}: {val[\"value\"]}, ({val[\"value\"] - val1[\"value\"]:+})')\n\n print('base_engine param:')\n for name, val in utils.true_param(theta).items():\n print(f' {name}: {val[\"value\"]}')\n\n p = multiprocessing.Process(target=self.evaluate_goal, args=(thetas[i], theta, i, res, iter))\n jobs.append(p)\n p.start()\n\n for num, proc in enumerate(jobs):\n proc.join()\n\n # If match is done in parallel, update the history count, eval and theta here.\n self.history_eval[self.history_count % 1000] = res.values()[num]\n self.history_theta[self.history_count % 1000] = thetas[num]\n self.history_count += 1\n\n print(f'Done match {num + 1}!, elapse: {time.perf_counter() - t1:0.2f}sec')\n\n logging.info(f'parallel elapse: {time.perf_counter() - t1:0.2f}s')\n\n print('Done engine match!')\n\n f1, f2 = res.values()[0], res.values()[1]\n\n logging.info(f'{__file__} > f1: {f1}, f2: {f2}')\n print(f'optimizer goal after match 1: {f1:0.5f} (low is better)')\n print(f'optimizer goal after match 2: {f2:0.5f} (low is better)')\n\n if f1 != f2:\n break\n\n print('perf is the same in match 1 and 2, launch new matches ...')\n\n count = count + 1\n logging.info(f'{__file__} > f1 and f2 are the same, try the engine match again. num_tries = {count}')\n\n if count >= 100:\n logging.info(f'{__file__} > too many evaluation to find a gradient, function seems flat')\n break\n\n # Update the gradient\n gradient = copy.deepcopy(theta)\n # print(f'Basic gradient after 2 engine matches:')\n for name, value in theta.items():\n gradient[name]['value'] = (f1 - f2) / (2.0 * c * bernouilli[name]['value'])\n # print(f' {name}: {gradient[name][\"value\"]}')\n logging.info(f'{__file__} > {name} gradient: {gradient}')\n\n if (f1 > current_goal) and (f2 > current_goal):\n logging.info(f'{__file__} > function seems not decreasing')\n gradient = utils.linear_combinaison(0.1, gradient)\n\n print('Modify the gradient because the results of engine matches\\n'\n 'did not improve when using the new param. But we will not\\n'\n 're-run the engine matches.')\n\n print('Modified gradient at alpha=0.1:')\n for n, v in gradient.items():\n print(f' {n}: {v[\"value\"]}')\n\n # For the correction factor used in the running average for the gradient,\n # see the paper \"Adam: A Method For Stochastic Optimization, Kingma and Lei Ba\"\n\n beta = 0.9\n correction = 1.0 / 1.0 - pow(beta, self.iter)\n\n gradient = utils.linear_combinaison((1 - beta), gradient, beta, self.previous_gradient)\n gradient = utils.linear_combinaison(correction, gradient)\n\n # print('New gradient after applying correction:')\n # for n, v in gradient.items():\n # print(f' {n}: {v[\"value\"]}')\n\n # Store the current gradient for the next time, to calculate the running average\n self.previous_gradient = gradient\n\n # Store the best the two evals f1 and f2 (or both)\n if (f1 <= current_goal):\n self.best_eval[self.best_count % 1000] = f1\n self.best_theta[self.best_count % 1000] = theta1\n self.best_count += 1\n\n if (f2 <= current_goal):\n self.best_eval[self.best_count % 1000] = f2\n self.best_theta[self.best_count % 1000] = theta2\n self.best_count += 1\n\n logging.info(f'{__file__} > final gradient: {gradient}')\n \n # Return the estimation of the new gradient\n return gradient","def run_migrad(self, fitarg, **kwargs):\n self.fitarg = fitarg\n kwargs['up'] = 1.\n\n\n logging.debug(self._par_names)\n logging.debug(self.__wrap_likelihood(list(fitarg['pinit'].values())))\n\n if kwargs['scipy']:\n self._res = op.minimize(self.__wrap_likelihood,\n list(fitarg['pinit'].values()),\n bounds=list(fitarg['limits'].values()),\n method='TNC',\n #method='Powell',\n options={'maxiter': kwargs['ncall']} #'xtol': 1e-20, 'eps' : 1e-20, 'disp': True}\n #tol=None, callback=None,\n #options={'disp': False, 'minfev': 0, 'scale': None,\n #'rescale': -1, 'offset': None, 'gtol': -1,\n #'eps': 1e-08, 'eta': -1, 'maxiter': kwargs['ncall'],\n #'maxCGit': -1, 'mesg_num': None, 'ftol': -1, 'xtol': -1, 'stepmx': 0,\n #'accuracy': 0}\n )\n logging.info(self._res)\n for i, k in enumerate(self._par_names):\n fitarg[k] = self._res.x[i]\n\n logging.debug(fitarg)\n\n cmd_string = \"lambda {0}: self.__calcLikelihood({0})\".format(\n (\", \".join(self._par_names), \", \".join(self._par_names)))\n\n string_args = \", \".join(self._par_names)\n global f # needs to be global for eval to find it\n f = lambda *args: self.__calc_likelihood(*args)\n\n cmd_string = \"lambda %s: f(%s)\" % (string_args, string_args)\n logging.debug(cmd_string)\n\n # work around so that the parameters get names for minuit\n self._minimize_f = eval(cmd_string, globals(), locals())\n self._minimize_f.errordef = minuit.Minuit.LEAST_SQUARES\n\n self._m = minuit.Minuit(self._minimize_f,\n #list(fitarg['pinit'].values()),\n **fitarg['pinit'],\n #names=self._par_names\n )\n# print_level=kwargs['verbosity'],\n# errordef=kwargs['up'],\n# pedantic=kwargs['pedantic'],\n #**fitarg)\n\n for p in self._par_names:\n self._m.fixed[p] = fitarg['fix'][p]\n self._m.limits[p] = fitarg['limits'][p]\n self._m.errors[p] = fitarg['error'][p]\n\n self._m.tol = kwargs['tol']\n self._m.strategy = kwargs['strategy']\n\n logging.debug(\"tol {0:.2e}, strategy: {1:n}\".format(\n self._m.tol, self._m.strategy.strategy))\n\n self._m.migrad(ncall=kwargs['ncall']) #, precision = kwargs['precision'])","def grad_wrapper(*wrapper_args, variables=None):\n\n @custom_gradient\n def inner_recompute_grad(*dresult):\n \"\"\"Nested custom gradient function for computing grads in reverse and forward mode autodiff.\"\"\"\n # Gradient calculation for reverse mode autodiff.\n with backprop.GradientTape() as t:\n id_args = nest.map_structure(gen_array_ops.identity, args)\n # Tuple `dresult` should contain at least one tensor.\n assert len(dresult) >= 1\n\n if not context.executing_eagerly():\n # XLA doesn't respect `tf.control_dependencies`. The code block\n # below manually adds a data dependency to `dresult` to ensure\n # recomputation of `f(*args, **kwargs)` happens after `dresult`.\n\n # This works even if `dresult[0]` is a size 0 tensor as reduce_max\n # of a size 0 tensor returns -inf. Use reshape here to avoid reading\n # the entire `dresult[0]`.\n elem = math_ops.reduce_max(array_ops.reshape(dresult[0], [-1])[:1])\n # Cast elem to bool in case elem is NaN.\n elem_bool = math_ops.cast(elem, dtypes.bool)\n dresult_dep = array_ops.where_v2(\n elem_bool == elem_bool, 0., float(\"nan\")) # pylint: disable=comparison-with-itself\n id_args = nest.map_structure(\n lambda x: x + math_ops.cast(dresult_dep, x.dtype), id_args)\n\n t.watch(id_args)\n if variables is not None:\n t.watch(variables)\n with variable_scope.variable_scope(current_var_scope):\n recomputed_result = f(*id_args, **kwargs)\n kw_vars = []\n if variables is not None:\n kw_vars = list(variables)\n grads = t.gradient(\n recomputed_result,\n list(id_args) + kw_vars,\n output_gradients=dresult,\n unconnected_gradients=UnconnectedGradients.ZERO)\n\n def transpose(*t_args, **t_kwargs):\n \"\"\"Gradient function calculation for forward mode autodiff.\"\"\"\n # Just throw an error since gradients / activations are not stored on\n # tape for recompute.\n raise NotImplementedError(\n \"recompute_grad tried to transpose grad of {}. \"\n \"Consider not using recompute_grad in forward mode\"\n \"autodiff\".format(f.__name__))\n\n return (grads[:len(id_args)], grads[len(id_args):]), transpose\n\n return inner_recompute_grad(*wrapper_args)","def __call__(self, step, inputs, hparams={}):\n\t\tstep+=1\n\n\t\t# apply gradient tape\n\t\ttape, loss = self.tape_gradients(inputs, **hparams)\n\t\t\n\t\t# check nan in loss\n\t\tif np.isnan(loss.numpy()):\n\t\t\tstring=\"Nan Loss on step %s:\\t rec loss = %s\\t, reg loss = %s\\t\" % (\n\t\t\t\tstep, \n\t\t\t\tself.reconstruction_loss.numpy(),\n\t\t\t\tself.regularization_loss.numpy(),\n\t\t\t\t)\n\t\t\treturn np.nan\n\n\t\t# optimize\n\t\tself.run_optimizer(tape, loss)\n\n\t\tprint('\\033[Kstep %s:\\t rec loss = %s\\t, reg loss = %s\\t' % (\n\t\t\tstep, \n\t\t\tself.reconstruction_loss.numpy(),\n\t\t\tself.regularization_loss.numpy(),\n\t\t\t), \"\\r\", end=\"\")\n\n\t\treturn step","def opt_step(latent_values, real_coding, loss_weight, mse, \n generator, optimizer, ntimes, ninput):\n with tf.GradientTape() as tape:\n tape.watch(latent_values)\n # results from generator\n gen_output = generator(latent_values, training=False)\n loss = mse_loss(mse, real_coding, gen_output[:, :(ntimes - 1), :, :], \n loss_weight, ninput)\n\n # gradient of the loss ws to the input\n gradient = tape.gradient(loss, latent_values)\n # applies gradients to the input\n optimizer.apply_gradients(zip([gradient], [latent_values]))\n\n return loss","def __call__(self, origin, function, state, **kwargs):\n direction = state['direction']\n ak = 0.\n if 'initial_alpha_step' in state:\n bk = state['initial_alpha_step']\n else:\n bk = self.stepSize\n v_bk = function(origin + bk * direction)\n\n while abs(bk - ak) > self.minStepSize:\n v_ak = function(origin + ak * direction)\n g_ak = numpy.dot(function.gradient(origin + ak * direction), direction)\n ck = ak - .5 * (ak - bk) * g_ak / (g_ak - (v_ak - v_bk) / (ak - bk))\n v_ck = function(origin + ck * direction)\n\n bk = ak\n ak = ck\n v_bk = v_ak\n v_ak = v_ck\n\n state['alpha_step'] = ck\n return origin + ck * direction","def optimise_fn(self, x):\n\n success = self._set_material_parameters(x)\n if not success:\n return self._bad_metric()\n\n # some iterations are repeated so cache the results to avoid unnecessary iterations\n cached_result_key = tuple(x)\n metric_value = self.cached_results.get(cached_result_key)\n\n if metric_value is None:\n print('--> Optimiser: {}'.format(self.material_model))\n\n sim_result = fs.run_simulation(stoma_cfg=self.stoma_cfg,\n from_optimiser=True)\n\n # when the simulation fails we want a non-constant measure for the optimiser to use\n metric_value = sim_result.metric_value if sim_result.success else self._bad_metric()\n\n self.cached_results[cached_result_key] = metric_value\n\n print('--> Optimiser: {} - metric={}'.format(self.material_model, metric_value))\n else:\n print('--> Optimiser: {} - metric={} (cached result)'.format(self.material_model, metric_value))\n\n return metric_value","def MAXED(N, sigma2, R, f_def, params):\n\n # pull out algorithm-specific parameters\n Omega = params['Omega']\n\n # create the function that we will maximize, Z\n def Z(lam, N, sigma2, R, f_def, Omega):\n \"\"\"A function, the maximization of which is equivalent to the\n maximization of \"\"\"\n\n A = - np.sum(f_def * np.exp(- np.sum((lam * R.T).T, axis=0)))\n B = - (Omega * np.sum(lam**2 * sigma2))**(0.5)\n C = - np.sum(N * lam)\n\n # negate because it's a minimization\n return - (A + B + C)\n\n # create a lambda\n lam = np.ones(len(N))\n\n # apply the simulated annealing to the Z\n mk = {'args': (N, sigma2, R, f_def, Omega)}\n lam = basinhopping(Z, lam, minimizer_kwargs=mk).x\n\n # back out the spectrum values from the lam\n return f_def * np.exp(-np.sum((lam * R.T).T, axis=0))","def optimizing(theta, data = data, target = target):\n # num = (sin(individual[0] - individual[1] / 8))**2 + (sin(individual[1] + individual[0] / 8))**2\n # denum = ((individual[0] - 8.6998)**2 + (individual[1] - 6.7665)**2)**0.5 + 1\n learner = MLPClassifier(hidden_layer_sizes=theta[0], learning_rate_init=theta[1], alpha=theta[2], verbose=True, early_stopping=True, n_iter_no_change=6)\n\n model = learner.fit(data, target)\n return model.best_loss_ # return the best error/residual (best error is cloes to zero) The error of a model is the difference between your predicted outcome and the real observed outcome and therefore 0 is desired\n\n # individual as a factor containing x, y = to tetha which ","def gradientdescent(cost_func, theta, args=(), delta_func = 0):\n step = 1\n old_cost = 0\n while True:\n theta_old = theta.copy()\n cost = cost_func(theta, *args)\n delta = delta_func(theta, *args)\n theta = theta - step * delta\n if cost > old_cost and old_cost != 0:\n step = step*0.7\n if np.allclose(theta_old, theta):\n break\n old_cost = cost\n return theta","def poll(target, step, args=(), kwargs=None, timeout=None, max_tries=None, check_success=is_truthy,\n step_function=step_constant, ignore_exceptions=(), poll_forever=False, collect_values=None, *a, **k):\n\n logging.info('Starting Polling')\n\n assert (timeout is not None or max_tries is not None) or poll_forever, \\\n ('You did not specify a maximum number of tries or a timeout. Without either of these set, the polling '\n 'function will poll forever. If this is the behavior you want, pass \"poll_forever=True\"')\n\n assert not ((timeout is not None or max_tries is not None) and poll_forever), \\\n 'You cannot specify both the option to poll_forever and max_tries/timeout.'\n\n kwargs = kwargs or dict()\n values = collect_values or Queue()\n\n max_time = Time.time() + timeout if timeout else None\n tries = 0\n logging.debug('Max Time: ' + str(max_time))\n logging.debug('Max Tries: ' + str(max_tries))\n\n last_item = None\n while True:\n\n if max_tries is not None and tries >= max_tries:\n raise MaxCallException(values, last_item)\n\n try:\n logging.debug('Arguments: ' + str(args))\n val = target(*args, **kwargs)\n logging.debug('Results from Target running: ' + str(val))\n last_item = val\n logging.info('Try #:' + str(tries))\n DisplayMessage('Try #:' + str(tries))\n except ignore_exceptions as e:\n logging.error(str(e))\n last_item = e\n else:\n # Condition passes, this is the only \"successful\" exit from the polling function\n if check_target_success(val):\n return val\n\n logging.debug('last result from poll: ' + str(last_item))\n # Condition passes, this is the only \"successful\" exit from the polling function\n if check_target_success(val):\n return val\n else:\n values.put(last_item)\n tries += 1\n # Check the time after to make sure the poll function is called at least once\n if max_time is not None and Time.time() >= max_time:\n # raise TimeoutException(values, last_item)\n logging.info('Time out reached.')\n logging.info('Checking status of job: ' + val)\n logging.info('Job will now sleep for an additional: ' + step)\n logging.debug('Step value: ' + str(step))\n Time.sleep(step)\n step = step_function(step)","def optimize(self, y = None, x=None, store_path=None, epochs = 25, learning_rate = 0.005, scoring_method = \"mse\", criterion = MSELoss(), \n reparam_f = None, ODE_criterion = None, init_conditions = None, scale = True, force = None, backprop_f = None, backprop = False,\n ode_coefs = None, solve = True, rounds = None, tr_score_prop = 0.5, q = None, eq_system = False, n_outputs = None, \n nonlinear_ode = False, reg_type = \"nl_ham\"):\n font = {'size' : 18}\n plt.rc('font', **font)\n \n #self.multiple_ICs = True if len(init_conditions[0]) > 1 else False\n self.n_outputs = n_outputs\n if n_outputs != len(init_conditions):\n assert False, \"n_outputs must match the len of ode_coefs and init_conds\"\n self.nl = nonlinear_ode\n self.log2 = np.log(2)\n self.q = q\n self.eq_system = eq_system\n self.rounds = rounds\n self.tr_score_prop = tr_score_prop\n self.solve = solve\n self.ode_coefs = ode_coefs\n if self.batch_size > 1:\n if reg_type == \"driven_pop\":\n custom_loss = driven_pop_loss\n force = fforce\n elif reg_type == \"simple_pop\":\n custom_loss = driven_pop_loss\n force = no_fforce\n elif reg_type == \"ham\":\n custom_loss = ham_loss\n elif reg_type == \"no_reg\":\n custom_loss = no_reg_loss\n elif reg_type == \"elastic\":\n custom_loss = elastic_loss\n elif reg_type == \"hennon\":\n custom_loss = hennon_hailes_loss\n else:\n assert False\n self.ODE_criterion = custom_loss\n if backprop_f:\n self.backprop_f = optimize_last_layer\n else:\n self.backprop_f = None\n self.epochs = epochs\n else:\n self.ODE_criterion = ODE_criterion\n self.backprop_f = backprop_f\n\n self.init_conditions = init_conditions\n \n self.scale = scale\n\n if self.batch_size > 1:\n self.reparam_f = freparam\n #self.force = fforce\n else:\n self.reparam_f = reparam_f\n self.force = force\n\n self.scoring_method = scoring_method\n self.criterion = criterion\n self.epochs = epochs\n self.learning_rate = learning_rate\n\n \"\"\"\n if self.ODE: \n if self.dt != None:\n #self.alpha = self.leaking_rate[0] / self.dt\n\n start, stop = float(x[0]), float(x[-1])\n nsteps = int((stop - start) / self.dt)\n x = torch.linspace(start, stop, steps = nsteps, requires_grad=False).view(-1,1).to(self.device)\n elif type(x) == type([]) and len(X) == 3:\n x0, xf, nsteps = x #6*np.pi, 100\n x = torch.linspace(x0, xf, steps = nsteps, requires_grad=False).view(-1,1).to(self.device)\n else:\n assert False, \"Please input start, stop, dt\"\n else:\n #ensure that X is a two dimensional tensor, or if X is None declare a tensor.\n X = check_x(X, y, self.dev).to(self.device)\n \"\"\"\n \n # Checks\n if not self.ODE_order:\n self.validate_data(y, x, self.verbose)\n \n # Initialize new random state\n if self.reservoir_matrices != None:\n if self.ODE_order:\n \n \n self.reservoir_matrices.n_inputs_ = x.shape[1]\n\n else:\n\n self.reservoir_matrices.n_inputs_ = max(y.shape[1] - 1, 1) if type(x) == type(None) else x.shape[1]\n \n self.reservoir_matrices.gen_in_weights()\n\n self.random_state = Generator().manual_seed(self.seed + 2)\n\n init_device = self.device if not self.windowsOS else torch.device('cpu')\n\n if not self.ODE_order:\n if type(y) == np.ndarray:\n y = torch.tensor(y, device = init_device, requires_grad = False)\n if len(y.shape) == 1:\n y = y.view(-1, 1)\n if y.device != self.device:\n y = y.to(init_device)\n self.y = y.type(self.dtype) \n else:\n self.y = None\n\n self.x = x.type(self.dtype) if x is not None else None #torch.ones(*y.shape)\n\n # Inform user\n if self.verbose:\n print(\"Model initialization and exploration run...\")\n \n if self.interactive:\n self.fig, self.ax = pl.subplots(1,3, figsize = (16,4))\n \n self.errorz, self.errorz_step, self.length_progress = [], [], []\n dim = len(self.free_parameters)\n self.state = TurboState(dim, length_min = self.length_min, \n batch_size=self.batch_size, success_tolerance = self.success_tolerance)\n \n self.count = 1\n\n\n declaration_args = {'activation_f' : self.activation_function,\n 'act_f_prime' : self.act_f_prime,\n #'backprop' : self.backprop,\n 'n_outputs' : self.n_outputs,\n #'model_type' : self.model_type,\n #'input_weight_type' : self.input_weight_type, \n 'approximate_reservoir' : self.approximate_reservoir,\n \"device\" : self.device,\n \"reservoir\" : self.reservoir_matrices\n }\n train_args = {\"burn_in\" : self.esn_burn_in, \n \"ODE_order\" : self.ODE_order,\n #\"track_in_grad\" : self.track_in_grad,\n \"force\" : self.force,\n \"reparam_f\" : self.reparam_f,\n \"init_conditions\" : self.init_conditions,\n \"ode_coefs\" : self.ode_coefs,\n \"q\" : self.q,\n \"eq_system\" : self.eq_system,\n \"nl\" : self.nl,\n \"backprop_f\" : self.backprop_f,\n \"epochs\" : self.epochs,\n \"SOLVE\" : self.solve, \n #\"track_in_grad\" : False,\n \"init_conditions\" : self.init_conditions,\n #\"SCALE\" : self.scale,\n \"reparam_f\" : self.reparam_f,\n \"ODE_criterion\" : self.ODE_criterion\n #\"multiple_ICs\" : self.multiple_ICs\n }\n\n backprop_args = {\"backprop_f\" : self.backprop_f,\n \"epochs\" : self.epochs}\n\n test_args = {\"scoring_method\" : self.scoring_method,\n \"reparam\": self.reparam_f,\n \"ODE_criterion\" : self.ODE_criterion}\n cv_args = {\"rounds\" : self.rounds,\n \"tr_score_prop\" : self.tr_score_prop,\n \"log_score\": self.log_score}\n\n self.parallel_arguments = {\"declaration_args\": declaration_args, #\"RC\" : RC,\n \"train_args\": train_args,\n \"test_args\" : test_args,\n \"backprop_args\" : backprop_args,\n \"device\" : self.device,\n \"cv_args\" : cv_args\n }\n\n X_init = get_initial_points(self.scaled_bounds.shape[1], self.initial_samples, device = self.device, dtype = self.dtype)\n \n if len(X_init) > self.batch_size:\n for i in range(X_init.shape[0] // self.batch_size):\n #print(i)\n X_batch = X_init[ (i*self.batch_size) : ((i+1)*self.batch_size), : ]\n Y_batch = self.eval_objective( X_batch ) \n \n if not i:\n X_turbo = X_batch\n Y_turbo = Y_batch \n else:\n Y_turbo = cat((Y_turbo, Y_batch), dim=0)\n X_turbo = cat((X_turbo, X_batch), dim=0)\n else:\n\n X_turbo = X_init\n Y_turbo = self.eval_objective( X_init)\n \n #X_turbo.share_memory()\n #Y_turbo = tensor(\n # [self.eval_objective(x.view(1,-1)) for x in X_turbo], dtype=dtype, device=device).unsqueeze(-1)\n X_turbo = X_turbo.to(self.device)\n Y_turbo = Y_turbo.to(self.device)\n\n self.X_turbo, self.Y_turbo = X_turbo, Y_turbo\n \n n_init = self.initial_samples\n\n #append the errorz to errorz_step\n self.errorz_step += [max(self.errorz)] * X_turbo.shape[0] #n_init\n \n self.count = 0\n # Run until TuRBO converges\n while not self.state.restart_triggered: \n\n # Fit a GP model\n train_Y = (Y_turbo - Y_turbo.mean()) / Y_turbo.std()\n likelihood = GaussianLikelihood(noise_constraint=Interval(1e-8, 1e-3))\n model = SingleTaskGP(X_turbo, train_Y, likelihood=likelihood)\n mll = ExactMarginalLogLikelihood(model.likelihood, model)\n fit_gpytorch_model(mll)\n\n # Create a batch\n X_next = generate_batch(\n state=self.state,\n model=model,\n X=X_turbo,\n Y=train_Y,\n batch_size=self.batch_size,\n n_candidates=min(5000, max(2000, 200 * dim)),\n num_restarts=10,\n raw_samples=512,\n acqf=\"ts\",\n device = self.device\n )\n X_next = X_next\n\n #assert 1 ==0, X_next\n\n #can be parallelized:\n Y_next = self.eval_objective( X_next) #tensor()#.unsqueeze(-1)\n #[self.eval_objective(x.view(1,-1)) for x in X_next],\n print('Y_next', Y_next)\n print(\"self.state\", self.state)\n # Update state \n self.state = update_state(state=self.state, Y_next=Y_next)\n\n # Append data\n X_turbo = cat((X_turbo, X_next), dim=0)\n Y_turbo = cat((Y_turbo, Y_next), dim=0)\n \n # Print current status\n print( \n f\"{len(X_turbo)}) Best score: {max(Y_next).item():.4f}, TR length: {self.state.length:.2e}\" + \n f\" length {self.state.length}\"# Best value:.item() {state.best_value:.2e},\n )\n \n print( \n f\"TR length: {self.state.length:.2e},\" + f\" min length {self.state.length_min:.2e}\"\n # + Best value:.item() {state.best_value:.2e},\n )\n\n self.errorz_step += [min(self.errorz)] * self.batch_size\n\n #assert len(self.errorz) == len(self.errorz_step), \"err len: {}, err step: {}\".format(len(self.errorz), len(self.errorz_step) )\n else:\n display.clear_output()\n\n \n #display.clear_output(wait=True) \n #display.display(pl.gcf())\n \n # Save to disk if desired\n if not store_path is None:\n with open(store_path, 'w+') as output_file:\n json.dump(best_arguments, output_file, indent=4)\n \n best_vals = X_turbo[torch.argmax(Y_turbo)]\n\n \n \n denormed_ = self.denormalize_bounds(best_vals)\n \n try:\n denormed_ = denormalize_bounds(best_vals)\n except:\n print(\"FAIL\")\n\n best_vals = X_turbo[torch.argmax(Y_turbo)]\n\n #####Bad temporary code to change it back into a dictionary\n denormed_free_parameters = list(zip(self.free_parameters, denormed_))\n denormed_free_parameters = dict([ (item[0], item[1].item()) for item in denormed_free_parameters])\n\n best_hyper_parameters = denormed_free_parameters\n for fixed_parameter in self.fixed_parameters:\n best_hyper_parameters = {fixed_parameter : self.bounds[fixed_parameter], **best_hyper_parameters }\n\n #log_vars = ['connectivity', 'llambda', 'llambda2', 'noise', 'regularization', 'dt']\n for var in self.log_vars:\n if var in best_hyper_parameters:\n best_hyper_parameters[var] = 10. ** best_hyper_parameters[var] \n \n # Return best parameters\n return best_hyper_parameters #X_turbo, Y_turbo, state, best_vals, denormed_ #best_arguments","def mpi_split_evaluator_run(target_evaluator,\n termination_params=None,\n core_params=None,\n exception_handling_params=None,\n log=None,\n #---> Insertion starts\n gradient_only=False,\n line_search=True):\n #<--- Insertion ends\n from libtbx.mpi4py import MPI\n comm = MPI.COMM_WORLD\n rank = comm.Get_rank()\n size = comm.Get_size()\n\n if (termination_params is None):\n termination_params = termination_parameters()\n if (core_params is None):\n core_params = core_parameters()\n if (exception_handling_params is None):\n exception_handling_params = exception_handling_parameters()\n x = target_evaluator.x\n if (log is not None):\n print(\"lbfgs minimizer():\", file=log)\n print(\" x.size():\", x.size(), file=log)\n print(\" m:\", core_params.m, file=log)\n print(\" maxfev:\", core_params.maxfev, file=log)\n print(\" gtol:\", core_params.gtol, file=log)\n print(\" xtol:\", core_params.xtol, file=log)\n print(\" stpmin:\", core_params.stpmin, file=log)\n print(\" stpmax:\", core_params.stpmax, file=log)\n print(\"lbfgs traditional_convergence_test:\", \\\n termination_params.traditional_convergence_test, file=log)\n minimizer = ext.minimizer(\n x.size(),\n core_params.m,\n core_params.maxfev,\n core_params.gtol,\n core_params.xtol,\n core_params.stpmin,\n core_params.stpmax)\n if (termination_params.traditional_convergence_test):\n is_converged = ext.traditional_convergence_test(\n x.size(),\n termination_params.traditional_convergence_test_eps)\n else:\n is_converged = ext.drop_convergence_test(\n n_test_points=termination_params.drop_convergence_test_n_test_points,\n max_drop_eps=termination_params.drop_convergence_test_max_drop_eps,\n iteration_coefficient\n =termination_params.drop_convergence_test_iteration_coefficient)\n callback_after_step = getattr(target_evaluator, \"callback_after_step\", None)\n diag_mode = getattr(target_evaluator, \"diag_mode\", None)\n if (diag_mode is not None): assert diag_mode in [\"once\", \"always\"]\n f_min, x_min = None, None\n f, g = None, None\n try:\n while 1:\n if (diag_mode is None):\n #XXX Only the diag_mode==None case is currently implemented, just as example\n f_term, g_term = target_evaluator.compute_functional_and_gradients()\n f_total = comm.reduce(f_term, MPI.SUM, 0)\n g_total = comm.reduce(g_term, MPI.SUM, 0)\n if rank==0: transmit = (f_total,g_total)\n else: transmit = None\n f, g = comm.bcast(transmit, root=0)\n if False and rank==0: # for debug\n print (\"%s %10.4f\"%(\"MPI stp\",f),\"[\",\" \".join([\"%10.4f\"%a for a in x]),\"]\")\n d = None\n else:\n f, g, d = target_evaluator.compute_functional_gradients_diag()\n if (diag_mode == \"once\"):\n diag_mode = None\n if (f_min is None):\n if (not termination_params.traditional_convergence_test):\n is_converged(f)\n f_min, x_min = f, x.deep_copy()\n elif (f_min > f):\n f_min, x_min = f, x.deep_copy()\n if (log is not None):\n print(\"lbfgs minimizer.run():\" \\\n \" f=%.6g, |g|=%.6g, x_min=%.6g, x_mean=%.6g, x_max=%.6g\" % (\n f, g.norm(), flex.min(x), flex.mean(x), flex.max(x)), file=log)\n if (d is None):\n #---> Insertion starts\n if (minimizer.run(x, f, g, gradient_only,line_search)): continue\n #<--- Insertion ends\n else:\n #---> Insertion starts\n if (minimizer.run(x, f, g, d, gradient_only,line_search)): continue\n #<--- Insertion ends\n if (log is not None):\n print(\"lbfgs minimizer step\", file=log)\n if (callback_after_step is not None):\n if (callback_after_step(minimizer) is True):\n if (log is not None):\n print(\"lbfgs minimizer stop: callback_after_step is True\", file=log)\n break\n if (termination_params.traditional_convergence_test):\n if ( minimizer.iter() >= termination_params.min_iterations\n and is_converged(x, g)):\n if (log is not None):\n print(\"lbfgs minimizer stop: traditional_convergence_test\", file=log)\n break\n else:\n if (is_converged(f)):\n if (log is not None):\n print(\"lbfgs minimizer stop: drop_convergence_test\", file=log)\n break\n if ( termination_params.max_iterations is not None\n and minimizer.iter() >= termination_params.max_iterations):\n if (log is not None):\n print(\"lbfgs minimizer stop: max_iterations\", file=log)\n break\n if ( termination_params.max_calls is not None\n and minimizer.nfun() > termination_params.max_calls):\n if (log is not None):\n print(\"lbfgs minimizer stop: max_calls\", file=log)\n break\n if (d is None):\n #---> Insertion starts\n if (not minimizer.run(x, f, g, gradient_only,line_search)): break\n #<--- Insertion ends\n else:\n #---> Insertion starts\n if (not minimizer.run(x, f, g, d, gradient_only,line_search)): break\n #<--- Insertion ends\n except RuntimeError as e:\n minimizer.error = str(e)\n if (log is not None):\n print(\"lbfgs minimizer exception:\", str(e), file=log)\n if (x_min is not None):\n x.clear()\n x.extend(x_min)\n error_classification = exception_handling_params.filter(\n minimizer.error, x.size(), x, g)\n if (error_classification > 0):\n raise\n elif (error_classification < 0):\n minimizer.is_unusual_error = True\n else:\n minimizer.is_unusual_error = False\n else:\n minimizer.error = None\n minimizer.is_unusual_error = None\n if (log is not None):\n print(\"lbfgs minimizer done.\", file=log)\n return minimizer","def minimize_batch(target_fn, gradient_fn, theta_0, tolerance=0.0000001):\n\n step_sizes = [ 100, 10, 1, 0.1, 0.01, 0.001, 0.0001, 0.00001]\n\n theta = theta_0\n target_fn = safe(target_fn)\n value = target_fn(theta)\n\n while True:\n gradient = gradient_fn(theta)\n next_thetas = [step(theta, gradient, -step_size)\n for step_size in step_sizes]\n next_theta = min(next_thetas, key=target_fn)\n next_value = target_fn(next_theta)\n\n if abs(value - next_value) < tolerance:\n return theta\n else:\n theta, value = next_theta, next_value","def produce_max(self, *args, **kwargs):\n raise NotImplementedError('This interaction has no produce_max method yet!')","def _optimize(self, X, y, W, steps):\n\n X = X.flatten(1)\n\n min_x, max_x = X.min(), X.max()\n len_x = max_x - min_x\n \n bestd = 1\n bestp = min_x\n minerr = W.sum()\n\n if len_x > 0.0:\n for p in np.arange(min_x, max_x, len_x/steps):\n for d in [-1, 1]:\n gy = np.ones((y.size))\n gy[X*d < p*d] = -1\n err = np.sum((gy != y)*W)\n if err < minerr:\n minerr = err\n bestd = d\n bestp = p\n\n return minerr, bestd, bestp","def gd(x0,gradient,learning_rate=1.0,min_step=1e-16,max_iters=1000,**kwargs):\n x = x0; i = 0; step_size = np.Inf\n while step_size > min_step and i < max_iters:\n x0 = x\n grad = gradient(x0)\n x = x0 - learning_rate*grad\n step_size = np.linalg.norm(x-x0)\n i += 1\n\n if step_size <= min_step:\n stop = True\n else:\n stop = False\n \n specs = {\n 'iterations' : i,\n 'final_step' : step_size,\n 'final_gradient' : np.linalg.norm(grad),\n 'stop' : stop\n }\n return x, specs","def optimize(opt, target, n_agents, n_variables, n_iterations, lb, ub, hyperparams):\n\n # Creating the SearchSpace\n space = SearchSpace(n_agents=n_agents, n_variables=n_variables,\n n_iterations=n_iterations, lower_bound=lb, upper_bound=ub)\n\n # Creating the Function\n function = Function(pointer=target)\n\n # Creating Optimizer\n if opt.__name__ is not 'BH':\n optimizer = opt(hyperparams=hyperparams)\n else:\n optimizer = opt()\n\n # Creating the optimization task\n task = Opytimizer(space=space, optimizer=optimizer, function=function)\n\n return task.start(store_best_only=True)","def solver_mtw(Xf, mXf, Ls, y, M, alpha, beta1, beta2, epsilon, gamma, coef1,\n coef2, R, b1, b2, sigmas, concomitant=False,\n stable=False, tol=1e-4, max_iter=1000, tol_ot=1e-5,\n max_iter_ot=20, max_iter_cd=2000,\n positive=False, n_jobs=1, tol_cd=1e-5, gpu=False,\n ot_threshold=0):\n log = {'loss': [], 'dloss': [], 'log_sinkhorn1': [], 'log_sinkhorn2': [],\n 'stable': stable, \"objcd\": [], \"fot1\": [0.], \"fot2\": [0.],\n 'reweighting_loss': [], \"n_coords\": [], \"obj\": 0.}\n n_samples, n_features = Xf[0].shape\n n_tasks = len(Xf)\n if n_jobs == -1:\n n_jobs = n_tasks\n marginals1, marginals2 = np.ones((2, n_tasks, n_features)) / n_features\n\n theta1 = coef1.copy()\n theta2 = coef2.copy()\n theta = theta1 - theta2\n\n thetaold = theta.copy()\n\n ot_img = True\n if len(M) == n_features:\n ot_img = False\n\n update_ot_1 = set_ot_func(stable, ot_img)\n update_ot_2 = set_ot_func(stable, ot_img)\n\n xp = utils.set_module(gpu)\n M = xp.asarray(- M / epsilon)\n if b1 is not None:\n b1 = xp.asarray(b1)\n if b2 is not None:\n b2 = xp.asarray(b2)\n\n thetabar1 = np.ones_like(coef1).mean(axis=-1)\n thetabar2 = np.ones_like(coef2).mean(axis=-1)\n\n if positive:\n theta2 *= 0.\n thetabar2 *= 0.\n theta = theta1\n a = n_samples * alpha * gamma\n beta1 = n_samples * beta1\n beta2 = n_samples * beta2\n\n if concomitant:\n sigma0 = 0.01 * np.linalg.norm(y, axis=1).min() / (n_samples ** 0.5)\n else:\n sigma0 = 0.\n with Parallel(n_jobs=n_jobs, backend=\"threading\") as pll:\n if alpha == 0.:\n theta, R, sigmas, mx = update_coefs(pll, Xf, y, theta, R,\n Ls, marginals1,\n sigmas, a, beta1,\n sigma0,\n tol=tol_cd,\n max_iter=max_iter_cd,\n positive=positive)\n obj = 0.5 * (R ** 2).sum(axis=1).dot(1 / sigmas) / n_samples\n obj += beta1 * abs(theta).sum() + 0.5 * sigmas.sum()\n theta1, theta2 = utils.get_unsigned(theta)\n log['loss'].append(obj)\n else:\n for i in range(max_iter):\n obj = 0.\n if not positive:\n Y1 = utils.residual(Xf, - theta2, y)\n else:\n Y1 = y\n theta1, R, sigmas, mxp = update_coefs(pll, Xf, Y1, theta1, R,\n Ls,\n marginals1,\n sigmas,\n a, beta1,\n sigma0,\n tol=tol_cd,\n max_iter=max_iter_cd)\n if not positive:\n Y2 = utils.residual(Xf, theta1, y)\n theta2, R, sigmas, mx = update_coefs(pll, mXf, Y2, theta2,\n R,\n Ls,\n marginals2,\n sigmas,\n a, beta2,\n sigma0,\n tol=tol_cd,\n max_iter=max_iter_cd)\n theta = theta1 - theta2\n else:\n theta = theta1\n\n dx = abs(theta - thetaold) / max(1, thetaold.max(),\n theta.max())\n dx = dx.max()\n thetaold = theta.copy()\n if alpha:\n if (theta1 > ot_threshold).any(0).all():\n fot1, log_ot1, marginals1, b1, q1 = \\\n update_ot_1(theta1, M, epsilon, gamma,\n b=b1, tol=tol_ot,\n max_iter=max_iter_ot,\n threshold=ot_threshold)\n if fot1 is None or not theta1.max(0).all():\n warnings.warn(\"Numerical errors. Moving in \"\n \"log-domain.\")\n b1 = xp.log(b1 + 1e-100, out=b1)\n stable = True\n update_ot_1 = set_ot_func(True, ot_img)\n fot1, log_ot1, marginals1, b1, q1 = \\\n update_ot_1(theta1, M, epsilon, gamma, b=b1,\n tol=tol_ot, max_iter=max_iter_ot,\n threshold=ot_threshold)\n\n log[\"log_sinkhorn1\"].append(log_ot1)\n thetabar1 = q1\n log[\"fot1\"].append(fot1)\n obj += alpha * fot1\n if not positive and (theta2 > ot_threshold).any(0).all():\n fot2, log_ot2, marginals2, b2, q2 = \\\n update_ot_2(theta2, M, epsilon, gamma,\n b=b2, tol=tol_ot, max_iter=max_iter_ot)\n\n if fot2 is None or not theta2.max(0).all():\n warnings.warn(\"Numerical errors. Moving in \"\n \"log-domain.\")\n b2 = xp.log(b2 + 1e-100, out=b2)\n stable = True\n update_ot_2 = set_ot_func(True, ot_img)\n fot2, log_ot2, marginals2, b2, q2 = \\\n update_ot_2(theta2, M, epsilon, gamma,\n b=b2, tol=tol_ot,\n max_iter=max_iter_ot)\n\n log[\"log_sinkhorn2\"].append(log_ot2)\n thetabar2 = q2\n log[\"fot2\"].append(fot2)\n obj += alpha * fot2\n\n log['loss'].append(obj)\n log['dloss'].append(dx)\n\n if dx < tol:\n break\n if i == max_iter - 1:\n warnings.warn('Objective did not converge.' +\n ' You might want' +\n ' to increase the number of iterations.' +\n ' Fitting data with very small alpha and' +\n ' beta may cause precision problems.',\n ConvergenceWarning)\n log['stable'] = stable\n\n if positive:\n theta2 *= 0.\n thetabar2 = xp.zeros_like(thetabar1)\n try:\n thetabar2 = thetabar2.get()\n except AttributeError:\n pass\n return (theta1, theta2, thetabar1, thetabar2, log, sigmas, b1, b2, R)","def optimize(self, state, algorithm, distances):\n\n if self.__current_job is not None:\n raise ServiceError('Optimization in progress. Wait till the end, before submitting next state.', 3)\n\n assert isinstance(state, State)\n assert isinstance(algorithm, Algorithm)\n assert isinstance(distances, Distances)\n\n data = {\n 'state': json.dumps(state.to_dict()),\n 'key': self.key,\n 'distances': json.dumps(distances.to_dict()),\n 'algorithm': json.dumps(algorithm.to_dict()),\n 'previous_task': self.__previous_job\n }\n\n try:\n response = requests.post('{}/api/v1/solve'.format(self.URL), data=data, timeout=10)\n except (Timeout, ConnectionError):\n raise ServiceError('Service unavailable: timeout.', 4)\n\n result = self._validate(response)\n self.__current_job = result.get('jid')\n return self.__current_job","def _generic_minimize(method, loss, x0,\n verbose=False,\n num_iters=1000,\n tol=1e-4,\n state=None,\n full_output=False,\n suppress_warnings=False,\n **kwargs):\n # Flatten the loss\n _x0, unflatten = flatten(x0)\n _objective = lambda x_flat, itr: loss(unflatten(x_flat), itr)\n\n if verbose:\n print(\"Fitting with {}.\".format(method))\n\n # Specify callback for fitting\n itr = [0]\n def callback(x_flat):\n itr[0] += 1\n print(\"Iteration {} loss: {:.3f}\".format(itr[0], loss(unflatten(x_flat), -1)))\n\n # Wrap the gradient to avoid NaNs\n def safe_grad(x, itr):\n g = grad(_objective)(x, itr)\n g[~np.isfinite(g)] = 1e8\n return g\n\n # Call the optimizer. Pass in -1 as the iteration since it is unused.\n result = minimize(_objective, _x0, args=(-1,),\n jac=safe_grad,\n method=method,\n callback=callback if verbose else None,\n options=dict(maxiter=num_iters, disp=verbose),\n tol=tol,\n **kwargs)\n if verbose:\n print(\"{} completed with message: \\n{}\".format(method, result.message))\n\n if not suppress_warnings and not result.success:\n warn(\"{} failed with message:\\n{}\".format(method, result.message))\n\n if full_output:\n return unflatten(result.x), result\n else:\n return unflatten(result.x)","def run_method(trial, method,\n cl_ctx=None,\n queue=None,\n clear_memoized_objects=False,\n true_sol_name=\"True Solution\",\n comp_sol_name=\"Computed Solution\", **kwargs):\n if clear_memoized_objects:\n global memoized_objects\n memoized_objects = {}\n\n if cl_ctx is None:\n raise ValueError(\"Missing cl_ctx\")\n if queue is None:\n raise ValueError(\"Missing queue\")\n\n # Get boundary ids\n scatterer_bdy_id = kwargs['scatterer_bdy_id']\n outer_bdy_id = kwargs['outer_bdy_id']\n\n # Get degree and wave number\n degree = trial['degree']\n wave_number = trial['kappa']\n\n # Get options prefix and solver parameters, if any\n options_prefix = kwargs.get('options_prefix', None)\n solver_parameters = dict(kwargs.get('solver_parameters', None))\n\n # Get prepared trial args in kwargs\n prepared_trial = prepare_trial(trial, true_sol_name, cl_ctx, queue)\n mesh, fspace, vfspace, true_sol, true_sol_grad_expr = prepared_trial\n\n # Create a place to memoize any objects if necessary\n tuple_trial = trial_to_tuple(trial)\n memo_key = tuple_trial[:2]\n if memo_key not in memoized_objects:\n memoized_objects[memo_key] = {}\n\n comp_sol = None\n\n # Handle any special kwargs and get computed solution\n if method == 'pml':\n # Get required objects\n pml_max = kwargs['pml_max']\n pml_min = kwargs['pml_min']\n\n # Get optional argumetns\n pml_type = kwargs.get('pml_type', None)\n quad_const = kwargs.get('quad_const', None)\n speed = kwargs.get('speed', None)\n\n # Make tensor function space\n if 'tfspace' not in memoized_objects[memo_key]:\n memoized_objects[memo_key]['tfspace'] = \\\n TensorFunctionSpace(mesh, 'CG', degree)\n\n tfspace = memoized_objects[memo_key]['tfspace']\n\n snes, comp_sol = pml(mesh, scatterer_bdy_id, outer_bdy_id, wave_number,\n options_prefix=options_prefix,\n solver_parameters=solver_parameters,\n fspace=fspace, tfspace=tfspace,\n true_sol_grad_expr=true_sol_grad_expr,\n pml_type=pml_type, quad_const=quad_const,\n speed=speed,\n pml_min=pml_min,\n pml_max=pml_max,\n )\n snes_or_ksp = snes\n\n elif method == 'nonlocal':\n # Build DG spaces if not already built\n if 'dgfspace' not in memoized_objects[memo_key]:\n memoized_objects[memo_key]['dgfspace'] = \\\n FunctionSpace(mesh, 'DG', degree)\n if 'dgvfspace' not in memoized_objects[memo_key]:\n memoized_objects[memo_key]['dgvfspace'] = \\\n VectorFunctionSpace(mesh, 'DG', degree)\n\n dgfspace = memoized_objects[memo_key]['dgfspace']\n dgvfspace = memoized_objects[memo_key]['dgvfspace']\n\n # Get opencl array context\n from meshmode.array_context import PyOpenCLArrayContext\n actx = PyOpenCLArrayContext(queue)\n\n # Build connection fd -> meshmode if not already built\n if 'meshmode_src_connection' not in memoized_objects[memo_key]:\n from meshmode.interop.firedrake import build_connection_from_firedrake\n memoized_objects[memo_key]['meshmode_src_connection'] = \\\n build_connection_from_firedrake(\n actx,\n dgfspace,\n grp_factory=None,\n restrict_to_boundary=scatterer_bdy_id)\n\n meshmode_src_connection = memoized_objects[memo_key]['meshmode_src_connection']\n\n # Set defaults for qbx kwargs\n qbx_order = kwargs.get('qbx_order', degree+2)\n fine_order = kwargs.get('fine_order', 4 * degree)\n fmm_order = kwargs.get('FMM Order', None)\n fmm_tol = kwargs.get('FMM Tol', None)\n # make sure got either fmm_order xor fmm_tol\n if fmm_order is None and fmm_tol is None:\n raise ValueError(\"At least one of 'fmm_order', 'fmm_tol' must not \"\n \"be *None*\")\n if fmm_order is not None and fmm_tol is not None:\n raise ValueError(\"At most one of 'fmm_order', 'fmm_tol' must not \"\n \"be *None*\")\n # if got fmm_tol, make a level-to-order\n fmm_level_to_order = None\n if fmm_tol is not None:\n if not isinstance(fmm_tol, float):\n raise TypeError(\"fmm_tol of type '%s' is not of type float\" % type(fmm_tol))\n if fmm_tol <= 0.0:\n raise ValueError(\"fmm_tol of '%s' is less than or equal to 0.0\" % fmm_tol)\n from sumpy.expansion.level_to_order import SimpleExpansionOrderFinder \n fmm_level_to_order = SimpleExpansionOrderFinder(fmm_tol)\n # Otherwise, make sure we got a valid fmm_order\n else:\n if not isinstance(fmm_order, int):\n if fmm_order != False:\n raise TypeError(\"fmm_order of type '%s' is not of type int\" % type(fmm_order))\n if fmm_order != False and fmm_order < 1:\n raise ValueError(\"fmm_order of '%s' is less than 1\" % fmm_order)\n\n qbx_kwargs = {'qbx_order': qbx_order,\n 'fine_order': fine_order,\n 'fmm_order': fmm_order,\n 'fmm_level_to_order': fmm_level_to_order,\n 'fmm_backend': 'fmmlib',\n }\n # }}}\n\n ksp, comp_sol = nonlocal_integral_eq(\n mesh, scatterer_bdy_id, outer_bdy_id,\n wave_number,\n options_prefix=options_prefix,\n solver_parameters=solver_parameters,\n fspace=fspace, vfspace=vfspace,\n true_sol_grad_expr=true_sol_grad_expr,\n actx=actx,\n dgfspace=dgfspace,\n dgvfspace=dgvfspace,\n meshmode_src_connection=meshmode_src_connection,\n qbx_kwargs=qbx_kwargs,\n )\n\n snes_or_ksp = ksp\n\n elif method == 'transmission':\n\n snes, comp_sol = transmission(mesh, scatterer_bdy_id, outer_bdy_id,\n wave_number,\n options_prefix=options_prefix,\n solver_parameters=solver_parameters,\n fspace=fspace,\n true_sol_grad_expr=true_sol_grad_expr,\n )\n snes_or_ksp = snes\n else:\n raise ValueError(\"Invalid method\")\n\n comp_sol.rename(name=comp_sol_name)\n return true_sol, comp_sol, snes_or_ksp","def fit_to_target_func(self, func_target, list_x, algo = 'DE', copy = False, **args_optim):\n func_to_fit = self.clone() if copy else self \n return_fit = args_optim.pop('return_fit', False) # return the fit val\n bounds = func_to_fit.theta_bounds\n if not(_is_fully_bounded(bounds)):\n SystemError(\"Can't fit with unknown bounds\")\n \n def SquareErrors(params):\n func_to_fit.theta = params\n res = pFunc_base.square_dist(func_to_fit, func_target, list_x)\n return res\n \n if(algo == 'DE'):\n import scipy.optimize\n resDE = scipy.optimize.differential_evolution(SquareErrors, bounds, **args_optim)\n else:\n raise NotImplementedError('Only DE has been implemented so far')\n \n fit = SquareErrors(resDE['x'])\n logger.info(fit)\n if(return_fit):\n return func_to_fit, fit\n else:\n return func_to_fit","def back_prop(net, input_values, desired_output, r=1, minimum_accuracy=-0.001):\n raise NotImplementedError","def parallel_nelder_mead_worker(obj_func, simplex, f_vals, j, P, opt_params):\n # Unpack the input parameters\n alpha = opt_params[0] # reflection parameter\n beta = opt_params[1] # contraction parameter\n gamma = opt_params[2] # expansion parameter\n my_point = simplex[j, :] # vertex to update\n my_val = f_vals[j] # value at the vertex to update\n best_val = f_vals[0] # best value in the vertex\n next_val = f_vals[j - 1] # next best point in the simplex\n evals = 0\n\n # Calculate the centroid of the \"good\" simplex points\n N = simplex.shape[0] # number of points in simplex\n centroid = np.mean(simplex[0 : (N - P), :], axis=0)\n\n # Calculate the reflection point and its function value\n r_point = centroid + alpha * (centroid - my_point)\n r_val = obj_func(r_point)\n evals += 1\n\n # Case 1: the reflection point is better than best point\n if r_val < best_val:\n e_point = r_point + gamma * (r_point - centroid)\n e_val = obj_func(e_point) # Calculate expansion point\n evals += 1\n if e_val < r_val:\n new_point = e_point\n new_val = e_val\n else:\n new_point = r_point\n new_val = r_val\n # Case 2: the reflection point is better than the next best point\n elif r_val < next_val:\n new_point = r_point # Report reflection point\n new_val = r_val\n # Case 3: the reflection point is worse than the next best point\n else:\n if r_val < my_val:\n temp_point = r_point # Check whether reflection or original point\n temp_val = r_val # is better and use it temporarily\n else:\n temp_point = my_point\n temp_val = my_val\n c_point = temp_point + beta * (centroid - temp_point)\n c_val = obj_func(c_point) # Calculate contraction point\n evals += 1\n if c_val < temp_val:\n new_point = c_point\n new_val = c_val # Check whether the contraction point is better\n else:\n new_point = temp_point\n new_val = temp_val\n\n # Return the outputs\n return new_point, new_val, evals","def example():\n Optimizer = BFGS(f, g)\n startPoint = 100 * numpy.ones(2);\n res = Optimizer.optimize(startPoint,\n epsilon=1e-5,\n maxIterations=10)\n print res\n pass","def solve(self, example_name, max_iter = 100, is_check_stop = True, maximum_line_search = 10):\n logger.debug(\"[+ +] Initial Obj.Val.: %.5e\"%(self.get_obj_fun_value()))\n start_time = tm.time()\n for i in range(max_iter):\n if i == 1: # skip the compiling time \n start_time = tm.time()\n iter_start_time = tm.time()\n self.backward_pass()\n backward_time = tm.time()\n obj, isStop = self.forward_pass(max_line_search=maximum_line_search)\n forward_time = tm.time()\n logger.debug(\"[+ +] Iter.No.%3d BWTime:%.3e FWTime:%.3e Obj.Val.:%.5e\"%(\n i, backward_time-iter_start_time,forward_time-backward_time,obj))\n result_path = os.path.join(\"logs\", example_name, str(i) +\".mat\")\n io.savemat(result_path,{\"trajectory\": self.get_traj()})\n if isStop and is_check_stop:\n break\n end_time = tm.time()\n logger.debug(\"[+ +] Completed! All Time:%.5e\"%(end_time-start_time))","def logexp_optimise(fn, x, **kwargs):\n def transform(x):\n theta = logexp_to_natural(x)\n y,grad = fn(theta)\n # get gradients back to our space\n grad *= logexp_gradientfactor(theta)\n return (y,grad)\n res = spo.minimize(transform, natural_to_logexp(x), jac=True,\n **kwargs)\n res.x = logexp_to_natural(res.x)\n return res","def gradient_descent(features, values, theta, alpha, num_iterations):\r\n\r\n m = len(values)\r\n cost_history = []\r\n\r\n for i in range (num_iterations):\r\n \r\n h = numpy.dot(features, theta)\r\n \r\n theta = theta - alpha / m * numpy.dot((h-values),features)\r\n \r\n cost = compute_cost(features, values, theta)\r\n \r\n cost_history.append(cost)\r\n\r\n return theta, pandas.Series(cost_history) # leave this line for the grader\r","def _newtons_method_gmres_action(f, initial_guess, max_iter=50, tol=1e-12):\n\n output_dim = len(f(initial_guess))\n \n @np.vectorize\n def sum_values(dictionary):\n return sum(dictionary.values())\n \n def create_action(x0):\n \n def L_fun(x):\n \"\"\"\n Action\n Returns J_f(x0)*x by setting the values of 'x' as the initial derivatives for the variables in x0.\n \"\"\"\n \n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\n action = sum_values(ad.get_deriv(f_x0))\n return action\n \n L = LinearOperator(shape=(output_dim, len(x0)), matvec=L_fun)\n \n return L\n \n x0 = initial_guess\n for iter_num in range(max_iter):\n L = create_action(x0)\n b = -1 * np.array(f(x0))\n if len(x0) == 1:\n b = np.array([b])\n step, _ = gmres(L, b, tol = tol, atol = 'legacy')\n xnext = x0 + step \n if np.all(np.abs(xnext - x0) < tol):\n return (xnext, iter_num + 1);\n x0 = xnext\n \n raise RuntimeError(\"Failed to converge after {0} iterations, value is {1}\".format(max_iter, x0) );","def optimize(self, num_restarts=1, max_iters=100, max_f_eval=300.0, method='Anneal'):\n dic = DictVectorizer()\n # flatten the parameters\n init_params,bounds=dic.fit_transform(self.params)\n #we minimise minus the marginal likelihood\n def objective(params_flatten):\n self.params=dic.inverse_transform(params_flatten,bounds)\n val = -self.log_marginal_likelihood()\n return val# we want to maximize it\n \n \n #run ptimisation with multiple restarts\n optml=np.inf\n for i in range(num_restarts):\n #minimise function\n if method=='Anneal':\n res=dual_annealing(objective,bounds, maxiter=max_iters, maxfun=max_f_eval, x0=init_params)\n else:\n \n res = minimize(objective, init_params, \n bounds=bounds, method=method,options={'maxiter': max_iters, 'disp': False})\n #print(\"Iteration \"+str(i)+\" \",-res.fun)\n if res.fun<optml:\n params_best=res.x #init_params \n optml=res.fun\n init_params=bounds[:,0]+(bounds[:,1]-bounds[:,0])*np.random.rand(len(bounds[:,0]))\n print(\"Iteration \"+str(i)+\" \",-res.fun)\n #params_best=res.x\n #optml=res.fun\n self.params=dic.inverse_transform(params_best,bounds)\n return -optml","def __max_step(self, batch):\n\n # short hand and optimizer\n policy = self.mc.get('policy', target=False)\n policy_parameters = list(policy.parameters())\n opt_outer = optim.Adam(policy_parameters, lr=self.outer_lr)\n\n # optimize\n opt_outer.zero_grad()\n obj = -self.obj(batch)\n obj.backward()\n opt_outer.step()","def solve(self, problem, x=None, reuselinesearch=False):\n man = problem.manifold\n verbosity = problem.verbosity\n objective = problem.cost\n gradient = problem.grad\n\n if not reuselinesearch or self.linesearch is None:\n self.linesearch = deepcopy(self._linesearch)\n linesearch = self.linesearch\n\n # If no starting point is specified, generate one at random.\n if x is None:\n x = man.rand()\n\n # Initialize iteration counter and timer\n iter = 0\n stepsize = np.nan\n time0 = time.time()\n\n if verbosity >= 1:\n print(\"Optimizing...\")\n if verbosity >= 2:\n print(\" iter\\t\\t cost val\\t grad. norm\")\n\n # Calculate initial cost-related quantities\n cost = objective(x)\n grad = gradient(x)\n gradnorm = man.norm(x, grad)\n def _Pgrad(_x):\n return problem.precon(_x, gradient(_x))\n Pgrad = problem.precon(x, grad)\n gradPgrad = man.inner(x, grad, Pgrad)\n\n # Initial descent direction is the negative gradient\n desc_dir = -Pgrad\n\n self._start_optlog(extraiterfields=['gradnorm'],\n solverparams={'beta_type': self._beta_type,\n 'orth_value': self._orth_value,\n 'linesearcher': linesearch})\n\n while True:\n if verbosity >= 2:\n print(\"%5d\\t%+.16e\\t%.8e\" % (iter, cost, gradnorm))\n\n if self._logverbosity >= 2:\n self._append_optlog(iter, x, cost, gradnorm=gradnorm)\n\n stop_reason = self._check_stopping_criterion(time0, gradnorm=gradnorm, iter=iter + 1, stepsize=stepsize)\n\n if stop_reason:\n if verbosity >= 1:\n print(stop_reason)\n print('')\n break\n\n # The line search algorithms require the directional derivative of\n # the cost at the current point x along the search direction.\n df0 = man.inner(x, grad, desc_dir)\n\n # If we didn't get a descent direction: restart, i.e., switch to\n # the negative gradient. Equivalent to resetting the CG direction\n # to a steepest descent step, which discards the past information.\n if df0 >= 0:\n # Or we switch to the negative gradient direction.\n if verbosity >= 3:\n print(\"Conjugate gradient info: got an ascent direction \"\n \"(df0 = %.2f), reset to the (preconditioned) \"\n \"steepest descent direction.\" % df0)\n # Reset to negative gradient: this discards the CG memory.\n desc_dir = -Pgrad\n df0 = -gradPgrad\n\n # Execute line search\n stepsize, newx = linesearch.search(objective, man, x, desc_dir, cost, df0, _Pgrad)\n\n # Compute the new cost-related quantities for newx\n newcost = objective(newx)\n newgrad = gradient(newx)\n newgradnorm = man.norm(newx, newgrad)\n Pnewgrad = problem.precon(newx, newgrad)\n newgradPnewgrad = man.inner(newx, newgrad, Pnewgrad)\n\n # Apply the CG scheme to compute the next search direction\n oldgrad = man.transp(x, newx, grad)\n orth_grads = man.inner(newx, oldgrad, Pnewgrad) / newgradPnewgrad\n\n # Powell's restart strategy (see page 12 of Hager and Zhang's\n # survey on conjugate gradient methods, for example)\n if abs(orth_grads) >= self._orth_value:\n beta = 0\n desc_dir = -Pnewgrad\n else:\n desc_dir = man.transp(x, newx, desc_dir)\n if self._beta_type == BetaTypes.DaiYuan:\n diff = newgrad - oldgrad\n beta = newgradPnewgrad / man.inner(newx, diff, desc_dir)\n elif self._beta_type == BetaTypes.PolakRibiere:\n diff = newgrad - oldgrad\n ip_diff = man.inner(newx, Pnewgrad, diff)\n beta = ip_diff / gradPgrad\n elif self._beta_type == BetaTypes.Hybrid1:\n diff = newgrad - oldgrad\n beta_DY = newgradPnewgrad / man.inner(newx, diff, desc_dir)\n ip_diff = man.inner(newx, Pnewgrad, diff)\n try:\n beta_HS = ip_diff / man.inner(newx, diff, desc_dir)\n except ZeroDivisionError:\n beta_HS = 1\n beta = max(0, min(beta_DY, beta_HS))\n elif self._beta_type == BetaTypes.Hybrid2:\n diff = newgrad - oldgrad\n beta_DY = newgradPnewgrad / man.inner(newx, diff, desc_dir)\n ip_diff = man.inner(newx, Pnewgrad, diff)\n try:\n beta_HS = ip_diff / man.inner(newx, diff, desc_dir)\n except ZeroDivisionError:\n beta_HS = 1\n c2 = linesearch.c2\n beta = max(-(1 - c2) / (1 + c2) * beta_DY, min(beta_DY, beta_HS))\n else:\n types = \", \".join([\"BetaTypes.%s\" % t for t in BetaTypes._fields])\n raise ValueError(\"Unknown beta_type %s. Should be one of %s.\" % (self._beta_type, types))\n\n desc_dir = -Pnewgrad + beta * desc_dir\n\n # Update the necessary variables for the next iteration.\n x = newx\n cost = newcost\n grad = newgrad\n Pgrad = Pnewgrad\n gradnorm = newgradnorm\n gradPgrad = newgradPnewgrad\n\n iter += 1\n \n return x, iter + 1, time.time() - time0","def optimize(self, args):\n\n ############################\n # Get the data\n ############################\n\n # Read the CSV file ignoring the header and the first column (which\n # contains the file name of the image used for extracting the data in\n # a row)\n try:\n data = np.genfromtxt(args.featuresFile, delimiter=',',\n skip_header=1)\n data = data[:, 1:]\n except:\n print('Could not read CSV file: {}'.format(args.featuresFile))\n return -1\n\n x = data[:, :-1]\n y = np.squeeze(data[:, -1:])\n\n ############################\n # Execute the optimization\n ############################\n\n tunningParams = [\n {\n 'kernel': ['linear'],\n 'C': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3]\n },\n {\n 'kernel': ['rbf'],\n 'gamma': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3],\n 'C': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3]\n },\n ]\n\n scores = ['precision', 'recall']\n\n for score in scores:\n print('# Tuning hyper-parameters for {}\\n'.format(score))\n\n clf = GridSearchCV(svm.SVC(C=1), tunningParams, cv=5,\n scoring=format('{}_macro'.format(score)))\n clf.fit(x, y)\n\n print('Best parameters set found on development set:\\n')\n print(clf.best_params_)\n\n print('\\nGrid scores on development set:\\n')\n means = clf.cv_results_['mean_test_score']\n stds = clf.cv_results_['std_test_score']\n for mean, std, params in zip(means, stds, clf.cv_results_['params']):\n print('{:.3f} (+/-{:.3f}) for {}'.format(mean, std * 2, params))\n\n #print('\\nDetailed classification report:\\n')\n #print('The model is trained on the full development set.')\n #print('The scores are computed on the full evaluation set.\\n')\n #y_true, y_pred = y_test, clf.predict(X_test)\n #print(classification_report(y_true, y_pred))\n #print()\n\n return 0","def __init__(self, optimizer='BFGS', optimizer_kwargs=None,\n lossprime=True, max_iterations = 1000000):\n\n user_kwargs = optimizer_kwargs\n optimizer_kwargs = {}\n print(f\"in {optimizer}: max_iterations = {max_iterations}\")\n if optimizer == 'BFGS':\n from scipy.optimize import minimize as optimizer\n optimizer_kwargs = {\n 'method' : 'BFGS',\n 'options': {'gtol': 1e-15,\n 'maxiter': max_iterations}\n }\n #optimizer_kwargs = {'method':'BFGS', 'gtol': 1e-15, }\n elif optimizer == 'L-BFGS-B':\n from scipy.optimize import minimize as optimizer\n optimizer_kwargs = {\n 'method': 'L-BFGS-B',\n 'options': {'ftol': 1e-05,\n 'gtol': 1e-08,\n 'maxfun': max_iterations,\n 'maxiter': max_iterations}\n }\n import scipy\n from distutils.version import StrictVersion\n if StrictVersion(scipy.__version__) >= StrictVersion('0.17.0'):\n optimizer_kwargs['options']['maxls'] = 2000\n elif optimizer == 'TNC':\n from scipy.optimize import minimize as optimizer\n optimizer_kwargs = {\n 'method': 'TNC',\n 'options': {'ftol': 0.,\n 'xtol': 0.,\n 'gtol': 1e-08,\n 'maxiter': max_iterations, }\n }\n elif optimizer == 'Newton-CG':\n from scipy.optimize import minimize as optimizer\n optimizer_kwargs = {\n 'method': 'Newton-CG',\n 'options': {'xtol': 1e-15,\n 'maxiter': max_iterations,}\n }\n\n elif optimizer == 'Nelder-Mead':\n from scipy.optimize import minimize as optimizer\n optimizer_kwargs = {\n 'method': 'Nelder-Mead',\n 'options': {'maxfun': max_iterations,\n 'maxiter': max_iterations, }\n }\n lossprime = False\n\n if user_kwargs:\n optimizer_kwargs.update(user_kwargs)\n self.optimizer = optimizer\n self.optimizer_kwargs = optimizer_kwargs\n self.lossprime = lossprime","def RunParallelSteps(steps, max_parallel=None, halt_on_error=False,\n return_values=False):\n def ReturnWrapper(queue, fn):\n \"\"\"Put the return value of |fn| into |queue|.\"\"\"\n queue.put(fn())\n\n full_steps = []\n queues = []\n with cros_build_lib.ContextManagerStack() as stack:\n if return_values:\n # We use a managed queue here, because the child process will wait for the\n # queue(pipe) to be flushed (i.e., when items are read from the queue)\n # before exiting, and with a regular queue this may result in hangs for\n # large return values. But with a managed queue, the manager process will\n # read the items and hold on to them until the managed queue goes out of\n # scope and is cleaned up.\n manager = stack.Add(Manager)\n for step in steps:\n queue = manager.Queue()\n queues.append(queue)\n full_steps.append(functools.partial(ReturnWrapper, queue, step))\n else:\n full_steps = steps\n\n with _BackgroundTask.ParallelTasks(full_steps, max_parallel=max_parallel,\n halt_on_error=halt_on_error):\n pass\n\n if return_values:\n return [queue.get_nowait() for queue in queues]","def evaluate(Agent, rules, wrappers, params_path=None, steps=1024):\n\n score = 0.0\n\n agent = Agent()\n\n if params_path is not None:\n agent.load_state_dict(params_path)\n\n env = CARLE()\n\n\n for wrapper in wrappers:\n env = wrapper[0](env)\n env.reward_scale = wrapper[1]\n\n env.batch_size = steps*len(rules)\n\n if wrapper[2] is not None:\n env.load_state_dict(torch.load(wrapper[2]))\n\n env.eval()\n\n #env.set_no_grad()\n\n total_steps = 0\n score_trace = []\n for ruleset in rules:\n\n env.inner_env.birth = ruleset[0]\n env.inner_env.survive = ruleset[0]\n\n obs = env.reset()\n\n for step in range(steps):\n\n action = agent(obs)\n\n obs, reward, done, info = env.step(action)\n\n score += reward.detach().sum().cpu().numpy()\n score_trace.append(reward.detach().sum().cpu().numpy())\n\n total_steps += 1\n\n print(\"cumulative score = {:.3e} at total steps = {}, rulset = {}\".format(\\\n score, total_steps, ruleset))\n\n score /= total_steps\n \n return score, score_trace","def clgrad(obj, exe, arg, delta=DELTA):\n f, x = get_method_and_copy_of_attribute(obj, exe, arg)\n def grad_f(*args, **kwargs):\n grad_val = numpy.zeros(x.shape)\n it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])\n for xi in it:\n i = it.multi_index\n xi += delta/2\n fp = f(*args, **kwargs)\n xi -= delta\n fm = f(*args, **kwargs)\n xi += delta/2\n grad_val[i] = (fp - fm)/delta\n return grad_val\n return grad_f","def optimize_svr(data, targets):\r\n def svc_crossval(C,epsilon,loss_n):\r\n\r\n return svc_cv(C=C, epsilon=epsilon,loss_n=loss_n, data=data, targets=targets)\r\n\r\n optimizer = BayesianOptimization(\r\n f=svc_crossval,\r\n pbounds={\"C\": (0.0001, 1000), \"epsilon\": (0, 0.2),'loss_n':(0,1)},\r\n random_state=1234,\r\n verbose=2\r\n )\r\n logger=JSONLogger(path=\"./linsvrlogs.json\")\r\n optimizer.subscribe(Events.OPTMIZATION_STEP,logger)\r\n optimizer.maximize(init_points=50,n_iter=300)\r\n with open('./linsvrlogs.json','a',encoding='utf-8')as f:\r\n f.write(str(optimizer.max))","def minimize_neldermead(func, x0, args=(), callback=None,\n maxiter=None, maxfev=None, disp=False,\n return_all=False, initial_simplex=None,\n xatol=1e-4, fatol=1e-4, **unknown_options):\n maxfun = maxfev\n retall = return_all\n\n rho = 1\n chi = 2\n psi = 0.5\n sigma = 0.5\n nonzdelt = 0.05\n zdelt = 0.00025\n\n if initial_simplex is None:\n N = len(x0)\n\n sim = numpy.zeros((N + 1, N), dtype=x0.dtype)\n sim[0] = x0\n for k in range(N):\n y = numpy.array(x0, copy=True)\n if y[k] != 0:\n y[k] = (1 + nonzdelt) * y[k]\n else:\n y[k] = zdelt\n sim[k + 1] = y\n\n maxiter = 10\n maxfun = 10\n\n one2np1 = list(range(1, N + 1))\n fsim = numpy.zeros((N + 1,), float)\n\n for k in range(N + 1):\n fsim[k] = func(sim[k])\n\n ind = numpy.argsort(fsim)\n fsim = numpy.take(fsim, ind, 0)\n # sort so sim[0,:] has the lowest function value\n sim = numpy.take(sim, ind, 0)\n raise Exception()\n print('aaaaffaaaaaa')\n\n iterations = 1\n\n while iterations < maxiter:\n if (numpy.max(numpy.ravel(numpy.abs(sim[1:] - sim[0]))) <= xatol and\n numpy.max(numpy.abs(fsim[0] - fsim[1:])) <= fatol):\n break\n logger.debug('itr: %s' % iterations)\n print('aaaaaaaaaa')\n xbar = numpy.add.reduce(sim[:-1], 0) / N\n xr = (1 + rho) * xbar - rho * sim[-1]\n fxr = func(xr)\n doshrink = 0\n\n if fxr < fsim[0]:\n xe = (1 + rho * chi) * xbar - rho * chi * sim[-1]\n fxe = func(xe)\n\n if fxe < fxr:\n sim[-1] = xe\n fsim[-1] = fxe\n else:\n sim[-1] = xr\n fsim[-1] = fxr\n else: # fsim[0] <= fxr\n if fxr < fsim[-2]:\n sim[-1] = xr\n fsim[-1] = fxr\n else: # fxr >= fsim[-2]\n # Perform contraction\n if fxr < fsim[-1]:\n xc = (1 + psi * rho) * xbar - psi * rho * sim[-1]\n fxc = func(xc)\n\n if fxc <= fxr:\n sim[-1] = xc\n fsim[-1] = fxc\n else:\n doshrink = 1\n else:\n # Perform an inside contraction\n xcc = (1 - psi) * xbar + psi * sim[-1]\n fxcc = func(xcc)\n\n if fxcc < fsim[-1]:\n sim[-1] = xcc\n fsim[-1] = fxcc\n else:\n doshrink = 1\n\n if doshrink:\n for j in one2np1:\n sim[j] = sim[0] + sigma * (sim[j] - sim[0])\n fsim[j] = func(sim[j])\n\n ind = numpy.argsort(fsim)\n sim = numpy.take(sim, ind, 0)\n fsim = numpy.take(fsim, ind, 0)\n if callback is not None:\n callback(sim[0])\n iterations += 1\n\n x = sim[0]\n fval = numpy.min(fsim)\n warnflag = 0\n\n result = OptimizeResult(fun=fval, nit=iterations, nfev=0,\n status=warnflag, success=(warnflag == 0),\n message=None, x=x, final_simplex=(sim, fsim))\n return result","def optimize_mlp(data, targets):\r\n def mlp_crossval(h1,h2,h3,ac,so):\r\n\r\n return mlp(\r\n h1=int(h1),\r\n h2=int(h2),\r\n h3=int(h3),\r\n ac=ac,\r\n so=so,\r\n data=data,\r\n targets=targets,\r\n )\r\n\r\n optimizer = BayesianOptimization(\r\n f=mlp_crossval,\r\n pbounds={\r\n \"h1\": (1, 300),\r\n \"h2\": (1, 300),\r\n \"h3\": (1, 300),\r\n \"ac\":(0,3),\r\n 'so': (0,3)\r\n },\r\n random_state=1234,\r\n verbose=2\r\n )\r\n logger=JSONLogger(path=\"./MLPreglogs.json\")\r\n optimizer.subscribe(Events.OPTMIZATION_STEP,logger)\r\n optimizer.maximize(init_points=50,n_iter=300)\r\n with open('./MLPreglogs.json','a',encoding='utf-8')as f:\r\n f.write(str(optimizer.max))","def projected_gradient_descent(self, x, y):\n x_adv = x.clone().detach().requires_grad_(True).to(x.device)\n targeted = self.y_target is not None\n num_channels = x.shape[1]\n\n if self.random:\n x_adv = random_perturbation(x_adv, self.norm, self.eps)\n\n for i in range(self.num_steps):\n _x_adv = x_adv.clone().detach().requires_grad_(True)\n\n prediction = self.model(_x_adv)\n loss = self.loss_fn(prediction, self.y_target if targeted else y)\n loss.backward()\n\n with torch.no_grad():\n # Force the gradient step to be a fixed size in a certain norm\n if self.norm == 'inf':\n gradients = _x_adv.grad.sign() * self.step_size\n else:\n # Note .view() assumes batched image data as 4D tensor\n gradients = _x_adv.grad * self.step_size / _x_adv.grad.view(\n _x_adv.shape[0], -1) \\\n .norm(self.norm, dim=-1) \\\n .view(-1, num_channels, 1, 1)\n\n if targeted:\n # Targeted: Gradient descent with on the loss of the (incorrect) target label\n # w.r.t. the image data\n x_adv -= gradients\n else:\n # Untargeted: Gradient ascent on the loss of the correct label w.r.t.\n # the model parameters\n x_adv += gradients\n\n # Project back into l_norm ball and correct range\n if self.norm == 'inf':\n # Workaround as PyTorch doesn't have elementwise clip\n x_adv = torch.max(torch.min(x_adv, x + self.eps), x - self.eps)\n else:\n delta = x_adv - x\n\n # Assume x and x_adv are batched tensors where the first dimension is\n # a batch dimension\n mask = delta.view(delta.shape[0], -1).norm(self.norm,\n dim=1) <= self.eps\n\n scaling_factor = delta.view(delta.shape[0], -1).norm(self.norm,\n dim=1)\n scaling_factor[mask] = self.eps\n\n # .view() assumes batched images as a 4D Tensor\n delta *= self.eps / scaling_factor.view(-1, 1, 1, 1)\n\n x_adv = x + delta\n\n x_adv = x_adv.clamp(*self.clamp)\n\n return x_adv.detach()","def downhill(F, xStart, args=None, side=0.1, ftol=1.0e-6, xtol=1.0e-6, maxiter=1000, maxfunc=1000, maxiternochange=10):\n # TODO: check the types of the input ???\n\n # print \"Entering downhill\"\n n = len(xStart)\n x = np.zeros((n+1, n), dtype=float) #point null matrix, n+1 rows, n columns\n f = np.zeros(n+1, dtype=float) # null vector, n+1 columns\n p_count = 0 # counter for detecting a plateau\n f_count = 0 # counter for the number of function call\n f_best_count = 0 # counter for the number of iterations in which the best solution does not change\n f_best_prev = 0.0 # holds the best value from the previous iteration\n epsilon = 0.001 # tolerance for considering two values as equal\n # max_iter_no_change = 10 # maximum number of accepted iterations with no change in the optimal solution\n precision = 2\n round_map = partial(round, ndigits=precision) # partial function for rounding purposes\n\n # initial simplex\n x[0] = xStart\n for i in xrange(1, n+1):\n x[i] = xStart\n x[i,i-1] = xStart[i-1] + side\n\n # print \"Evaluate the starting points\"\n # compute the value of F at the vertices of the simplex\n for i in xrange(n+1):\n f[i] = F(x[i], args)\n # p_count += 1\n\n # main loop\n # print \"Start iterating\"\n for k in xrange(maxiter):\n\n # check the number of function calls\n if f_count > maxfunc:\n print \"Stopping criteria: maximum number of function calls\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXFUNCALL'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXFUNCALL'}\n\n # find the best and worst vertex (consider a minimization problem)\n iLo = np.argmin(f) # best vertex\n iHi = np.argmax(f) # worst vertex\n\n # print k,\" \", f[iLo]\n #\n # if f[iLo] < -0.310000:\n # print f[iLo]\n # print x[iLo]\n # print x\n # sys.exit(1)\n # print \"k: \", k, \" f_best_prev: \", f_best_prev, \" f[iLo]: \", f[iLo], \" f_best_count: \", f_best_count\n # print \"Beginning of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\n # print \"x: \", x, \" f: \", f\n # print \"=========================================================================================\"\n # check if the solution has changed from the previous iterations\n if f[iLo] < f_best_prev:\n f_best_prev = f[iLo]\n f_best_count = 0\n else:\n f_best_count += 1\n\n if f_best_count > maxiternochange:\n print \"Stopping criteria: maximum number of iterations with no improvement in the best solution\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'NOIMPROVEMENT'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'NOIMPROVEMENT'}\n\n if abs(f[iLo] - f[iHi]) < ftol: # If difference between highest and lowest is smaller than ftol, return\n print \"Stopping criteria: difference between highest and lowest points is smaller than tolerance\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXTOLERANCE'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXTOLERANCE'}\n # compute the move vector d\n d = (-(n+1) * x[iHi] + np.sum(x, axis=0)) / n\n # print \"d: \", d\n\n # check for convergence\n if sqrt(np.dot(d, d)/n) < xtol: # length of the vector d\n print \"Stopping criteria: length of step d smaller than tolerance\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'SMALLSTEP'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'SMALLSTEP'}\n # try reflection\n xNew = np.array(map(round_map, x[iHi] + 2 * d))\n fNew = F(xNew, args)\n f_count += 1\n # print \"Reflected point: \", xNew, \" value: \", fNew\n\n # check for no improvement over the worst point\n # and for plateau condition\n if f[iHi] - epsilon <= fNew <= f[iHi] + epsilon:\n p_count += 1\n # print \"No improvement here\"\n\n if p_count == n+2: # we reflected all vertices with no improvement\n print \"Stopping criteria: Probably we landed on a plateau... exiting\" # TODO: restart instead of exiting\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'PLATEAU'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'PLATEAU'}\n\n\n else:\n p_count = 0\n\n\n if fNew <= f[iLo]: # if the new value is better than the best so far,\n x[iHi] = xNew # substitute the worst vertex with the new one\n f[iHi] = fNew\n\n # try to expand the reflection\n xNew = np.array(map(round_map, x[iHi] + d))\n fNew = F(xNew, args)\n f_count += 1\n # print \"Expanded point: \", xNew, \" value: \", fNew\n\n if fNew <= f[iHi]: # in the original source version it is f[iLo] (?)\n x[iHi] = xNew\n f[iHi] = fNew\n else:\n # try reflection again\n if fNew <= f[iHi]:\n x[iHi] = xNew\n f[iHi] = fNew\n else:\n # try contraction\n xNew = np.array(map(round_map, x[iHi] + 0.5 * d))\n fNew = F(xNew, args)\n f_count += 1\n # print \"Contracted point: \", xNew, \" value: \", fNew\n\n if fNew <= f[iHi]: # accept contraction\n x[iHi] = xNew\n f[iHi] = fNew\n else:\n # shrink\n for i in xrange(len(x)):\n if i != iLo:\n x[i] = np.array(map(round_map, x[i] - x[iLo] * 0.5))\n f[i] = F(x[i], args)\n f_count += 1\n\n # print \"End of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\n # print \"x: \", x, \" f: \", f\n # print \"*\"*50\n # print \"\"\n\n\n\n print \"Stopping criteria: maximum number of iterations\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXITERATION'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXITERATION'}","def maximize(self,x0,method='fmin',**kwargs):\n return self._optimize(x0,'max',method,**kwargs)","def minimize(self, func, grad, x0, args=()):\n learning_rate = self._learning_rate\n best_x = x = x0\n best_value = func(x, *args)\n iters_without_improve = 0\n\n for iteration in range(self._max_iterations):\n gradient = grad(x, *args)\n\n # If absolute values of all partial derivatives are equal to 0 with specified accuracy, then parameters are\n # close enough to the minimum and there is no need to continue gradient descent.\n if np.abs(gradient).max() <= self._accuracy:\n break\n\n x = x - learning_rate * gradient\n\n # If new values of x haven't lead to decrease of the function value for the specified number of iteration,\n # the x is reverted to its previous best value and the learning rate is reduced\n value = func(x, *args)\n if value > best_value:\n iters_without_improve += 1\n if iters_without_improve >= self._lr_reduce_patience:\n x = best_x\n learning_rate *= self._lr_reduce_factor\n else:\n iters_without_improve = 0\n best_value = value\n best_x = x\n\n return best_x","def lbfgs(self, pstart, Nepochs=50, bounds=None, disp_p=False,\n maxfun=15000, args=(), pass_self=False, res=False,\n callback=None):\n\n self.params = pstart\n self.bounds = self._parse_bounds(bounds)\n self.Nepochs = Nepochs\n self.disp_p = disp_p \n\n # Restart the counters\n self.iteration = 0\n self.t_store = time.time()\n self.of_list = []\n\n # Get initial of value\n of = self.objective(self.params, *args)\n self.of_list.append(self._get_value(of)) \n\n def of(params, *args, **kwargs):\n \"\"\"Modify the objective function slightly to allow storing\n intermediate objective values without re-evaluating the function\n \"\"\"\n if pass_self == True:\n arglist = list(args)\n arglist.append(self)\n args = tuple(arglist)\n\n out = value_and_grad(self.objective)(params, *args, **kwargs)\n self.of_last = self._get_value(out[0])\n return out\n\n def cb(xk):\n \"\"\"Callback function for the SciPy minimizer\n \"\"\"\n self.iteration += 1\n t_current = time.time()\n t_elapsed = t_current - self.t_store\n self.t_store = t_current\n \n self.of_list.append(self.of_last)\n self.params = xk\n self._disp(t_elapsed)\n\n # Call the custom callback function if any\n if callback is not None:\n callback(self)\n\n res_opt = minimize(of, self.params, args=args, method='L-BFGS-B',\n jac=True, bounds=self.bounds, tol=None, callback=cb,\n options={'disp': False,\n 'maxcor': 10,\n 'ftol': 1e-8,\n 'gtol': 1e-5,\n 'eps': 1e-08,\n 'maxfun': maxfun,\n 'maxiter': Nepochs,\n 'iprint': -1,\n 'maxls': 20})\n\n if res == False:\n return (res_opt.x, self.of_list)\n else:\n return (res_opt.x, self.of_list, res_opt)","def find_mle_by_grad_descent(initial_sensor_loc, \n\t\t obj_loc, distance, lr=0.001, num_iters = 1000): \n\tsensor_loc = initial_sensor_loc\n\t# Your code: finish the gradient descent\n\n\treturn sensor_loc","def optimize_gp_hyperparams(x, y, optimization_steps, learning_rate,\r\n kernel=rational_quadratic_kernel_torch, params=None):\r\n x = np.array(x).reshape(-1, 1)\r\n y = np.array(y).reshape(-1, 1)\r\n N = len(x)\r\n\r\n # tranform our training set in Tensor\r\n x_tensor = torch.from_numpy(x).float()\r\n y_tensor = torch.from_numpy(y).float()\r\n\r\n # we should define our hyperparameters as torch parameters where we keep track of\r\n # the operations to get hte gradients from them\r\n m = np.abs(y[-1][0])\r\n mu = torch.tensor(m).float()\r\n s = np.var(y)\r\n sig = torch.tensor(s).float()\r\n if params:\r\n lambda_param = nn.Parameter(torch.tensor(params['ls']), requires_grad=True)\r\n alpha_param = nn.Parameter(torch.tensor(params['a']), requires_grad=True)\r\n output_variance = nn.Parameter(torch.tensor(params['ov']), requires_grad=True)\r\n noise_variance = nn.Parameter(torch.tensor(params['nv']), requires_grad=True)\r\n mu_param = nn.Parameter(torch.tensor(params['mu']), requires_grad=True)\r\n sig_param = nn.Parameter(torch.tensor(params['sig']), requires_grad=True)\r\n\r\n else:\r\n lambda_param = nn.Parameter(torch.tensor(1.), requires_grad=True)\r\n alpha_param = nn.Parameter(torch.tensor(1.), requires_grad=True)\r\n output_variance = nn.Parameter(torch.tensor(1.), requires_grad=True)\r\n noise_variance = nn.Parameter(torch.tensor(2.5), requires_grad=True)\r\n mu_param = nn.Parameter(mu, requires_grad=True)\r\n sig_param = nn.Parameter(sig, requires_grad=True)\r\n\r\n # we use Adam as optimizer\r\n optim = torch.optim.Adam([lambda_param, alpha_param, output_variance,\r\n noise_variance, mu_param, sig_param], lr=learning_rate)\r\n\r\n # optimization loop using the log-likelihood that involves the cholesky decomposition\r\n nlls = []\r\n lambdas = []\r\n output_variances = []\r\n noise_variances = []\r\n iterations = optimization_steps\r\n for i in range(iterations):\r\n if lambda_param.item() == lambda_param.item():\r\n return_dict = {'ls': lambda_param.item(),\r\n 'a': alpha_param.item(),\r\n 'ov': output_variance.item(),\r\n 'nv': noise_variance.item(),\r\n 'mu': mu_param.item(),\r\n 'sig': sig_param.item()}\r\n assert noise_variance >= 0, f\"ouch! {i, noise_variance}\"\r\n optim.zero_grad()\r\n K = kernel(x_tensor, x_tensor, lambda_param, alpha_param,\r\n output_variance) + noise_variance * torch.eye(N)\r\n try:\r\n cholesky = torch.cholesky(K)\r\n _alpha_temp, _ = torch.solve(y_tensor, cholesky)\r\n _alpha, _ = torch.solve(_alpha_temp, cholesky.t())\r\n except:\r\n return return_dict\r\n nll = N / 2 * torch.log(torch.tensor(2 * np.pi)) + 0.5 * torch.matmul(y_tensor.transpose(0, 1), _alpha) + \\\r\n torch.sum(torch.log(torch.diag(cholesky)))\r\n\r\n # we have to add the log-likelihood of the prior\r\n norm = distributions.Normal(loc=m, scale=s)\r\n prior_negloglike = torch.log(lambda_param) - torch.log(torch.exp(norm.log_prob(lambda_param)))\r\n\r\n nll += 0.9 * prior_negloglike\r\n nll.backward()\r\n\r\n nlls.append(nll.item())\r\n lambdas.append(lambda_param.item())\r\n output_variances.append(output_variance.item())\r\n noise_variances.append(noise_variance.item())\r\n optim.step()\r\n\r\n # projected in the constraints (lengthscale and output variance should be positive)\r\n for p in [lambda_param, output_variance]:\r\n p.data.clamp_(min=0.0000001)\r\n noise_variance.data.clamp_(min=0.001, max=0.05)\r\n alpha_param.data.clamp_(min=0.001, max=0.1)\r\n # mu_param.data.clamp_(min=0.01, max=40)\r\n # sig_param.data.clamp_(min=0.01, max=40)\r\n\r\n return_dict = {'ls': lambda_param.item(),\r\n 'a': alpha_param.item(),\r\n 'ov': output_variance.item(),\r\n 'nv': noise_variance.item(),\r\n 'mu': mu_param.item(),\r\n 'sig': sig_param.item()}\r\n\r\n return return_dict","def inner_recompute_grad(*dresult):\n # Gradient calculation for reverse mode autodiff.\n with backprop.GradientTape() as t:\n id_args = nest.map_structure(gen_array_ops.identity, args)\n # Tuple `dresult` should contain at least one tensor.\n assert len(dresult) >= 1\n\n if not context.executing_eagerly():\n # XLA doesn't respect `tf.control_dependencies`. The code block\n # below manually adds a data dependency to `dresult` to ensure\n # recomputation of `f(*args, **kwargs)` happens after `dresult`.\n\n # This works even if `dresult[0]` is a size 0 tensor as reduce_max\n # of a size 0 tensor returns -inf. Use reshape here to avoid reading\n # the entire `dresult[0]`.\n elem = math_ops.reduce_max(array_ops.reshape(dresult[0], [-1])[:1])\n # Cast elem to bool in case elem is NaN.\n elem_bool = math_ops.cast(elem, dtypes.bool)\n dresult_dep = array_ops.where_v2(\n elem_bool == elem_bool, 0., float(\"nan\")) # pylint: disable=comparison-with-itself\n id_args = nest.map_structure(\n lambda x: x + math_ops.cast(dresult_dep, x.dtype), id_args)\n\n t.watch(id_args)\n if variables is not None:\n t.watch(variables)\n with variable_scope.variable_scope(current_var_scope):\n recomputed_result = f(*id_args, **kwargs)\n kw_vars = []\n if variables is not None:\n kw_vars = list(variables)\n grads = t.gradient(\n recomputed_result,\n list(id_args) + kw_vars,\n output_gradients=dresult,\n unconnected_gradients=UnconnectedGradients.ZERO)\n\n def transpose(*t_args, **t_kwargs):\n \"\"\"Gradient function calculation for forward mode autodiff.\"\"\"\n # Just throw an error since gradients / activations are not stored on\n # tape for recompute.\n raise NotImplementedError(\n \"recompute_grad tried to transpose grad of {}. \"\n \"Consider not using recompute_grad in forward mode\"\n \"autodiff\".format(f.__name__))\n\n return (grads[:len(id_args)], grads[len(id_args):]), transpose","def optimizer(targets_float32, predictions_float32, learning_rate, global_step, coeff_l2_norm_pred_error, coeff_grad_error, scope):\n if coeff_l2_norm_pred_error < 0.:\n raise ValueError('`coeff_l2_norm_pred_error` is not positive.')\n if coeff_grad_error < 0.:\n raise ValueError('`coeff_grad_error` is not positive.')\n if not coeff_l2_norm_pred_error and not coeff_grad_error:\n raise ValueError('`coeff_l2_norm_pred_error` and `coeff_grad_error` are equal to 0.')\n \n # If `coeff_l2_norm_pred_error` is equal to 0.0, we\n # should not allocate memory for the computation of\n # the l2-norm prediction error. Similarly, if `coeff_grad_error`\n # is equal to 0.0, we should not allocate memory for\n # the computation of the gradient error.\n loss_float32 = tf.constant(0.,\n dtype=tf.float32)\n dict_errors = {}\n if coeff_l2_norm_pred_error:\n dict_errors['l2_norm_pred_error'] = coeff_l2_norm_pred_error*pnn.tfutils.prediction_error_l2_norm(targets_float32,\n predictions_float32)\n loss_float32 += dict_errors['l2_norm_pred_error']\n if coeff_grad_error:\n dict_errors['grad_error'] = coeff_grad_error*pnn.tfutils.prediction_error_gradient(targets_float32,\n predictions_float32)\n loss_float32 += dict_errors['grad_error']\n weight_decay = 5.e-4*weight_l2_norm()\n loss_float32 += weight_decay\n optimization = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(\n loss_float32,\n var_list=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=scope),\n global_step=global_step\n )\n return (dict_errors, weight_decay, optimization)","def Solve(self, cost, termination=None, ExtraArgs=(), **kwds):\n # process and activate input settings\n sigint_callback = kwds.pop('sigint_callback', None)\n settings = self._process_inputs(kwds)\n disp = settings['disp'] if 'disp' in settings else False\n echo = settings['callback'] if 'callback' in settings else None\n# for key in settings:\n# exec \"%s = settings['%s']\" % (key,key)\n if disp in ['verbose', 'all']: verbose = True\n else: verbose = False\n #-------------------------------------------------------------\n\n from python_map import python_map\n if self._map != python_map:\n #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp'\n from mystic.monitors import Null\n evalmon = Null()\n else: evalmon = self._evalmon\n fcalls, cost = wrap_function(cost, ExtraArgs, evalmon)\n\n # set up signal handler\n #self._EARLYEXIT = False\n self._generateHandler(sigint_callback) \n\n # activate signal_handler\n #import threading as thread\n #mainthread = isinstance(thread.current_thread(), thread._MainThread)\n #if mainthread: #XXX: if not mainthread, signal will raise ValueError\n import signal\n if self._handle_sigint:\n signal.signal(signal.SIGINT,self.signal_handler)\n\n # register termination function\n if termination is not None: self.SetTermination(termination)\n\n # get the nested solver instance\n solver = self._AbstractEnsembleSolver__get_solver_instance()\n #-------------------------------------------------------------\n\n # generate starting points\n initial_values = self._InitialPoints()\n\n # run optimizer for each grid point\n from copy import deepcopy as _copy\n op = [_copy(solver) for i in range(len(initial_values))]\n #cf = [cost for i in range(len(initial_values))]\n vb = [verbose for i in range(len(initial_values))]\n cb = [echo for i in range(len(initial_values))] #XXX: remove?\n at = self.id if self.id else 0 # start at self.id\n id = range(at,at+len(initial_values))\n\n # generate the local_optimize function\n def local_optimize(solver, x0, rank=None, disp=False, callback=None):\n from copy import deepcopy as _copy\n from mystic.tools import isNull\n solver.id = rank\n solver.SetInitialPoints(x0)\n if solver._useStrictRange: #XXX: always, settable, or sync'd ?\n solver.SetStrictRanges(min=solver._strictMin, \\\n max=solver._strictMax) # or lower,upper ?\n solver.Solve(cost, disp=disp, callback=callback)\n sm = solver._stepmon\n em = solver._evalmon\n if isNull(sm): sm = ([],[],[],[])\n else: sm = (_copy(sm._x),_copy(sm._y),_copy(sm._id),_copy(sm._info))\n if isNull(em): em = ([],[],[],[])\n else: em = (_copy(em._x),_copy(em._y),_copy(em._id),_copy(em._info))\n return solver, sm, em\n\n # map:: solver = local_optimize(solver, x0, id, verbose)\n results = self._map(local_optimize, op, initial_values, id, \\\n vb, cb, **self._mapconfig)\n\n # save initial state\n self._AbstractSolver__save_state()\n #XXX: HACK TO GET CONTENT OF ALL MONITORS\n # reconnect monitors; save all solvers\n from mystic.monitors import Monitor\n while results: #XXX: option to not save allSolvers? skip this and _copy\n _solver, _stepmon, _evalmon = results.pop()\n sm = Monitor()\n sm._x,sm._y,sm._id,sm._info = _stepmon\n _solver._stepmon.extend(sm)\n del sm\n em = Monitor()\n em._x,em._y,em._id,em._info = _evalmon\n _solver._evalmon.extend(em)\n del em\n self._allSolvers[len(results)] = _solver\n del results, _solver, _stepmon, _evalmon\n #XXX: END HACK\n\n # get the results with the lowest energy\n self._bestSolver = self._allSolvers[0]\n bestpath = self._bestSolver._stepmon\n besteval = self._bestSolver._evalmon\n self._total_evals = self._bestSolver.evaluations\n for solver in self._allSolvers[1:]:\n self._total_evals += solver.evaluations # add func evals\n if solver.bestEnergy < self._bestSolver.bestEnergy:\n self._bestSolver = solver\n bestpath = solver._stepmon\n besteval = solver._evalmon\n\n # return results to internals\n self.population = self._bestSolver.population #XXX: pointer? copy?\n self.popEnergy = self._bestSolver.popEnergy #XXX: pointer? copy?\n self.bestSolution = self._bestSolver.bestSolution #XXX: pointer? copy?\n self.bestEnergy = self._bestSolver.bestEnergy\n self.trialSolution = self._bestSolver.trialSolution #XXX: pointer? copy?\n self._fcalls = self._bestSolver._fcalls #XXX: pointer? copy?\n self._maxiter = self._bestSolver._maxiter\n self._maxfun = self._bestSolver._maxfun\n\n # write 'bests' to monitors #XXX: non-best monitors may be useful too\n self._stepmon = bestpath #XXX: pointer? copy?\n self._evalmon = besteval #XXX: pointer? copy?\n self.energy_history = None\n self.solution_history = None\n #from mystic.tools import isNull\n #if isNull(bestpath):\n # self._stepmon = bestpath\n #else:\n # for i in range(len(bestpath.y)):\n # self._stepmon(bestpath.x[i], bestpath.y[i], self.id)\n # #XXX: could apply callback here, or in exec'd code\n #if isNull(besteval):\n # self._evalmon = besteval\n #else:\n # for i in range(len(besteval.y)):\n # self._evalmon(besteval.x[i], besteval.y[i])\n #-------------------------------------------------------------\n\n # restore default handler for signal interrupts\n if self._handle_sigint:\n signal.signal(signal.SIGINT,signal.default_int_handler)\n\n # log any termination messages\n msg = self.Terminated(disp=disp, info=True)\n if msg: self._stepmon.info('STOP(\"%s\")' % msg)\n # save final state\n self._AbstractSolver__save_state(force=True)\n return","def process_solve_kwargs(**kwargs):\n\n tol = kwargs.get('tol', DEFAULT_TOL)\n maxiter = kwargs.get('maxiter', MAX_ITER)\n Ainv = kwargs.get('Ainv', None)\n verbose = kwargs.get('verbose', False)\n\n if VERBOSE:\n print(\"tol:\", tol)\n print(\"maxiter:\", maxiter)\n print(\"Ainv:\", Ainv)\n\n return tol, int(maxiter), Ainv, verbose","def maximum(x, y):\r\n # see decorator for function body\r","def optimize(model, deep=3, data_version=\"version_6\", first_loc=1, end_loc=7):\n if model == \"Regressor\":\n # preprocess for MLP preceptron\n _, _, X_del, y_del, _, _ = \\\n pre_processing.merge_split(data_version=data_version, first_loc=first_loc, end_loc=end_loc)\n\n # setup a MLP preceptron\n regressor = MLPRegressor(solver='lbfgs', random_state=1)\n\n # implement hyper search\n regressor_search = hyper_search.hyper_search(regressor, X_del, y_del, deep=deep, version=data_version)\n\n return regressor_search\n\n elif model == \"Classifier\":\n # preprocess for MLP preceptron\n _, _, X_del, y_del, _, _ = \\\n pre_processing.merge_split(data_version=data_version, first_loc=first_loc, end_loc=end_loc, regressor=False)\n\n # setup a MLP preceptron\n classifier = MLPClassifier(solver='lbfgs', random_state=1)\n\n # implement hyper search\n classifier_search = hyper_search.hyper_search(classifier, X_del, y_del, deep=deep, version=data_version)\n\n return classifier_search"],"string":"[\n \"def optimize_library_descent_multiple(self, target, direction='max',\\n trials=4, multiprocessing=False,\\n ret_error=False, **kwargs):\\n \\n # pass some parameters down to the optimization function to call\\n kwargs['target'] = target\\n kwargs['direction'] = direction\\n \\n # initialize the list of jobs with an optimization job starting from the\\n # current interaction matrix\\n joblist = [(self.init_arguments, 'optimize_library_descent', kwargs)]\\n sens_mat = self.sens_mat #< store matrix to restore it later\\n\\n # set the ensemble of sensitivity matrices to try\\n self.choose_sensitivity_matrix(density='auto')\\n self.parameters['initialize_state']['sensitivity'] = 'ensemble'\\n\\n # add additional jobs with random initial interaction matrices\\n init_arguments = self.init_arguments\\n for _ in range(trials - 1):\\n joblist.append((copy.deepcopy(init_arguments),\\n 'optimize_library_descent', kwargs))\\n \\n # restore interaction matrix of this object\\n self.sens_mat = sens_mat\\n \\n if multiprocessing:\\n # calculate all results in parallel\\n pool = mp.Pool(processes=self.get_number_of_cores())\\n result_iter = pool.imap_unordered(_run_job, joblist)\\n \\n else:\\n # create a generator over which we iterate later\\n result_iter = (_run_job(job) for job in joblist)\\n \\n # find the best result by iterating over all results\\n result_best, values = None, []\\n for result in result_iter:\\n values.append(result[0])\\n # check whether this run improved the result\\n if result_best is None:\\n result_best = result\\n elif ((direction == 'max' and result[0] > result_best[0]) or\\n (direction == 'min' and result[0] < result_best[0])):\\n result_best = result\\n \\n # sort the best state and store it in the current object\\n state = self.sort_sensitivity_matrix(result_best[1])\\n self.sens_mat = state.copy()\\n\\n if ret_error:\\n # replace the best value by a tuple of the best value and its error\\n value_best = result_best[0]\\n value_err = np.abs(value_best - np.median(values))\\n result_best = ((value_best, value_err), ) + result_best[1:]\\n return result_best\",\n \"def optimize_library_anneal(self, target, direction='max', steps=100,\\n ret_info=False, args=None):\\n # lazy import\\n from .optimizer import ReceptorOptimizerAnnealer # @UnresolvedImport\\n \\n # prepare the class that manages the simulated annealing\\n annealer = ReceptorOptimizerAnnealer(self, target, direction, args,\\n ret_info=ret_info)\\n annealer.steps = int(steps)\\n annealer.Tmax = self.parameters['anneal_Tmax']\\n annealer.Tmin = self.parameters['anneal_Tmin']\\n if self.parameters['verbosity'] == 0:\\n annealer.updates = 0\\n\\n # do the optimization\\n MI, state = annealer.optimize()\\n\\n # sort the best state and store it in the current object\\n state = self.sort_sensitivity_matrix(state)\\n self.sens_mat = state.copy()\\n \\n if ret_info:\\n return MI, state, annealer.info\\n else:\\n return MI, state\",\n \"def optimize_library(self, target, method='descent', direction='max',\\n **kwargs):\\n if method == 'descent':\\n return self.optimize_library_descent(target, direction, **kwargs)\\n elif method == 'descent_multiple' or method == 'descent-multiple':\\n return self.optimize_library_descent_multiple(target, direction,\\n **kwargs)\\n elif method == 'anneal':\\n return self.optimize_library_anneal(target, direction, **kwargs)\\n \\n else:\\n raise ValueError('Unknown optimization method `%s`' % method)\",\n \"def Optimization(*args, **kwargs):\\n from warnings import warn\\n\\n warn(\\n \\\"Optimization has been renamed to OptimizationResult and will be removed as soon as v0.13.0\\\", DeprecationWarning\\n )\\n return OptimizationResult(*args, **kwargs)\",\n \"def optimize(self, max_iters=1e3, messages=False, use_counter=False,\\\\\\n factr=1e7, pgtol=1e-05):\\n logger.debug('Beginning MLE to optimize hyperparams. grad_method=%s'\\\\\\n % self.grad_method)\\n\\n # setup the optimization\\n try:\\n x0 = self._transform_parameters(self.parameters)\\n assert np.all(np.isfinite(x0))\\n except:\\n logger.error('Transformation failed for initial values. '\\\\\\n + 'Ensure constraints are met or the value is not too small.')\\n raise\\n\\n # filter out the fixed parameters\\n free = np.logical_not(self._fixed_indicies)\\n x0 = x0[free]\\n\\n # setup the counter\\n if use_counter:\\n self._counter = solver_counter(disp=True)\\n else:\\n self._counter = None\\n\\n # run the optimization\\n try:\\n x_opt, f_opt, opt = fmin_l_bfgs_b(func=self._objective_grad, x0=x0,\\\\\\n factr=factr, pgtol=pgtol, maxiter=max_iters, disp=messages)\\n except (KeyboardInterrupt,IndexError):\\n logger.info('Keyboard interrupt raised. Cleaning up...')\\n if self._counter is not None and self._counter.backup is not None:\\n self.parameters = self._counter.backup[1]\\n logger.info('will return best parameter set with'\\\\\\n + 'log-likelihood = %.4g' % self._counter.backup[0])\\n else:\\n logger.info('Function Evals: %d. Exit status: %s' % (f_opt, opt['warnflag']))\\n # extract the optimal value and set the parameters to this\\n transformed_parameters = self._previous_parameters \\n transformed_parameters[free] = x_opt\\n self.parameters = self._untransform_parameters(transformed_parameters)\\n return opt\",\n \"def Optimise(LogLikelihood,par,func_args,fixed=None,type='max',method='NM',maxiter=10000, maxfun=10000, verbose=True):\\n \\n if fixed==None:\\n var_par = np.copy(par)\\n #otherwise construct the parameter vector from var_par and fixed_par_val\\n else:\\n par = np.array(par)\\n fixed = np.array(fixed) #ensure fixed is a np array\\n #assign parameters to normal param vector\\n fixed_par = par[np.where(fixed==True)]\\n var_par = par[np.where(fixed!=True)]\\n \\n #set the algorithm to use - CG and P not working (at least not well)\\n add_kwords = {'verbose':verbose}\\n if method == 'NM':\\n Algorithm = NelderMead\\n add_kwords = {'maxiter':maxiter, 'maxfun':maxfun,'verbose':verbose}\\n elif method == 'CG':\\n print \\\"warning: CG method didn't work properly during testing\\\"\\n Algorithm = ConjugateGradient\\n elif method == 'P':\\n print \\\"warning: Powell algorithm didn't work properly during testing\\\"\\n Algorithm = Powell\\n else:\\n print \\\"error: optimisation function not found\\\"\\n return par\\n \\n #set the optimisation function to pos or neg for the fmin funcitons\\n if type == 'max': OptFunc = NegFixedPar_func\\n elif type == 'min': OptFunc = FixedPar_func\\n else:\\n print \\\"error: %s not a valid option\\\" % type\\n return par\\n \\n #call the optimser with the appropriate function\\n fitted_par = Algorithm(OptFunc, var_par, (LogLikelihood,func_args,fixed,fixed_par), \\\\\\n **add_kwords)\\n \\n #now return the params in the correct order...\\n if fixed==None:\\n return_par = fitted_par\\n else:\\n return_par = np.copy(par) \\n return_par[np.where(fixed!=True)] = fitted_par\\n \\n return return_par\",\n \"def opt_wrapper(m, **kwargs):\\r\\n m.optimize(**kwargs)\\r\\n return m.optimization_runs[-1]\",\n \"def opt_wrapper(m, **kwargs):\\n m.optimize(**kwargs)\\n return m.optimization_runs[-1]\",\n \"def __call__(self, origin, state, **kwargs):\\n fun = kwargs['function']\\n d = state['direction']/np.linalg.norm(state['direction'])\\n # filter directions that are too large\\n if self.filter:\\n ndabs_log = -np.log10(np.abs(d))\\n mean_log = np.mean(ndabs_log)\\n #print \\\"\\\\n ** MEAN =\\\", mean_log\\n direction = (ndabs_log > mean_log-1.5).astype(int)*d\\n else:\\n direction = d\\n state['direction'] = direction\\n## for pos, d in enumerate(direction):\\n## use_dir = self.use_dirs[pos]\\n## if use_dir * d < 0:\\n## # directions don't match so don't move in this direction\\n## direction[pos] = 0\\n maxStepSize = self.maxStepSize\\n if np.isscalar(maxStepSize):\\n stepSize = maxStepSize\\n else:\\n stepfacs = np.zeros(self.dim)\\n for d in range(self.dim):\\n # explicit loop so as to catch any ZeroDivisionErrors\\n try:\\n stepfacs[d] = abs(maxStepSize[d] / direction[d])\\n except ZeroDivisionError:\\n # Direction is orthogonal to this parameter direction,\\n # so ensure won't choose this as the minimum step size\\n stepfacs[d] = Inf\\n # Stop stepping with giant sizes if direction vector has strong\\n # separation of scales\\n stepSize = min(stepfacs)\\n# print \\\"direction = \\\", direction\\n# print \\\"step = \\\", step\\n i = 1\\n old_value = state['old_value']\\n not_done = True\\n# print \\\"** TEMP: Hardwiring step size to be 0.0005\\\"\\n# stepSize = 0.0005\\n init_step = stepSize\\n while not_done:\\n print(\\\"\\\\nLinestep: i =\\\", i, \\\"step size =\\\", stepSize, \\\"direction =\\\\n\\\", end='')\\n print(direction)\\n p = origin + i * stepSize * direction\\n print(\\\"Testing p = \\\", p)\\n new_value = fun(p)\\n if new_value < old_value:\\n i += 1\\n old_value = new_value\\n else:\\n if i == 1:\\n # don't shrink step size to be less than 1/maxReduceFac of initial\\n if stepSize*self.maxReduceFac < init_step:\\n not_done = False\\n p = origin + (i-1) * stepSize * direction\\n else:\\n stepSize /= self.stepMod\\n else:\\n # had found a working step but it's no longer stepping to lower residuals\\n not_done = False\\n p = origin + (i-1) * stepSize * direction\\n state['alpha_step'] = stepSize\\n return p\",\n \"def optimization_step(self):\\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\\n \\n var_list = [self.x_tilda, self.minibatch_set]\\n \\n if (self.num_samples > 0) and (not self.mixture):\\n \\n if ((self.mf_steps > 0) and self.alpha >0) or\\\\\\n self.gibbs_steps > 0: \\n \\n var_list.append(self.sampler_theta)\\n \\n elif \\\"CD\\\" in self.algorithm:\\n \\n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \\n \\n var_list = [self.minibatch_set]\\n \\n var_list.append(self.learning_rate)\\n \\n if self.use_momentum:\\n \\n var_list.append(self.momentum)\\n \\n output_vars = [self.pseudo_cost]\\n \\n if self.report_p_tilda:\\n \\n output_vars.append(self.p_tilda)\\n \\n else:\\n \\n output_vars.append(theano.shared(0))\\n \\n opt_step = theano.function(inputs = var_list,\\n outputs = output_vars,\\n updates = self.updates,\\n givens = input_dict,\\n on_unused_input='warn')\\n \\n return opt_step\",\n \"def optimize(maxiter: int = 1000,\\n tol = None,\\n save_steps: int = 1,\\n c0: float = 0.62,\\n c1: float = 0.1,\\n c2: float = 0.602,\\n c3: float = 0.101,\\n c4: float = 0):\\n _spsa_vars = [c0, c1, c2, c3, c4]\\n theta = self.vectorizer.vector\\n nb_params = len(theta)\\n use_exact_grads = 'grads' in self._method\\n \\n if save_steps:\\n theta_vec = [theta]\\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\\n \\n \\n pbar = tqdm(total=maxiter, disable=not self.progbar)\\n def callback(_):\\n pbar.clear()\\n pbar.update()\\n val = round(self.loss, 5)\\n pbar.set_description(str(val))\\n\\n if self.loss_target is not None:\\n if self.loss < self.loss_target:\\n # returning True doesn't terminate optimization\\n pbar.close()\\n raise KeyboardInterrupt\\n \\n for ii in range(maxiter):\\n \\n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\\n delta = 2 * randint(0, 2, size=nb_params) - 1\\n # plus and minus directions\\n \\n if use_exact_grads:\\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\\n else:\\n theta_plus = theta + c_spsa * delta\\n theta_minus = theta - c_spsa * delta\\n\\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\\n # derivative estimate\\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\\n # updated theta\\n theta = theta - a_spsa * g_spsa\\n \\n callback(ii)\\n \\n if tol is not None:\\n if (cost_plus + cost_minus)/2 < tol:\\n pbar.close()\\n break\\n \\n if save_steps:\\n theta_vec.append(theta)\\n cost_vec.append(cost_plus/2+cost_minus/2)\\n \\n \\n result_dict = {'hyper_parameters':_spsa_vars,\\n 'maxiter':maxiter,\\n 'theta_opt':theta,\\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\\n if save_steps:\\n result_dict['theta_history'] = theta_vec\\n result_dict['cost_history'] = cost_vec\\n self.result_dict = result_dict\\n pbar.close()\\n\\n return self.inject_res_vector_and_return_tn()\",\n \"def optimize(self, X, y, *args):\\n self.loss_function.set_space(X, y, *args)\\n self.betas_ = fastgradalgo(\\n self.loss_function,\\n t_init=self.eta_init,\\n max_iter=self.max_iter\\n )\\n return self.betas_\",\n \"def optimize(self, coords_batch: SameSizeCoordsBatch, energy_helper):\\n\\n a_coords = coords_batch.coords\\n n_total_confs = a_coords.shape[0]\\n n_atoms = a_coords.shape[1]\\n \\n func_evals = 0\\n\\n # evaluate initial f(x) and df/dx\\n loss, std = energy_helper.compute_energy() # loss[nConf]\\n st = OptState(self, n_total_confs, n_atoms, loss.dtype)\\n st.loss = loss\\n st.std = std\\n min_loss = st.loss.detach().clone()\\n \\n minE_no_constraints = energy_helper.energy_no_constraint().detach().clone()\\n min_std = torch.full_like(minE_no_constraints, -1)\\n st.flat_grad = energy_helper.compute_grad().reshape(st.n_confs,-1)\\n min_grad_square_max = torch.full((n_total_confs,), 9e20, dtype=a_coords.dtype, device=self.device)\\n #st.abs_grad_sum = st.flat_grad.abs().sum(1)\\n \\n status = torch.zeros((n_total_confs,),dtype=torch.uint8, device=self.device)\\n is_active = torch.ones((n_total_confs,), dtype=torch.uint8, device=self.device).bool()\\n conf_steps = torch.full((n_total_confs,), -1, dtype=torch.int16, device=self.device)\\n minE_coords = a_coords.detach().clone()\\n minE_grad = torch.full((n_total_confs,n_atoms*3), -999, dtype=a_coords.dtype, device=self.device)\\n \\n current_evals = 1\\n func_evals += 1\\n n_iter = 0\\n\\n # optimize for a max of max_iter iterations\\n while n_iter < self.convergence_opts.max_iter:\\n # keep track of nb of iterations\\n n_iter += 1\\n\\n ############################################################\\n # compute gradient descent direction\\n ############################################################\\n if n_iter == 1:\\n st.d = st.flat_grad.neg()\\n else:\\n # d: direction of step\\n # s: step = direction * trust of step\\n # y: delta gradient in step (grad - prev_grad) = vector of gradient change\\n # ys: sum(y * step) \\n # do lbfgs update (update memory)\\n y = st.flat_grad.sub(st.prev_flat_grad)\\n \\n s = st.d*st.t.reshape(-1,1)\\n \\n ys = torch.sum(y * s, dim=1)\\n \\n is_valid_step = ys > 1e-10 # DIAL BACK TO 10E-6,4,5, look at RFO, rational function optimization\\n # reach out to lee-ping or roland king (optking)\\n # try occasionally setting h_diag to 1\\n # look into getting code from psi4 to convert, (little bit of a mess) cartesian to internal pyoptking\\n # pyberny: has nicer code for internal coordinates\\n # maybe can get initial hessian guess in internal coordinates and project back to xyz and use as first guess\\n st.old_dirs.push_if(is_valid_step, y)\\n st.old_stps.push_if(is_valid_step, s)\\n y = y[is_valid_step] \\n st.H_diag[is_valid_step] = ys[is_valid_step] / torch.sum(y * y, dim=1)\\n d_not_valid_steps = st.flat_grad[~is_valid_step].neg() #d[~is_valid_step]\\n \\n # compute the approximate (L-BFGS) inverse Hessian\\n # multiplied by the gradient\\n \\n ro = 1. / torch.sum(st.old_dirs.container * st.old_stps.container, dim=2)\\n ro[torch.isinf(ro)] = 1e-10\\n\\n al = torch.zeros((self.history_size,st.n_confs), dtype=loss.dtype, device=self.device)\\n \\n num_old = st.old_dirs.count_hist.max()\\n# log.debug(\\\"old_dirs {}\\\\n{}\\\".format(num_old, st.old_dirs.container[0:num_old]))\\n \\n q = st.flat_grad.neg()\\n for i in range(num_old):\\n al[i] = torch.sum(st.old_stps.container[i]* q, dim=1) * ro[i]\\n q.add_(-al[i].reshape(-1,1) * st.old_dirs.container[i])\\n st.d = r = q * st.H_diag.reshape(-1,1) \\n# log.debug(\\\"al {}\\\".format(al[0:num_old]))\\n# log.debug(\\\"q {}\\\".format(q))\\n# log.debug(\\\"d {}\\\".format(st.d))\\n# log.debug(\\\"H_diag {}\\\".format(st.H_diag))\\n# \\n for i in range(num_old - 1, -1, -1):\\n be_i = torch.sum(st.old_dirs.container[i] * r, dim=1) * ro[i]\\n# log.debug(\\\"{} od {}\\\".format(i,st.old_dirs.container[i]))\\n# log.debug(\\\"{} r {}\\\".format(i,r))\\n# log.debug(\\\"{} ro {}\\\".format(i,ro[i]))\\n# log.debug(\\\"{} bei {}\\\".format(i,be_i))\\n r.add_((al[i] - be_i).reshape(-1,1) * st.old_stps.container[i])\\n# log.debug(\\\"{} r {}\\\".format(i,r))\\n# st.d[~is_valid_step] = d_not_valid_steps\\n\\n if st.prev_flat_grad is None:\\n st.prev_flat_grad = st.flat_grad.clone()\\n else:\\n st.prev_flat_grad.copy_(st.flat_grad)\\n st.prev_loss = st.loss\\n\\n ############################################################\\n # compute step length\\n ############################################################\\n # reset initial guess for trust\\n if n_iter == 1:\\n st.t = self.trust_by_step_size(a_coords, st.d, 0.1) \\n else:\\n# log.debug(lr)\\n st.t = st.lr.clone()\\n #if n_iter > 10: st.t = st.t + st.t * random.gauss(0, 0.1)\\n\\n if self.line_search_fn == \\\"Armijo\\\":\\n ls_func_evals = self.armijo_line_search(n_iter, a_coords, st, energy_helper)\\n \\n elif self.line_search_fn == \\\"Wolfe\\\":\\n ls_func_evals =self.wolfe_lineSearch(n_iter, a_coords, st, energy_helper)\\n \\n else:\\n # directional derivative\\n #gtd = torch.sum(st.flat_grad * st.d, dim=1) # g * d\\n\\n # no line search, simply move with fixed-step\\n st.t = self._add_grad(a_coords, st.t, st.d)\\n \\n if n_iter != self.convergence_opts.max_iter:\\n # re-evaluate function only if not in last iteration\\n # the reason we do this: in a stochastic setting,\\n # no use to re-evaluate that function here\\n st.loss, st.std = energy_helper.compute_energy()\\n st.flat_grad = energy_helper.compute_grad().reshape(st.n_confs,-1)\\n #st.abs_grad_sum = st.flat_grad.abs().sum(1) # not needed\\n ls_func_evals = 1\\n\\n\\n # update func eval\\n current_evals += ls_func_evals\\n func_evals += ls_func_evals\\n\\n\\n ############################################################\\n # check conditions\\n ############################################################\\n #\\n # active conformers are conformers that have not convereged\\n # all variable in st. (OptState) are limited to active conformers\\n #\\n # local variables that have only elements for active conformers in the following evaluation\\n # code have an \\\"a_\\\" prefix\\n #\\n \\n status[is_active] = 0\\n \\n \\n # a_ prefix flags tensors on active conformers only, just as st.\\n a_flat_grad_sqare = st.flat_grad.pow(2)\\n a_flat_grad_MSE = a_flat_grad_sqare.sum(1) / n_atoms \\n a_flat_grad_square_max = a_flat_grad_sqare.max(1)[0]\\n\\n if log.isEnabledFor(logging.DEBUG):\\n log.debug('{} loss: {}, max_grad: {} a_coords[0:5,1,0] {}'.format(\\n n_iter, \\n st.loss[0:5].detach().cpu().numpy(),\\n a_flat_grad_square_max.sqrt().detach().cpu().numpy(),\\n a_coords[0:5,0,0].detach().cpu().numpy()))\\n\\n a_deltaLoss = st.loss - min_loss[is_active]\\n st.last_decreased[a_deltaLoss < 0] = n_iter\\n\\n # check if energy is converged\\n a_e_decreased = a_deltaLoss * a_deltaLoss < self.convergence_opts.convergence_es\\n e_decreased_idx = st.in_confIdx[a_e_decreased]\\n status[e_decreased_idx] |= Status.ENERGY_CONVERGED\\n \\n # flag geometry as \\\"decreased\\\" if it went down or stated ~ same but gradient decreased \\n # allow for 10x more tolerance because if forces are decreased\\n a_deltaGrad = a_flat_grad_square_max - min_grad_square_max[is_active]\\n a_e_decreased = ( (a_deltaLoss < 0)\\n | ((a_deltaLoss <= self.convergence_opts.convergence_es * 10) \\n &(a_deltaGrad < 0))) \\n e_decreased_idx = st.in_confIdx[a_e_decreased]\\n \\n # store best geometry when geom is found\\n if e_decreased_idx:\\n minE_coords[e_decreased_idx] = a_coords[a_e_decreased].detach_()\\n minE_no_constraints[e_decreased_idx] = \\\\\\n energy_helper.energy_no_constraint()[a_e_decreased].detach_()\\n minE_grad[e_decreased_idx] = st.flat_grad[a_e_decreased].detach_()\\n min_loss [e_decreased_idx] = st.loss[a_e_decreased].detach().clone()\\n if not st.std is None: min_std[e_decreased_idx] = st.std[a_e_decreased]\\n min_grad_square_max[e_decreased_idx] = a_flat_grad_square_max[a_e_decreased]\\n \\n dummy = n_iter - st.last_decreased >= self.convergence_opts.max_it_without_decrease\\n status[st.in_confIdx[dummy]] |= Status.ENERGY_NOT_DECREASING\\n \\n dummy = (a_flat_grad_MSE < self.convergence_opts.convergence_gms) \\\\\\n & (a_flat_grad_square_max < self.convergence_opts.convergence_gmaxs)\\n status[st.in_confIdx[dummy]] |= Status.GRADIENT_CONVERGED \\n\\n dt_square = st.d*st.t.reshape(-1,1)\\n dt_square *= dt_square\\n dummy = (dt_square.sum(1)/ n_atoms <= self.convergence_opts.convergence_dms) \\\\\\n & (dt_square.max(1)[0] <= self.convergence_opts.convergence_dmaxs)\\n status[st.in_confIdx[dummy]] |= Status.GEOMETRY_CONVERGED\\n \\n if self.plot_data is not None:\\n rec = torch.full((n_total_confs,), float('nan'), dtype=st.loss.dtype, device=self.device)\\n rec[is_active] = st.loss\\n self.plot_data.append([n_iter, rec])\\n \\n actives_finished = (status[is_active] >= Status.ALL_CONVERGED) \\n\\n actives_finished_in_idx = st.in_confIdx[actives_finished]\\n # set conf_steps for not-finished conformations\\n conf_steps[actives_finished_in_idx] = n_iter\\n\\n if (~actives_finished).sum() == 0:\\n log.info(f\\\"all finished (nIter={n_iter}): {minE_no_constraints}\\\") \\n break\\n\\n if n_iter == self.convergence_opts.max_iter:\\n log.info(f\\\"MAX_ITER reached: {minE_no_constraints}\\\")\\n status[ st.in_confIdx[~actives_finished] ] |= Status.ITERATIONS_EXCEEDED\\n break\\n if current_evals >= self.convergence_opts.max_iter * 3: \\n status[ st.in_confIdx[~actives_finished] ] |= Status.ITERATIONS_EXCEEDED \\n log.info(f\\\"MAX_EVAL reached: {minE_no_constraints}\\\") \\n break\\n \\n # filter out completed conformations\\n if actives_finished.sum() > 0:\\n a_future_actives = ~actives_finished\\n is_active[actives_finished_in_idx] = 0\\n st.filter_(a_future_actives)\\n energy_helper.filter_(a_future_actives) # also filters coords_batch\\n a_coords = coords_batch.coords\\n\\n if n_iter % self.prune_high_energy_freq == 0 and n_iter > 5:\\n # this is a global minimum search, to speed up: prune \\n # conformations with the highest energy\\n drop_count = int(st.loss.shape[0] * self.prune_high_energy_fract)\\n if drop_count < 1: continue\\n a_to_drop = st.loss.argsort(descending=True)[0:int(st.loss.shape[0] * self.prune_high_energy_fract)]\\n to_drop_idx = st.in_confIdx[a_to_drop]\\n is_active[to_drop_idx] = 0\\n status[to_drop_idx] = Status.HIGH_ENERGY\\n conf_steps[to_drop_idx] = n_iter\\n a_future_actives = torch.ones_like(st.loss, dtype=torch.uint8).bool()\\n a_future_actives[a_to_drop] = 0\\n st.filter_(a_future_actives)\\n energy_helper.filter_(a_future_actives) # also filters coords_batch\\n a_coords = coords_batch.coords\\n \\n if self.plot_data:\\n self.plot(n_total_confs)\\n\\n # set conf_steps for not-finished conformations\\n conf_steps[conf_steps == -1] = n_iter\\n \\n if log.isEnabledFor(logging.DEBUG):\\n log.debug(f'lbfgs completed e={minE_no_constraints}, maxgrad^2={min_grad_square_max}')\\n status[(status > Status.ALL_CONVERGED) & (status < Status.HIGH_ENERGY)] = Status.ALL_CONVERGED\\n\\n if st.std is None: min_std = None\\n return minE_coords, minE_no_constraints, minE_grad, min_std, status, conf_steps\",\n \"def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\\n return x_best, -y_best\",\n \"def optimize(self):\\n \\n if self.verbose:\\n print('Starting grid search with bounds: [' + \\\\\\n ';'.join(['%5g to %5g']*len(self.steps))%tuple([(self.steps[i][0], self.steps[i][-1]) for i in range(len(self.steps))]) +']')\\n\\n for params in self._get_next_point():\\n self.transform.set_params(params)\\n\\n v, _ = self.measure.value_and_derivatives(self.transform)\\n\\n if v < self.best_value:\\n self.best_value = v\\n self.best_params = params\\n# print('New best value %2.4f at ('%v, ', '.join(['%8.3f']*len(params))%tuple(params), ')')\\n\\n self.value_history.append(v)\\n self.last_value = v\\n self.iteration += 1\\n\\n if self.report_freq > 0 and (self.iteration % self.report_freq == 0) and self.report_func is not None:\\n self.report_func(self)\\n\\n # Set the best transform\\n self.transform.set_params(self.best_params)\\n self.last_value = self.best_value\\n return self.best_value\",\n \"def optimization_manager(config):\\n def optimize(state,\\n grad,\\n warmup=config.optim.warmup,\\n grad_clip=config.optim.grad_clip):\\n \\\"\\\"\\\"Optimizes with warmup and gradient clipping (disabled if negative).\\\"\\\"\\\"\\n lr = state.lr\\n if warmup > 0:\\n lr = lr * jnp.minimum(state.step / warmup, 1.0)\\n if grad_clip >= 0:\\n # Compute global gradient norm\\n grad_norm = jnp.sqrt(\\n sum([jnp.sum(jnp.square(x)) for x in jax.tree_leaves(grad)]))\\n # Clip gradient\\n clipped_grad = jax.tree_map(\\n lambda x: x * grad_clip / jnp.maximum(grad_norm, grad_clip), grad)\\n else: # disabling gradient clipping if grad_clip < 0\\n clipped_grad = grad\\n return state.optimizer.apply_gradient(clipped_grad, learning_rate=lr)\\n\\n return optimize\",\n \"def solve(self, topology, algorithm=\\\"SLSQP\\\", grad=\\\"AD\\\", step_size=1e-6, iters=100, eps=1e-6, kappa=1e-8, tmax=100, eta=1e-6, verbose=False):\\n if verbose:\\n print(\\\"----------\\\")\\n print(\\\"Optimization with {} started!\\\".format(algorithm))\\n print(f\\\"# Parameters: {self.number_of_parameters()}, # Constraints {self.number_of_constraints()}\\\")\\n\\n # test for bad stuff before going any further\\n self.check_optimization_sanity()\\n\\n # compose gradient and objective functions\\n if grad not in (\\\"AD\\\", \\\"FD\\\"):\\n raise ValueError(f\\\"Gradient method {grad} is not supported!\\\")\\n if grad == \\\"AD\\\":\\n if verbose:\\n print(\\\"Computing gradients using automatic differentiation!\\\")\\n x_func = partial(self._optimize_form, topology=topology.copy(), tmax=tmax, eta=eta)\\n grad_func = partial(grad_autograd, grad_func=agrad(x_func)) # x, grad, x_func\\n\\n elif grad == \\\"FD\\\":\\n if verbose:\\n print(f\\\"Warning: Calculating gradients using finite differences with step size {step_size}. This may take a while...\\\")\\n grad_func = self.gradient_func(grad_finite_differences, topology.copy(), tmax, eta, step_size)\\n\\n # grad_func = self.gradient_func(grad_func, topology.copy(), tmax, eta, step_size)\\n obj_func = self.objective_func(topology, grad_func, tmax, eta)\\n\\n # generate optimization variables\\n x = self.optimization_parameters(topology)\\n\\n # extract the lower and upper bounds to optimization variables\\n bounds_low, bounds_up = self.optimization_bounds(topology)\\n\\n # stack keyword arguments\\n hyper_parameters = {\\\"f\\\": obj_func,\\n \\\"algorithm\\\": algorithm,\\n \\\"dims\\\": self.number_of_parameters(),\\n \\\"bounds_low\\\": bounds_low,\\n \\\"bounds_up\\\": bounds_up,\\n \\\"iters\\\": iters,\\n \\\"eps\\\": eps,\\n \\\"ftol\\\": kappa}\\n\\n # assemble optimization solver\\n solver = nlopt_solver(**hyper_parameters)\\n\\n # solve optimization problem\\n x_opt = None\\n start = time()\\n try:\\n x_opt = solver.optimize(x)\\n if verbose:\\n print(\\\"Optimization ended correctly!\\\")\\n except RoundoffLimited:\\n print(\\\"Optimization was halted because roundoff errors limited progress\\\")\\n print(\\\"Results may still be useful though!\\\")\\n x_opt = self.optimization_parameters(topology)\\n except RuntimeError:\\n print(\\\"Optimization failed due to a runtime error!\\\")\\n print(f\\\"Optimization total runtime: {round(time() - start, 4)} seconds\\\")\\n return static_equilibrium(topology)\\n\\n # fetch last optimum value of loss function\\n time_opt = time() - start\\n loss_opt = solver.last_optimum_value()\\n evals = solver.get_numevals()\\n status = nlopt_status(solver.last_optimize_result())\\n\\n # set optimizer attributes\\n self.time_opt = time_opt\\n self.x_opt = x_opt\\n self.penalty = loss_opt\\n self.evals = evals\\n self.status = status\\n\\n # set norm of the gradient\\n # NOTE: np.zeros is a dummy array (signature requirement set by nlopt)\\n self.gradient = grad_func(x_opt, np.zeros(x_opt.size))\\n self.gradient_norm = np.linalg.norm(self.gradient)\\n\\n if verbose:\\n print(f\\\"Optimization total runtime: {round(time_opt, 6)} seconds\\\")\\n print(\\\"Number of evaluations incurred: {}\\\".format(evals))\\n print(f\\\"Final value of the objective function: {round(loss_opt, 6)}\\\")\\n print(f\\\"Norm of the gradient of the objective function: {round(self.gradient_norm, 6)}\\\")\\n print(f\\\"Optimization status: {status}\\\".format(status))\\n print(\\\"----------\\\")\\n\\n # exit like a champion\\n return static_equilibrium(topology)\",\n \"def step_func_cat(X, args, Y, info, Ytarget, err, tols, iter, maxIter):\\n [XF, ZF, L, EA, W, CB, WL, WEA, L_EA, CB_EA] = args[\\\"cat\\\"]\\n\\n # if abs( err[1] + ZF ) < 0.0001:\\n # breakpoint()\\n\\n [alpha_min, alpha0, alphaR] = args[\\n \\\"step\\\"\\n ] # get minimum alpha, initial alpha, and alpha reduction rate from passed arguments\\n\\n # J = info['jacobian']\\n # dX = -np.matmul(np.linalg.inv(J), err)\\n dX = -np.matmul(info[\\\"stiffnessB\\\"], err)\\n\\n # ! Reduce dHF by factor (between 1 at I = 1 and 0 at I = MaxIter) that reduces linearly with iteration count\\n # to ensure that we converge on a solution even in the case were we obtain a nonconvergent cycle about the\\n # correct solution (this happens, for example, if we jump to quickly between a taut and slack catenary)\\n\\n alpha = 1.0 # M<<<<<<<< np.max([alpha_min, alpha0*(1.0 - alphaR*iter/maxIter)])\\n\\n # exponential approach alpha = alpha0 * np.exp( iter/maxIter * np.log(alpha_min/alpha0 ) )\\n\\n dX[0] = dX[0] * alpha # dHF*( 1.0 - Tol*I )\\n dX[1] = dX[1] * alpha # dVF*( 1.0 - Tol*I )\\n\\n # To avoid an ill-conditioned situation, make sure HF does not go less than or equal to zero by having a lower limit of Tol*HF\\n # [NOTE: the value of dHF = ( Tol - 1.0 )*HF comes from: HF = HF + dHF = Tol*HF when dHF = ( Tol - 1.0 )*HF]\\n # dX[0] = max( dX[0], ( tol - 1.0 )*info['HF']);\\n\\n # To avoid an ill-conditioned situation, make sure HF does not get too close to zero, by forcing HF >= tols[0]\\n # if info['HF'] + dX[0] <= tol*abs(info['VF']+dX[1]):\\n # if info['HF'] + dX[0] <= tols[0]\\n if X[0] + dX[0] <= tols[0]:\\n # dX[0] = tol*abs(info['VF']+dX[1]) - info['HF']\\n # dX[0] = tols[0] - info['HF']\\n dX[0] = tols[0] - X[0]\\n\\n # To avoid an ill-conditioned situation where the line is nearly all on the seabed but the solver gets stuck,\\n # if np.abs(err[1] + ZF)/ZF < tol:\\n # breakpoint()\\n # deltaHFVF = info['HF'] - info['VF']\\n # dX[0] = dX[0] - 0.5*deltaHFVF\\n # dX[1] = dX[1] + 0.5*deltaHFVF\\n\\n # prevent silly situation where a line with weight and positive ZF considers a negative VF\\n if info[\\\"ProfileType\\\"] == 2:\\n if X[1] + dX[1] <= tols[1]: # if vertical force is within tolerance of being zero/negative\\n VFtarget = (L - info[\\\"LBot\\\"]) * W # set next VF value to be the weight of portion of line that's suspended\\n dX[1] = VFtarget - X[1]\\n\\n return dX # returns dX (step to make)\",\n \"def maximize(func, grad_func, x, y, theta_0, alpha_0=0.01, max_it=100):\\n return minimize(negate(func), negate_all(grad_func), x, y, theta_0, alpha_0=0.01, max_it=100)\",\n \"def optimize(self,\\n max_grad_norm=0.5,\\n learning_rate=7e-4,\\n rms_decay=0.99,\\n rms_epsilon=1e-5):\\n grads = tf.gradients(tf.negative(self.objective), self.variables)\\n if max_grad_norm is not None:\\n grads, _ = tf.clip_by_global_norm(grads, max_grad_norm)\\n trainer = tf.train.RMSPropOptimizer(learning_rate=learning_rate,\\n decay=rms_decay,\\n epsilon=rms_epsilon)\\n return trainer.apply_gradients(list(zip(grads, self.variables)))\",\n \"def checkgrad(self, target_param = None, verbose=False, step=1e-6, tolerance = 1e-3):\\n\\n x = self._get_params_transformed().copy()\\n\\n if not verbose:\\n #just check the global ratio\\n dx = step*np.sign(np.random.uniform(-1,1,x.size))\\n\\n #evaulate around the point x\\n f1, g1 = self.objective_and_gradients(x+dx)\\n f2, g2 = self.objective_and_gradients(x-dx)\\n gradient = self.objective_function_gradients(x)\\n\\n numerical_gradient = (f1-f2)/(2*dx)\\n global_ratio = (f1-f2)/(2*np.dot(dx,gradient))\\n\\n if (np.abs(1.-global_ratio)<tolerance) and not np.isnan(global_ratio):\\n return True\\n else:\\n return False\\n else:\\n #check the gradient of each parameter individually, and do some pretty printing\\n try:\\n names = self._get_param_names_transformed()\\n except NotImplementedError:\\n names = ['Variable %i'%i for i in range(len(x))]\\n\\n # Prepare for pretty-printing\\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\\n float_len = 10\\n cols = [max_names]\\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\\n cols = np.array(cols) + 5\\n header_string = [\\\"{h:^{col}}\\\".format(h = header[i], col = cols[i]) for i in range(len(cols))]\\n header_string = map(lambda x: '|'.join(x), [header_string])\\n separator = '-'*len(header_string[0])\\n print '\\\\n'.join([header_string[0], separator])\\n\\n if target_param is None:\\n param_list = range(len(x))\\n else:\\n param_list = self.grep_param_names(target_param)\\n\\n for i in param_list:\\n xx = x.copy()\\n xx[i] += step\\n f1, g1 = self.objective_and_gradients(xx)\\n xx[i] -= 2.*step\\n f2, g2 = self.objective_and_gradients(xx)\\n gradient = self.objective_function_gradients(x)[i]\\n\\n numerical_gradient = (f1-f2)/(2*step)\\n ratio = (f1-f2)/(2*step*gradient)\\n difference = np.abs((f1-f2)/2/step - gradient)\\n\\n if (np.abs(ratio-1)<tolerance):\\n formatted_name = \\\"\\\\033[92m {0} \\\\033[0m\\\".format(names[i])\\n else:\\n formatted_name = \\\"\\\\033[91m {0} \\\\033[0m\\\".format(names[i])\\n r = '%.6f' % float(ratio)\\n d = '%.6f' % float(difference)\\n g = '%.6f' % gradient\\n ng = '%.6f' % float(numerical_gradient)\\n grad_string = \\\"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\\\".format(formatted_name,r,d,g, ng, c0 = cols[0]+9, c1 = cols[1], c2 = cols[2], c3 = cols[3], c4 = cols[4])\\n print grad_string\",\n \"def nn_ga_optimise_from_args(func_caller, worker_manager, max_capital, mode, mutation_op,\\n crossover_op=None, options=None, reporter='default'):\\n if options is None:\\n reporter = get_reporter(reporter)\\n options = load_options(ga_opt_args, reporter=reporter)\\n options.mode = mode\\n return (NNGAOptimiser(func_caller, worker_manager, mutation_op, crossover_op,\\n options, reporter)).optimise(max_capital)\",\n \"def checkgrad(self, target_param=None, verbose=False, step=1e-6, tolerance=1e-3):\\r\\n\\r\\n x = self._get_params_transformed().copy()\\r\\n\\r\\n if not verbose:\\r\\n # just check the global ratio\\r\\n\\r\\n #choose a random direction to find the linear approximation in\\r\\n if x.size==2:\\r\\n dx = step * np.ones(2) # random direction for 2 parameters can fail dure to symmetry\\r\\n else:\\r\\n dx = step * np.sign(np.random.uniform(-1, 1, x.size))\\r\\n\\r\\n # evaulate around the point x\\r\\n f1, g1 = self.objective_and_gradients(x + dx)\\r\\n f2, g2 = self.objective_and_gradients(x - dx)\\r\\n gradient = self.objective_function_gradients(x)\\r\\n\\r\\n numerical_gradient = (f1 - f2) / (2 * dx)\\r\\n global_ratio = (f1 - f2) / (2 * np.dot(dx, np.where(gradient==0, 1e-32, gradient)))\\r\\n\\r\\n return (np.abs(1. - global_ratio) < tolerance) or (np.abs(gradient - numerical_gradient).mean() < tolerance)\\r\\n else:\\r\\n # check the gradient of each parameter individually, and do some pretty printing\\r\\n try:\\r\\n names = self._get_param_names_transformed()\\r\\n except NotImplementedError:\\r\\n names = ['Variable %i' % i for i in range(len(x))]\\r\\n\\r\\n # Prepare for pretty-printing\\r\\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\\r\\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\\r\\n float_len = 10\\r\\n cols = [max_names]\\r\\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\\r\\n cols = np.array(cols) + 5\\r\\n header_string = [\\\"{h:^{col}}\\\".format(h=header[i], col=cols[i]) for i in range(len(cols))]\\r\\n header_string = map(lambda x: '|'.join(x), [header_string])\\r\\n separator = '-' * len(header_string[0])\\r\\n print '\\\\n'.join([header_string[0], separator])\\r\\n\\r\\n if target_param is None:\\r\\n param_list = range(len(x))\\r\\n else:\\r\\n param_list = self.grep_param_names(target_param, transformed=True, search=True)\\r\\n if not np.any(param_list):\\r\\n print \\\"No free parameters to check\\\"\\r\\n return\\r\\n\\r\\n\\r\\n for i in param_list:\\r\\n xx = x.copy()\\r\\n xx[i] += step\\r\\n f1, g1 = self.objective_and_gradients(xx)\\r\\n xx[i] -= 2.*step\\r\\n f2, g2 = self.objective_and_gradients(xx)\\r\\n gradient = self.objective_function_gradients(x)[i]\\r\\n\\r\\n numerical_gradient = (f1 - f2) / (2 * step)\\r\\n ratio = (f1 - f2) / (2 * step * np.where(gradient==0, 1e-312, gradient))\\r\\n difference = np.abs((f1 - f2) / 2 / step - gradient)\\r\\n\\r\\n if (np.abs(1. - ratio) < tolerance) or np.abs(difference) < tolerance:\\r\\n formatted_name = \\\"\\\\033[92m {0} \\\\033[0m\\\".format(names[i])\\r\\n else:\\r\\n formatted_name = \\\"\\\\033[91m {0} \\\\033[0m\\\".format(names[i])\\r\\n r = '%.6f' % float(ratio)\\r\\n d = '%.6f' % float(difference)\\r\\n g = '%.6f' % gradient\\r\\n ng = '%.6f' % float(numerical_gradient)\\r\\n grad_string = \\\"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\\\".format(formatted_name, r, d, g, ng, c0=cols[0] + 9, c1=cols[1], c2=cols[2], c3=cols[3], c4=cols[4])\\r\\n print grad_string\",\n \"def fit(self, start_params=None, method='newton', maxiter=100,\\n full_output=True, disp=True, fargs=(), callback=None, retall=False,\\n skip_hessian=False, **kwargs):\\n Hinv = None # JP error if full_output=0, Hinv not defined\\n\\n start_params = self._get_start_params(start_params)\\n\\n # TODO: separate args from nonarg taking score and hessian, ie.,\\n # user-supplied and numerically evaluated estimate frprime doesn't take\\n # args in most (any?) of the optimize function\\n\\n nobs = self.endog.shape[0]\\n # f = lambda params, *args: -self.loglike(params, *args) / nobs\\n\\n def f(params, *args):\\n return -self.loglike(params, *args) / nobs\\n\\n if method == 'newton':\\n # TODO: why are score and hess positive?\\n def score(params, *args):\\n return self.score(params, *args) / nobs\\n\\n def hess(params, *args):\\n return self.hessian(params, *args) / nobs\\n else:\\n def score(params, *args):\\n return -self.score(params, *args) / nobs\\n\\n def hess(params, *args):\\n return -self.hessian(params, *args) / nobs\\n\\n warn_convergence = kwargs.pop('warn_convergence', True)\\n optimizer = Optimizer()\\n xopt, retvals, optim_settings = optimizer._fit(f, score, start_params,\\n fargs, kwargs,\\n hessian=hess,\\n method=method,\\n disp=disp,\\n maxiter=maxiter,\\n callback=callback,\\n retall=retall,\\n full_output=full_output)\\n\\n # NOTE: this is for fit_regularized and should be generalized\\n cov_params_func = kwargs.setdefault('cov_params_func', None)\\n if cov_params_func:\\n Hinv = cov_params_func(self, xopt, retvals)\\n elif method == 'newton' and full_output:\\n Hinv = np.linalg.inv(-retvals['Hessian']) / nobs\\n # TODO: try/except for non-invertible hessian?\\n elif not skip_hessian:\\n H = -1 * self.hessian(xopt)\\n invertible = False\\n if np.all(np.isfinite(H)):\\n eigvals, eigvecs = np.linalg.eigh(H)\\n if np.min(eigvals) > 0:\\n invertible = True\\n\\n if invertible:\\n Hinv = eigvecs.dot(np.diag(1.0 / eigvals)).dot(eigvecs.T)\\n Hinv = np.asfortranarray((Hinv + Hinv.T) / 2.0)\\n else:\\n warnings.warn('Inverting hessian failed, no bse or cov_params '\\n 'available', HessianInversionWarning)\\n Hinv = None\\n\\n if 'cov_type' in kwargs:\\n cov_kwds = kwargs.get('cov_kwds', {})\\n kwds = {'cov_type': kwargs['cov_type'], 'cov_kwds': cov_kwds}\\n else:\\n kwds = {}\\n if 'use_t' in kwargs:\\n kwds['use_t'] = kwargs['use_t']\\n # TODO: add Hessian approximation and change the above if needed\\n mlefit = LikelihoodModelResults(self, xopt, Hinv, scale=1., **kwds)\\n\\n # TODO: hardcode scale?\\n if isinstance(retvals, dict):\\n mlefit.mle_retvals = retvals\\n if warn_convergence and not retvals['converged']:\\n warnings.warn(\\\"Maximum Likelihood optimization failed to \\\"\\n \\\"converge. Check mle_retvals\\\",\\n ConvergenceWarning)\\n\\n mlefit.mle_settings = optim_settings\\n return mlefit\",\n \"def _optimize(optimizer, regularization_losses, scope, **kwargs):\\n sum_loss = _gather_loss(regularization_losses, scope)\\n grad = None\\n if sum_loss is not None:\\n grad = optimizer.compute_gradients(sum_loss, **kwargs)\\n return sum_loss, grad\",\n \"def minimize(fun, \\n bounds = None, \\n value_limit = math.inf,\\n num_retries = 1000,\\n logger = None,\\n workers = mp.cpu_count(),\\n popsize = 31, \\n max_evaluations = 50000, \\n capacity = 500,\\n stop_fittness = None,\\n optimizer = None,\\n ):\\n\\n if optimizer is None:\\n optimizer = de_cma(max_evaluations, popsize, stop_fittness) \\n store = Store(bounds, capacity = capacity, logger = logger)\\n return retry(fun, store, optimizer.minimize, num_retries, value_limit, workers)\",\n \"def minimizer(f, x, optimizer, grad_f, hess_f=None,\\n args=(),\\n maxiter=None, tol=1e-5,\\n stepsize=1, adaptive=True,\\n bounds=None,\\n disp=False):\\n min_obj = {'steepest': SteepestDescent,\\n 'conjugate': ConjugateDescent,\\n 'newton': NewtonDescent,\\n 'cg': ScipyCG,\\n 'ncg': ScipyNCG,\\n 'bfgs': ScipyBFGS,\\n 'lbfgs': ScipyLBFGS}\\n\\n if optimizer not in min_obj.keys():\\n raise ValueError('unknown optimizer')\\n local_meth = optimizer in ('steepest', 'conjugate', 'newton')\\n\\n if local_meth:\\n proj = None\\n if not bounds is None:\\n if callable(bounds):\\n proj = bounds\\n else:\\n proj = bounds_to_proj(bounds)\\n\\n return min_obj[optimizer](f, x, grad_f, hess_f=hess_f,\\n maxiter=maxiter, tol=tol,\\n stepsize=stepsize, adaptive=adaptive,\\n proj=proj)\\n\\n if not bounds is None and optimizer != 'lbfgs':\\n raise NotImplementedError('%s optimization method does not accept constraints' % optimizer)\\n \\n return min_obj[optimizer](f, x, grad_f, hess_f=hess_f,\\n maxiter=maxiter, tol=tol,\\n bounds=bounds, disp=disp)\",\n \"def run_step_blackbox_optimizer(config,\\n current_input,\\n blackbox_optimizer,\\n proposed_perturbations,\\n finished_dnas,\\n results,\\n logging_data=None):\\n core_hyperparameters = blackbox_optimizer.get_hyperparameters()\\n function_values = [0.0] * len(proposed_perturbations)\\n rewards_for_controller = []\\n perturbations = proposed_perturbations\\n evaluation_stats = []\\n current_value_exact = 0.0\\n current_value_exact_counter = 0\\n\\n for i in range(len(results)):\\n rewards_for_controller.append(results[i]['function_value'])\\n tag = results[i]['tag']\\n index = 0\\n if tag > 0:\\n if config.est_type == 'antithetic':\\n index = (tag - 1) * 2\\n function_values[index] += results[i]['function_value']\\n else:\\n index = tag - 1\\n function_values[index] += results[i]['function_value']\\n if tag < 0:\\n index = (-tag - 1) * 2 + 1\\n function_values[index] += results[i]['function_value']\\n if tag == 0:\\n current_value_exact += results[i]['function_value']\\n current_value_exact_counter += 1\\n current_value_exact /= float(current_value_exact_counter)\\n\\n for result in results:\\n evaluation_stat = list(result['evaluation_stat'])\\n evaluation_stats.append(evaluation_stat)\\n\\n function_values_reshaped = np.array(function_values)\\n perturbations_reshaped = np.array(perturbations)\\n\\n logging.info('LIST OF FUNCTION VALUES')\\n logging.info(function_values_reshaped)\\n\\n logging.info('MAX VALUE SEEN CURRENTLY')\\n logging.info(np.max(function_values_reshaped))\\n\\n logging.info('MEAN OF VALUES')\\n logging.info(np.mean(function_values_reshaped))\\n\\n if logging_data is not None:\\n iteration = logging_data['iteration']\\n best_value = logging_data['best_value']\\n iteration = logging_data['iteration']\\n best_input = logging_data['best_input']\\n best_core_hyperparameters = logging_data['best_core_hyperparameters']\\n optimizer_state = blackbox_optimizer.get_state()\\n\\n if current_value_exact > best_value[0]:\\n best_value[0] = current_value_exact\\n best_input = current_input\\n best_core_hyperparameters = core_hyperparameters\\n\\n # Writing logs.\\n if iteration % config.log_frequency == 0:\\n util.log_row(config.params_file, current_input)\\n util.log_row(config.best_params_file, best_input)\\n util.log_row(config.best_core_hyperparameters_file,\\n best_core_hyperparameters)\\n util.log_row(config.best_value_file, best_value)\\n util.log_row(config.optimizer_internal_state_file, optimizer_state)\\n util.log_row(config.current_values_list_file, [current_value_exact])\\n util.log_row(config.best_values_list_file, [best_value[0]])\\n util.log_row(config.fvalues_file, function_values_reshaped)\\n util.log_row(config.iteration_file, [iteration])\\n\\n print('Current exact value estimate:')\\n print(current_value_exact)\\n sys.stdout.flush()\\n\\n new_current_input = blackbox_optimizer.run_step(perturbations_reshaped,\\n function_values_reshaped,\\n current_input,\\n current_value_exact)\\n config.controller.collect_rewards_and_train(rewards_for_controller,\\n finished_dnas)\\n\\n evaluation_stats_reduced = [sum(x) for x in zip(*evaluation_stats)]\\n blackbox_optimizer.update_state(evaluation_stats_reduced)\\n\\n return [True, new_current_input]\",\n \"def solve(self, **kwargs) -> OptimizationResult:\\n raise NotImplementedError\",\n \"def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\\r\\n\\r\\n\\t\\r\\n\\tif grad == 'NO':\\r\\n\\t\\tif method == 'Powell' :\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'Nelder-Mead':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t options = {'ftol': 0.0001})\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'default':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, \\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\r\\n\\telif grad == 'YES':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \\r\\n \\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\\r\\n\\t\\treturn res.x, res.nit \\r\\n\\t\\t\\t\\r\\n\\t\\t\\r\\n\\telif grad == 'HESS':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\\r\\n\\t\\t\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t\\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \\r\\n\\t\\treturn res.x, res.nit\",\n \"def _optfn(self, x):\\n\\n logger.debug(\\\" optfn(theta=%s)\\\", str(x))\\n\\n wmx = max(self.weights) * self.weighttrunc\\n\\n ip = []\\n for i,w in enumerate(self.weights):\\n if w < wmx:\\n continue\\n ip.append((i,w,x))\\n\\n if self.pool is None:\\n itr = map(self.worker.loglik_grad, ip)\\n else:\\n itr = self.pool.imap_unordered(_pool_loglik_grad, ip, 10)\\n\\n if self._prior_shape is None:\\n ll = 0.\\n grad = np.zeros(len(x))\\n else:\\n ll = sum(sp.special.xlogy(self._prior_shape-1,x)-(x/self._prior_scale))\\n grad = (self._prior_shape - 1)/x - 1/self._prior_scale\\n\\n for l,g in itr:\\n ll += l\\n grad += g\\n\\n logger.debug(\\\" optfn=%g\\\", ll)\\n\\n return -ll, -grad\",\n \"def inner(*args, **kwargs):\\n current_var_scope = variable_scope.get_variable_scope()\\n with record.stop_recording():\\n result = f(*args, **kwargs)\\n\\n def grad_wrapper(*wrapper_args, variables=None):\\n \\\"\\\"\\\"Wrapper function to accomodate lack of kwargs in graph mode custom_gradient.\\\"\\\"\\\"\\n\\n @custom_gradient\\n def inner_recompute_grad(*dresult):\\n \\\"\\\"\\\"Nested custom gradient function for computing grads in reverse and forward mode autodiff.\\\"\\\"\\\"\\n # Gradient calculation for reverse mode autodiff.\\n with backprop.GradientTape() as t:\\n id_args = nest.map_structure(gen_array_ops.identity, args)\\n # Tuple `dresult` should contain at least one tensor.\\n assert len(dresult) >= 1\\n\\n if not context.executing_eagerly():\\n # XLA doesn't respect `tf.control_dependencies`. The code block\\n # below manually adds a data dependency to `dresult` to ensure\\n # recomputation of `f(*args, **kwargs)` happens after `dresult`.\\n\\n # This works even if `dresult[0]` is a size 0 tensor as reduce_max\\n # of a size 0 tensor returns -inf. Use reshape here to avoid reading\\n # the entire `dresult[0]`.\\n elem = math_ops.reduce_max(array_ops.reshape(dresult[0], [-1])[:1])\\n # Cast elem to bool in case elem is NaN.\\n elem_bool = math_ops.cast(elem, dtypes.bool)\\n dresult_dep = array_ops.where_v2(\\n elem_bool == elem_bool, 0., float(\\\"nan\\\")) # pylint: disable=comparison-with-itself\\n id_args = nest.map_structure(\\n lambda x: x + math_ops.cast(dresult_dep, x.dtype), id_args)\\n\\n t.watch(id_args)\\n if variables is not None:\\n t.watch(variables)\\n with variable_scope.variable_scope(current_var_scope):\\n recomputed_result = f(*id_args, **kwargs)\\n kw_vars = []\\n if variables is not None:\\n kw_vars = list(variables)\\n grads = t.gradient(\\n recomputed_result,\\n list(id_args) + kw_vars,\\n output_gradients=dresult,\\n unconnected_gradients=UnconnectedGradients.ZERO)\\n\\n def transpose(*t_args, **t_kwargs):\\n \\\"\\\"\\\"Gradient function calculation for forward mode autodiff.\\\"\\\"\\\"\\n # Just throw an error since gradients / activations are not stored on\\n # tape for recompute.\\n raise NotImplementedError(\\n \\\"recompute_grad tried to transpose grad of {}. \\\"\\n \\\"Consider not using recompute_grad in forward mode\\\"\\n \\\"autodiff\\\".format(f.__name__))\\n\\n return (grads[:len(id_args)], grads[len(id_args):]), transpose\\n\\n return inner_recompute_grad(*wrapper_args)\\n\\n return result, grad_wrapper\",\n \"def _get_step_fn(self) -> Callable:\\n\\n def loss_fn(\\n params: frozen_dict.FrozenDict,\\n apply_fn: Callable,\\n batch: Dict[str, jnp.ndarray],\\n ) -> Tuple[float, Dict[str, float]]:\\n \\\"\\\"\\\"Loss function.\\\"\\\"\\\"\\n # map samples with the fitted map\\n mapped_samples = apply_fn({\\\"params\\\": params}, batch[\\\"source\\\"])\\n\\n # compute the loss\\n val_fitting_loss = self.fitting_loss(batch[\\\"target\\\"], mapped_samples)\\n val_regularizer = self.regularizer(batch[\\\"source\\\"], mapped_samples)\\n val_tot_loss = (\\n val_fitting_loss + self.regularizer_strength * val_regularizer\\n )\\n\\n # store training logs\\n loss_logs = {\\n \\\"total_loss\\\": val_tot_loss,\\n \\\"fitting_loss\\\": val_fitting_loss,\\n \\\"regularizer\\\": val_regularizer\\n }\\n\\n return val_tot_loss, loss_logs\\n\\n @functools.partial(jax.jit, static_argnums=3)\\n def step_fn(\\n state_neural_net: train_state.TrainState,\\n train_batch: Dict[str, jnp.ndarray],\\n valid_batch: Optional[Dict[str, jnp.ndarray]] = None,\\n is_logging_step: bool = False,\\n ) -> Tuple[train_state.TrainState, Dict[str, float]]:\\n \\\"\\\"\\\"Step function.\\\"\\\"\\\"\\n # compute loss and gradients\\n grad_fn = jax.value_and_grad(loss_fn, argnums=0, has_aux=True)\\n (_, current_train_logs), grads = grad_fn(\\n state_neural_net.params, state_neural_net.apply_fn, train_batch\\n )\\n\\n # logging step\\n current_logs = {\\\"train\\\": current_train_logs, \\\"eval\\\": {}}\\n if is_logging_step:\\n _, current_eval_logs = loss_fn(\\n params=state_neural_net.params,\\n apply_fn=state_neural_net.apply_fn,\\n batch=valid_batch\\n )\\n current_logs[\\\"eval\\\"] = current_eval_logs\\n\\n # update state\\n return state_neural_net.apply_gradients(grads=grads), current_logs\\n\\n return step_fn\",\n \"def recompute_grad(f):\\n # TODO(cdfreeman) Add is_recomputing functionality from graph mode version\\n\\n @custom_gradient\\n def inner(*args, **kwargs):\\n \\\"\\\"\\\"Inner function closure for calculating gradients.\\\"\\\"\\\"\\n current_var_scope = variable_scope.get_variable_scope()\\n with record.stop_recording():\\n result = f(*args, **kwargs)\\n\\n def grad_wrapper(*wrapper_args, variables=None):\\n \\\"\\\"\\\"Wrapper function to accomodate lack of kwargs in graph mode custom_gradient.\\\"\\\"\\\"\\n\\n @custom_gradient\\n def inner_recompute_grad(*dresult):\\n \\\"\\\"\\\"Nested custom gradient function for computing grads in reverse and forward mode autodiff.\\\"\\\"\\\"\\n # Gradient calculation for reverse mode autodiff.\\n with backprop.GradientTape() as t:\\n id_args = nest.map_structure(gen_array_ops.identity, args)\\n # Tuple `dresult` should contain at least one tensor.\\n assert len(dresult) >= 1\\n\\n if not context.executing_eagerly():\\n # XLA doesn't respect `tf.control_dependencies`. The code block\\n # below manually adds a data dependency to `dresult` to ensure\\n # recomputation of `f(*args, **kwargs)` happens after `dresult`.\\n\\n # This works even if `dresult[0]` is a size 0 tensor as reduce_max\\n # of a size 0 tensor returns -inf. Use reshape here to avoid reading\\n # the entire `dresult[0]`.\\n elem = math_ops.reduce_max(array_ops.reshape(dresult[0], [-1])[:1])\\n # Cast elem to bool in case elem is NaN.\\n elem_bool = math_ops.cast(elem, dtypes.bool)\\n dresult_dep = array_ops.where_v2(\\n elem_bool == elem_bool, 0., float(\\\"nan\\\")) # pylint: disable=comparison-with-itself\\n id_args = nest.map_structure(\\n lambda x: x + math_ops.cast(dresult_dep, x.dtype), id_args)\\n\\n t.watch(id_args)\\n if variables is not None:\\n t.watch(variables)\\n with variable_scope.variable_scope(current_var_scope):\\n recomputed_result = f(*id_args, **kwargs)\\n kw_vars = []\\n if variables is not None:\\n kw_vars = list(variables)\\n grads = t.gradient(\\n recomputed_result,\\n list(id_args) + kw_vars,\\n output_gradients=dresult,\\n unconnected_gradients=UnconnectedGradients.ZERO)\\n\\n def transpose(*t_args, **t_kwargs):\\n \\\"\\\"\\\"Gradient function calculation for forward mode autodiff.\\\"\\\"\\\"\\n # Just throw an error since gradients / activations are not stored on\\n # tape for recompute.\\n raise NotImplementedError(\\n \\\"recompute_grad tried to transpose grad of {}. \\\"\\n \\\"Consider not using recompute_grad in forward mode\\\"\\n \\\"autodiff\\\".format(f.__name__))\\n\\n return (grads[:len(id_args)], grads[len(id_args):]), transpose\\n\\n return inner_recompute_grad(*wrapper_args)\\n\\n return result, grad_wrapper\\n\\n return tf_decorator.make_decorator(f, inner)\",\n \"def minimize_batch(target_fn, gradient_fn, theta_0, tolerance=0.00001):\\n\\n step_sizes = [100, 10, 1, 0.1, 0.01, 0.001, 0.0001, 0.00001]\\n\\n theta = theta_0 # set theta to initial value\\n target_fn = safe(target_fn) # safe version of target_fn\\n value = target_fn(theta) # value we're minimizing\\n\\n while True:\\n gradient = gradient_fn(theta)\\n next_thetas = [step(theta, gradient, -step_size)\\n for step_size in step_sizes]\\n # choose the one that minimizes the error function\\n next_theta = min(next_thetas, key=target_fn)\\n next_value = target_fn(next_theta)\\n\\n # stop if we're \\\"converging\\\"\\n if abs(value - next_value) < tolerance:\\n return theta\\n else:\\n theta, value = next_theta, next_value\",\n \"def optimize(self, input_val_dict):\\n logger.log(\\\"Start CG optimization\\\")\\n\\n logger.log(\\\"computing loss before\\\")\\n loss_before = self.loss(input_val_dict)\\n\\n logger.log(\\\"performing update\\\")\\n\\n logger.log(\\\"computing gradient\\\")\\n gradient = self.gradient(input_val_dict)\\n logger.log(\\\"gradient computed\\\")\\n\\n logger.log(\\\"computing descent direction\\\")\\n Hx = self._hvp_approach.build_eval(input_val_dict)\\n descent_direction = conjugate_gradients(Hx, gradient, cg_iters=self._cg_iters)\\n\\n initial_step_size = np.sqrt(2.0 * self._max_constraint_val *\\n (1. / (descent_direction.dot(Hx(descent_direction)) + 1e-8)))\\n if np.isnan(initial_step_size):\\n logger.log(\\\"Initial step size is NaN! Rejecting the step!\\\")\\n return\\n\\n initial_descent_step = initial_step_size * descent_direction\\n logger.log(\\\"descent direction computed\\\")\\n\\n prev_params = self._target.get_param_values()\\n prev_params_values = _flatten_params(prev_params)\\n\\n loss, constraint_val, n_iter, violated = 0, 0, 0, False\\n for n_iter, ratio in enumerate(self._backtrack_ratio ** np.arange(self._max_backtracks)):\\n cur_step = ratio * initial_descent_step\\n cur_params_values = prev_params_values - cur_step\\n cur_params = _unflatten_params(cur_params_values, params_example=prev_params)\\n self._target.set_params(cur_params)\\n\\n loss, constraint_val = self.loss(input_val_dict), self.constraint_val(input_val_dict)\\n if loss < loss_before and constraint_val <= self._max_constraint_val:\\n break\\n\\n \\\"\\\"\\\" ------------------- Logging Stuff -------------------------- \\\"\\\"\\\"\\n if np.isnan(loss):\\n violated = True\\n logger.log(\\\"Line search violated because loss is NaN\\\")\\n if np.isnan(constraint_val):\\n violated = True\\n logger.log(\\\"Line search violated because constraint %s is NaN\\\" % self._constraint_name)\\n if loss >= loss_before:\\n violated = True\\n logger.log(\\\"Line search violated because loss not improving\\\")\\n if constraint_val >= self._max_constraint_val:\\n violated = True\\n logger.log(\\\"Line search violated because constraint %s is violated\\\" % self._constraint_name)\\n\\n if violated and not self._accept_violation:\\n logger.log(\\\"Line search condition violated. Rejecting the step!\\\")\\n self._target.set_params(prev_params)\\n\\n logger.log(\\\"backtrack iters: %d\\\" % n_iter)\\n logger.log(\\\"computing loss after\\\")\\n logger.log(\\\"optimization finished\\\")\",\n \"def train_step(\\n self, inputs: Dict[str, torch.Tensor], targets: Dict[str, torch.Tensor], should_step: bool = True\\n ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor]]:\\n if isinstance(self.optimizer, torch.optim.LBFGS):\\n # NOTE: Horovod is not supported for L-BFGS.\\n # NOTE: AMP is not supported for L-BFGS yet.\\n # NOTE: gradient accumulation is not supported for L-BFGS yet.\\n\\n def closure():\\n # Allows L-BFGS to reevaluate the loss function\\n self.distributed.zero_grad(self.optimizer)\\n model_outputs = self.dist_model((inputs, targets))\\n loss, _ = self.model.train_loss(\\n targets, model_outputs, self.regularization_type, self.regularization_lambda\\n )\\n loss.backward()\\n return loss\\n\\n self.distributed.step(self.optimizer, closure)\\n\\n # Obtain model predictions and loss\\n model_outputs = self.dist_model((inputs, targets))\\n loss, all_losses = self.model.train_loss(\\n targets, model_outputs, self.regularization_type, self.regularization_lambda\\n )\\n\\n if not self.evaluate_training_set:\\n # Update evaluation metrics with current model params:\\n # noisy but fast way to get metrics on the training set\\n predictions = self.model.outputs_to_predictions(model_outputs)\\n self.model.update_metrics(targets, predictions)\\n\\n return loss, all_losses\\n\\n with torch.cuda.amp.autocast() if self.use_amp else contextlib.nullcontext():\\n with self.distributed.prepare_model_update(self.dist_model, should_step=should_step):\\n # Obtain model predictions and loss\\n model_outputs = self.dist_model((inputs, targets))\\n loss, all_losses = self.model.train_loss(\\n targets, model_outputs, self.regularization_type, self.regularization_lambda\\n )\\n loss = loss / self.gradient_accumulation_steps\\n\\n # Begin the backward pass\\n variables = self.dist_model.parameters()\\n if self.use_amp:\\n self.scaler.scale(loss).backward()\\n else:\\n self.distributed.backward(loss, self.dist_model)\\n\\n if not should_step:\\n # Short-circuit the parameter updates if we are still accumulating gradients\\n return loss, all_losses\\n\\n # Wait for gradient aggregation to complete before clipping the gradients\\n # When using AMP, we need to do this before unscaling.\\n # See: https://github.com/horovod/horovod/blob/master/examples/pytorch/pytorch_mnist.py\\n self.distributed.wait_optimizer_synced(self.optimizer)\\n\\n if self.use_amp:\\n # In-place unscaling of all gradients before weights update\\n # Do this before gradient clipping per docs:\\n # https://pytorch.org/docs/master/notes/amp_examples.html#gradient-clipping\\n self.scaler.unscale_(self.optimizer)\\n\\n if self.distributed.allow_clip_gradients():\\n # Clip gradients\\n self.clip_grads(variables)\\n\\n # Apply gradient updates\\n with self.distributed.prepare_optimizer_update(self.optimizer):\\n # Because we already synchronized above, we skip doing so here\\n if self.use_amp:\\n self.scaler.step(self.optimizer)\\n else:\\n self.distributed.step(self.optimizer)\\n\\n if self.use_amp:\\n # Update scaler in case of overflow/underflow\\n self.scaler.update()\\n\\n if not self.evaluate_training_set:\\n # Update evaluation metrics with current model params:\\n # noisy but fast way to get metrics on the training set\\n predictions = self.model.outputs_to_predictions(model_outputs)\\n self.model.update_metrics(targets, predictions)\\n\\n self.distributed.zero_grad(self.optimizer)\\n\\n return loss, all_losses\",\n \"def hyperopt_fmin(\\n fn,\\n space,\\n algo,\\n max_evals=sys.maxsize,\\n timeout=None,\\n loss_threshold=None,\\n trials=None,\\n rstate=None,\\n allow_trials_fmin=True,\\n pass_expr_memo_ctrl=None,\\n catch_eval_exceptions=False,\\n verbose=True,\\n return_argmin=True,\\n points_to_evaluate=None,\\n max_queue_len=1,\\n show_progressbar=True,\\n # early_stop_fn=None,\\n):\\n if rstate is None:\\n env_rseed = os.environ.get(\\\"HYPEROPT_FMIN_SEED\\\", \\\"\\\")\\n if env_rseed:\\n rstate = np.random.RandomState(int(env_rseed))\\n else:\\n rstate = np.random.RandomState()\\n\\n validate_timeout(timeout)\\n validate_loss_threshold(loss_threshold)\\n\\n if allow_trials_fmin and hasattr(trials, \\\"fmin\\\"):\\n assert False\\n # return trials.fmin(\\n # fn,\\n # space,\\n # algo=algo,\\n # max_evals=max_evals,\\n # timeout=timeout,\\n # loss_threshold=loss_threshold,\\n # max_queue_len=max_queue_len,\\n # rstate=rstate,\\n # pass_expr_memo_ctrl=pass_expr_memo_ctrl,\\n # verbose=verbose,\\n # catch_eval_exceptions=catch_eval_exceptions,\\n # return_argmin=return_argmin,\\n # show_progressbar=show_progressbar,\\n # early_stop_fn=early_stop_fn,\\n # )\\n\\n if trials is None:\\n if points_to_evaluate is None:\\n trials = base.Trials()\\n else:\\n assert type(points_to_evaluate) == list\\n trials = generate_trials_to_calculate(points_to_evaluate)\\n\\n domain = base.Domain(fn, space, pass_expr_memo_ctrl=pass_expr_memo_ctrl)\\n\\n rval = FMinIter(\\n algo,\\n domain,\\n trials,\\n max_evals=max_evals,\\n timeout=timeout,\\n loss_threshold=loss_threshold,\\n rstate=rstate,\\n verbose=verbose,\\n max_queue_len=max_queue_len,\\n show_progressbar=show_progressbar,\\n # early_stop_fn=early_stop_fn,\\n )\\n rval.catch_eval_exceptions = catch_eval_exceptions\\n\\n # next line is where the fmin is actually executed\\n rval.exhaust()\\n\\n if len(trials.trials) == 0:\\n raise Exception(\\n \\\"There are no evaluation tasks, cannot return argmin of task losses.\\\"\\n )\\n return trials\",\n \"def optimize(self, iterations=1000):\\r\\n prev = None\\r\\n finalx = None\\r\\n finaly = None\\r\\n while iterations:\\r\\n maxei, eis = self.acquisition()\\r\\n new_y = self.f(maxei)\\r\\n if maxei == prev:\\r\\n break\\r\\n self.gp.update(maxei, new_y)\\r\\n pycodehack = finaly is None or self.minimize and finaly > new_y\\r\\n if ((pycodehack or not self.minimize and finaly < new_y)):\\r\\n finaly = new_y\\r\\n finalx = maxei\\r\\n prev = maxei\\r\\n iterations -= 1\\r\\n return finalx, finaly\",\n \"def calc_gradient(self):\\n \\n self.setup()\\n\\n # Create our 2D dictionary the first time we execute.\\n if not self.gradient:\\n for name in self.param_names:\\n self.gradient[name] = {}\\n \\n # Pull initial state and stepsizes from driver's parameters\\n base_param = OrderedDict()\\n stepsize = {}\\n for key, item in self._parent.get_parameters().iteritems():\\n base_param[key] = item.evaluate()\\n \\n if item.fd_step:\\n stepsize[key] = item.fd_step\\n else:\\n stepsize[key] = self.default_stepsize\\n\\n # For Forward or Backward diff, we want to save the baseline\\n # objective and constraints. These are also needed for the\\n # on-diagonal Hessian terms, so we will save them in the class\\n # later.\\n base_data = self._run_point(base_param)\\n \\n # Set up problem based on Finite Difference type\\n if self.form == 'central':\\n deltas = [1, -1]\\n func = diff_1st_central\\n elif self.form == 'forward':\\n deltas = [1, 0]\\n func = diff_1st_fwrdbwrd\\n else:\\n deltas = [0, -1]\\n func = diff_1st_fwrdbwrd\\n\\n self.gradient_case = OrderedDict()\\n\\n # Assemble input data\\n for param in self.param_names:\\n \\n pcase = []\\n for j_step, delta in enumerate(deltas):\\n \\n case = base_param.copy()\\n case[param] += delta*stepsize[param]\\n pcase.append({ 'param': case })\\n \\n self.gradient_case[param] = pcase\\n \\n # Run all \\\"cases\\\".\\n # TODO - Integrate OpenMDAO's concurrent processing capability once it\\n # is formalized. This operation is inherently paralellizable.\\n for key, case in self.gradient_case.iteritems():\\n for ipcase, pcase in enumerate(case):\\n if deltas[ipcase]:\\n pcase['data'] = self._run_point(pcase['param'])\\n else:\\n pcase['data'] = base_data\\n \\n \\n # Calculate gradients\\n for key, case in self.gradient_case.iteritems():\\n \\n eps = stepsize[key]\\n \\n for name in list(self.objective_names + \\\\\\n self.eqconst_names + \\\\\\n self.ineqconst_names):\\n self.gradient[key][name] = \\\\\\n func(case[0]['data'][name],\\n case[1]['data'][name], eps)\\n\\n # Save these for Hessian calculation\\n self.base_param = base_param\\n self.base_data = base_data\",\n \"def hmc(f, x, gradf,\\n args=(),\\n display=False,\\n checkgrad=False,\\n steps=1,\\n nsamples=1,\\n nomit=0,\\n persistence=False,\\n decay=0.9,\\n stepadj=0.2,\\n window=1,\\n use_cython=True,\\n return_energies=False,\\n return_diagnostics=False,\\n ):\\n global HMC_MOM\\n\\n # check some options\\n assert steps >= 1, 'step size has to be >= 1'\\n assert nsamples >= 1, 'nsamples has to be >= 1'\\n assert nomit >= 0, 'nomit has to be >= 0'\\n assert decay >= 0, 'decay has to be >= 0'\\n assert decay <= 1, 'decay has to be <= 1'\\n assert window >= 0, 'window has to be >= 0'\\n if window > steps:\\n window = steps\\n if display:\\n print \\\"setting window size to step size %d\\\" % window\\n\\n if persistence:\\n alpha = decay\\n salpha = np.sqrt(1-alpha**2);\\n else:\\n alpha = salpha = 0.\\n\\n nparams = len(x)\\n epsilon = stepadj\\n\\n # Check the gradient evaluation.\\n if checkgrad:\\n # Check gradients\\n error = check_grad(f, gradf, x, *args)\\n if display:\\n print \\\"Energy gradient error: %f\\\"%error\\n return error\\n\\n # Initialize matrix of returned samples\\n samples = np.zeros((nsamples, nparams))\\n\\n # Return energies?\\n if return_energies:\\n energies = np.zeros(nsamples)\\n else:\\n energies = np.zeros(0)\\n\\n # Return diagnostics?\\n if return_diagnostics:\\n diagn_pos = np.zeros((nsamples, nparams))\\n diagn_mom = np.zeros((nsamples, nparams))\\n diagn_acc = np.zeros(nsamples)\\n else:\\n diagn_pos = np.zeros((0,0))\\n diagn_mom = np.zeros((0,0))\\n diagn_acc = np.zeros(0)\\n\\n if not persistence or HMC_MOM is None or nparams != len(HMC_MOM):\\n # Initialise momenta at random\\n p = np.random.randn(nparams)\\n else:\\n # Initialise momenta from stored state\\n p = HMC_MOM\\n \\n # Main loop.\\n all_args = [f,\\n x,\\n gradf,\\n args,\\n p,\\n samples,\\n energies,\\n diagn_pos,\\n diagn_mom,\\n diagn_acc,\\n nsamples,\\n nomit,\\n window,\\n steps,\\n display,\\n persistence,\\n return_energies,\\n return_diagnostics,\\n alpha,\\n salpha,\\n epsilon]\\n\\n if use_cython:\\n try:\\n os.environ['C_INCLUDE_PATH']=np.get_include()\\n import pyximport; pyximport.install()\\n from hmc2x import hmc_main_loop as c_hmc_main_loop\\n if display:\\n print \\\"Using compiled code\\\"\\n nreject = c_hmc_main_loop(*all_args)\\n except:\\n if display:\\n print \\\"Using pure python code\\\"\\n nreject = hmc_main_loop(*all_args)\\n else:\\n if display:\\n print \\\"Using pure python code\\\"\\n nreject = hmc_main_loop(*all_args)\\n\\n if display:\\n if display:\\n print '\\\\nFraction of samples rejected: %g\\\\n'%(nreject/float(nsamples))\\n\\n # Store diagnostics\\n if return_diagnostics:\\n diagn = dict()\\n diagn['pos'] = diagn_pos # positions matrix\\n diagn['mom'] = diagn_mom # momentum matrix\\n diagn['acc'] = diagn_acc # acceptance treshold matrix\\n diagn['rej'] = nreject/float(nsamples) # rejection rate\\n diagn['stps'] = epsilon # stepsize vector\\n\\n # Store final momentum value in global so that it can be retrieved later\\n if persistence:\\n HMC_MOM = p\\n else:\\n HMC_MOM = None\\n\\n if return_energies or return_diagnostics:\\n out = (samples,)\\n else:\\n return samples\\n \\n if return_energies: out += (energies,)\\n if return_diagnostics: out += (diagn,)\\n return out\",\n \"def update(self, max_norm=1.0):\\n \\n theta_prime = []\\n\\n for i, batch in enumerate(self.tasks):\\n y_hat = self.constraint(self.theta, self.f(batch)) # gather predictions to single dimension\\n loss = self.criteon( y_hat, self.y )\\n #compute gradients\\n grad = torch.autograd.grad(loss, self.theta)\\n #update params\\n theta_prime.append( self.theta - self.alpha * grad[0] )\\n\\n del loss\\n\\n #perform meta-update\\n m_loss = torch.tensor(0.0, requires_grad=True)\\n for i in range(len(self.tasks)):\\n theta = theta_prime[i]\\n batch = self.tasks[i]\\n y_hat = self.constraint(theta, self.f(batch)) # gather predictions to single dimension\\n m_loss = m_loss + self.criteon( y_hat, self.y ) # updating meta-loss\\n \\n #zero gradient before running backward pass\\n self.meta_optim.zero_grad()\\n\\n #backward pass\\n m_loss.backward(retain_graph=True)\\n\\n #clip gradients\\n nn.utils.clip_grad_norm_([self.theta], max_norm)\\n \\n #one-step gradient descent\\n self.meta_optim.step()\",\n \"def cost_lm(params, m, optimize=True, plot=False, initial_cost = False, order = None, **kwargs):\\n optimization_dictionary = {'nelder-mead': Optimization.fmin_log_params,\\n 'levenburg-marquardt least square': Optimization.leastsq_log_params,\\n 'levenburg-marquardt': Optimization.fmin_lm_log_params}\\n return_dictionary = {}\\n try:\\n plot_after = kwargs.pop('plot_after')\\n except KeyError:\\n plot_after = False\\n if initial_cost:\\n initial_cost = m.cost(params)\\n print(('Initial Cost:', initial_cost))\\n try:\\n if kwargs.pop('plot_before'):\\n initial_plot = Plotting.figure()\\n\\n f=Plotting.plot_model_results(m)\\n Plotting.title('Before Optimization')\\n return_dictionary[\\\"initial\\\"] = initial_plot\\n except KeyError:\\n pass\\n if optimize:\\n order.reverse()\\n new_params = params.copy()\\n for opt in order:\\n routine_dict_n = routine_dict_drier(opt.attrib)\\n try:\\n opt_type = routine_dict_n.pop('type').lower()\\n except KeyError:\\n opt_type = 'levenburg-marquardt'\\n new_params = optimization_dictionary[opt_type](m, new_params, **routine_dict_n)\\n optimized_cost = m.cost(new_params)\\n params = new_params\\n print(('Optimized cost:', optimized_cost))\\n # print 'Optimized parameters:', params\\n\\n if plot or plot_after:\\n if not optimize:\\n optimized_cost = m.cost(params)\\n print(('Optimized cost:', optimized_cost))\\n print(('Optimized parameters:', params))\\n Plotting.figure()\\n f=Plotting.plot_model_results(m)\\n for thing in f[0]:\\n thing.set_alpha(.7)\\n\\n Plotting.title('After Optimization')\\n return_dictionary[\\\"params\\\"] = params\\n return return_dictionary\",\n \"def gradient_descent(x0,df,rate=0.1,max_iters=1000,min_step=1e-6,max_step=1e5,\\n projection=None,trajectory=False,step_history=False,f=None,\\n cost_history=False,feedback=False,plot_history=False):\\n if feedback is True:\\n print(\\\"gd.gradient_descent():\\\")\\n if f is not None:\\n assert callable(f)\\n fx0 = f(x0)\\n if feedback is True:\\n print(f\\\" initial cost = {fx0:.2e}\\\")\\n if projection is not None:\\n assert callable(projection)\\n project = True\\n else:\\n project = False\\n if trajectory is True:\\n xx = [x0.copy()]\\n if step_history is True:\\n steps = []\\n if cost_history is True:\\n assert callable(f)\\n fx = [fx0]\\n\\n x = x0.copy()\\n for i in range(max_iters):\\n dx = -rate*df(x)\\n if project is True:\\n x0 = x.copy()\\n x = projection(x0+dx)\\n dx = x-x0\\n else:\\n x += dx\\n if trajectory is True:\\n xx.append(x.copy())\\n if cost_history is True:\\n fx += [f(x)]\\n step_size = np.linalg.norm(dx)\\n if step_history is True:\\n steps += [step_size]\\n if step_size < min_step or step_size > max_step:\\n break\\n\\n results = dict()\\n results['output'] = x\\n if trajectory is True:\\n results['trajectory'] = xx\\n if cost_history is True:\\n results['cost_history'] = fx\\n if step_history is True:\\n results['step_history'] = steps\\n if plot_history is True:\\n assert step_history is True or cost_history is True\\n plt.figure()\\n if step_history is True:\\n plt.semilogy(steps,label='step size')\\n if cost_history is True:\\n plt.semilogy(fx,label='cost')\\n plt.xlabel('iteration number')\\n plt.title('Gradient Descent')\\n plt.legend()\\n results['figure'] = plt\\n plt.show(block=False)\\n \\n if feedback is True:\\n if f is not None:\\n print(f\\\" final cost = {f(x):.2e}\\\")\\n \\n return results\",\n \"def step(self, closure=None, found_inf: Tensor = None):\\n if found_inf is None:\\n return super(AdamW, self).step(closure=closure)\\n\\n if found_inf.shape:\\n raise ValueError(\\\"The found_inf tensor has to be scalar type\\\")\\n\\n loss = None\\n if closure is not None:\\n with torch.enable_grad():\\n loss = closure()\\n\\n for group in self.param_groups:\\n params_with_grad = []\\n grads = []\\n exp_avgs = []\\n exp_avg_sqs = []\\n max_exp_avg_sqs = []\\n state_steps = []\\n beta1, beta2 = group['betas']\\n\\n for p in group['params']:\\n if p.grad is not None:\\n params_with_grad.append(p)\\n if p.grad.is_sparse:\\n raise RuntimeError('AdamW does not support sparse gradients')\\n grads.append(p.grad)\\n\\n state = self.state[p]\\n\\n # Lazy state initialization\\n if not state:\\n state['step'] = torch.zeros_like(found_inf)\\n # Exponential moving average of gradient values\\n state['exp_avg'] = torch.zeros_like(\\n p, memory_format=torch.preserve_format)\\n # Exponential moving average of squared gradient values\\n state['exp_avg_sq'] = torch.zeros_like(\\n p, memory_format=torch.preserve_format)\\n # Maintains max of all exp. moving avg. of sq. grad. values\\n state['max_exp_avg_sq'] = torch.zeros_like(\\n p, memory_format=torch.preserve_format)\\n\\n exp_avgs.append(state['exp_avg'])\\n exp_avg_sqs.append(state['exp_avg_sq'])\\n max_exp_avg_sqs.append(state['max_exp_avg_sq'])\\n\\n state_steps.append(state['step'])\\n\\n F.adam_step(\\n found_inf,\\n state_steps,\\n params_with_grad,\\n grads,\\n exp_avgs,\\n exp_avg_sqs,\\n max_exp_avg_sqs,\\n amsgrad=group['amsgrad'],\\n beta1=beta1,\\n beta2=beta2,\\n lr=group['lr'],\\n weight_decay=group['weight_decay'],\\n eps=group['eps'],\\n maximize=group['maximize'],\\n use_adamw=True)\\n\\n return loss\",\n \"def __call__(self, parameters) -> ValueEstimate:\\n # Encode params to json string\\n save_circuit_template_params(parameters, \\\"current_optimization_params.json\\\")\\n with open(\\\"current_optimization_params.json\\\", \\\"r\\\") as f:\\n current_params_string = f.read()\\n\\n # POST params to proxy\\n evaluation_id = self.client.post_argument_values(current_params_string)\\n\\n # POST status to EVALUATING\\n self.client.post_status(\\\"EVALUATING\\\")\\n\\n # WAIT for status to be OPTIMIZING\\n while self.client.get_status() != \\\"OPTIMIZING\\\":\\n time.sleep(1)\\n\\n # GET cost function evaluation from proxy\\n evaluation_string = self.client.get_evaluation_result(evaluation_id)\\n value_estimate = load_value_estimate(io.StringIO(evaluation_string))\\n\\n return value_estimate\",\n \"def approximate_gradient(self, theta, c, iter):\\n\\n true_theta = utils.true_param(theta)\\n\\n if self.history_count > 0:\\n current_goal, _ = self.average_evaluations(30)\\n else:\\n current_goal = SPSA_minimization.BAD_GOAL\\n\\n logging.info(f'{__file__} > current_goal: {current_goal}')\\n\\n print(f'current optimizer mean goal: {current_goal:0.5f} (low is better, lowest: -1.0, highest: 1.0)')\\n # print(f'Sample, optimizer goal = -(engine match score) or -(3.0 pts/4 games) or -0.75')\\n\\n bernouilli = self.create_bernouilli(theta)\\n\\n count = 0\\n while True:\\n logging.info(f'{__file__} Apply bernouilli term to theta, theta={theta}, c={c}, bernouilli={bernouilli}')\\n # Calculate two evaluations of f at points M + c * bernouilli and\\n # M - c * bernouilli to estimate the gradient. We do not want to\\n # use a null gradient, so we loop until the two functions evaluations\\n # are different. Another trick is that we use the same seed for the\\n # random generator for the two function evaluations, to reduce the\\n # variance of the gradient if the evaluations use simulations (like\\n # in games).\\n state = random.getstate()\\n theta1 = utils.linear_combinaison(1.0, theta, c, bernouilli)\\n logging.info(f'{__file__} theta1: {theta1}')\\n\\n # Apply parameter limits\\n logging.info(f'{__file__} > Apply limits to theta1 before sending to engine')\\n theta1 = utils.apply_limits(theta1)\\n logging.info(f'{__file__} theta1 with limits: {theta1}')\\n logging.info(f'{__file__} > run 1st match with theta1: {theta1}')\\n\\n random.setstate(state)\\n theta2 = utils.linear_combinaison(1.0, theta, -c, bernouilli)\\n logging.info(f'{__file__} theta2: {theta2}')\\n\\n # Apply parameter limits\\n logging.info(f'{__file__} > Apply limits to theta2 before sending to engine')\\n theta2 = utils.apply_limits(theta2)\\n logging.info(f'{__file__} theta2 with limits: {theta2}')\\n logging.info(f'{__file__} > run 2nd match with theta2: {theta2}')\\n\\n # Run the 2 matches in parallel after iteration 1.\\n manager = multiprocessing.Manager()\\n res = manager.dict()\\n thetas = [theta1, theta2]\\n\\n if iter < self.iter_parallel_start:\\n print('Run match 1 ...')\\n true_param = utils.true_param(theta1)\\n print('test_engine param:')\\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\\n print(f' {name}: {val[\\\"value\\\"]}, ({val[\\\"value\\\"] - val1[\\\"value\\\"]:+})')\\n\\n print('base_engine param:')\\n for name, val in utils.true_param(theta).items():\\n print(f' {name}: {val[\\\"value\\\"]}')\\n\\n t1 = time.perf_counter()\\n f1 = self.evaluate_goal(theta1, theta, 0, res, iter)\\n logging.info(f'f1 elapse: {time.perf_counter() - t1:0.2f}s')\\n print(f'Done match 1!, elapse: {time.perf_counter() - t1:0.2f}sec')\\n print(f'goal after match 1: {f1:0.5f}')\\n\\n # Run match 2\\n print('Run match 2 ...')\\n true_param = utils.true_param(theta2)\\n print('test_engine param:')\\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\\n print(f' {name}: {val[\\\"value\\\"]}, ({val[\\\"value\\\"] - val1[\\\"value\\\"]:+})')\\n\\n print('base_engine param:')\\n for name, val in utils.true_param(theta).items():\\n print(f' {name}: {val[\\\"value\\\"]}')\\n\\n t1 = time.perf_counter()\\n f2 = self.evaluate_goal(theta2, theta, 1, res, iter)\\n logging.info(f'f2 elapse: {time.perf_counter() - t1:0.2f}s')\\n print(f'Done match 2!, elapse: {time.perf_counter() - t1:0.2f}sec')\\n print(f'goal after match 2: {f2:0.5f}')\\n\\n print('Done engine match!')\\n else:\\n print('Run 2 matches in parallel ...')\\n t1 = time.perf_counter()\\n jobs = []\\n for i in range(2):\\n print(f'Run match {i + 1} ...')\\n\\n true_param = utils.true_param(thetas[i])\\n print('test_engine param:')\\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\\n print(f' {name}: {val[\\\"value\\\"]}, ({val[\\\"value\\\"] - val1[\\\"value\\\"]:+})')\\n\\n print('base_engine param:')\\n for name, val in utils.true_param(theta).items():\\n print(f' {name}: {val[\\\"value\\\"]}')\\n\\n p = multiprocessing.Process(target=self.evaluate_goal, args=(thetas[i], theta, i, res, iter))\\n jobs.append(p)\\n p.start()\\n\\n for num, proc in enumerate(jobs):\\n proc.join()\\n\\n # If match is done in parallel, update the history count, eval and theta here.\\n self.history_eval[self.history_count % 1000] = res.values()[num]\\n self.history_theta[self.history_count % 1000] = thetas[num]\\n self.history_count += 1\\n\\n print(f'Done match {num + 1}!, elapse: {time.perf_counter() - t1:0.2f}sec')\\n\\n logging.info(f'parallel elapse: {time.perf_counter() - t1:0.2f}s')\\n\\n print('Done engine match!')\\n\\n f1, f2 = res.values()[0], res.values()[1]\\n\\n logging.info(f'{__file__} > f1: {f1}, f2: {f2}')\\n print(f'optimizer goal after match 1: {f1:0.5f} (low is better)')\\n print(f'optimizer goal after match 2: {f2:0.5f} (low is better)')\\n\\n if f1 != f2:\\n break\\n\\n print('perf is the same in match 1 and 2, launch new matches ...')\\n\\n count = count + 1\\n logging.info(f'{__file__} > f1 and f2 are the same, try the engine match again. num_tries = {count}')\\n\\n if count >= 100:\\n logging.info(f'{__file__} > too many evaluation to find a gradient, function seems flat')\\n break\\n\\n # Update the gradient\\n gradient = copy.deepcopy(theta)\\n # print(f'Basic gradient after 2 engine matches:')\\n for name, value in theta.items():\\n gradient[name]['value'] = (f1 - f2) / (2.0 * c * bernouilli[name]['value'])\\n # print(f' {name}: {gradient[name][\\\"value\\\"]}')\\n logging.info(f'{__file__} > {name} gradient: {gradient}')\\n\\n if (f1 > current_goal) and (f2 > current_goal):\\n logging.info(f'{__file__} > function seems not decreasing')\\n gradient = utils.linear_combinaison(0.1, gradient)\\n\\n print('Modify the gradient because the results of engine matches\\\\n'\\n 'did not improve when using the new param. But we will not\\\\n'\\n 're-run the engine matches.')\\n\\n print('Modified gradient at alpha=0.1:')\\n for n, v in gradient.items():\\n print(f' {n}: {v[\\\"value\\\"]}')\\n\\n # For the correction factor used in the running average for the gradient,\\n # see the paper \\\"Adam: A Method For Stochastic Optimization, Kingma and Lei Ba\\\"\\n\\n beta = 0.9\\n correction = 1.0 / 1.0 - pow(beta, self.iter)\\n\\n gradient = utils.linear_combinaison((1 - beta), gradient, beta, self.previous_gradient)\\n gradient = utils.linear_combinaison(correction, gradient)\\n\\n # print('New gradient after applying correction:')\\n # for n, v in gradient.items():\\n # print(f' {n}: {v[\\\"value\\\"]}')\\n\\n # Store the current gradient for the next time, to calculate the running average\\n self.previous_gradient = gradient\\n\\n # Store the best the two evals f1 and f2 (or both)\\n if (f1 <= current_goal):\\n self.best_eval[self.best_count % 1000] = f1\\n self.best_theta[self.best_count % 1000] = theta1\\n self.best_count += 1\\n\\n if (f2 <= current_goal):\\n self.best_eval[self.best_count % 1000] = f2\\n self.best_theta[self.best_count % 1000] = theta2\\n self.best_count += 1\\n\\n logging.info(f'{__file__} > final gradient: {gradient}')\\n \\n # Return the estimation of the new gradient\\n return gradient\",\n \"def run_migrad(self, fitarg, **kwargs):\\n self.fitarg = fitarg\\n kwargs['up'] = 1.\\n\\n\\n logging.debug(self._par_names)\\n logging.debug(self.__wrap_likelihood(list(fitarg['pinit'].values())))\\n\\n if kwargs['scipy']:\\n self._res = op.minimize(self.__wrap_likelihood,\\n list(fitarg['pinit'].values()),\\n bounds=list(fitarg['limits'].values()),\\n method='TNC',\\n #method='Powell',\\n options={'maxiter': kwargs['ncall']} #'xtol': 1e-20, 'eps' : 1e-20, 'disp': True}\\n #tol=None, callback=None,\\n #options={'disp': False, 'minfev': 0, 'scale': None,\\n #'rescale': -1, 'offset': None, 'gtol': -1,\\n #'eps': 1e-08, 'eta': -1, 'maxiter': kwargs['ncall'],\\n #'maxCGit': -1, 'mesg_num': None, 'ftol': -1, 'xtol': -1, 'stepmx': 0,\\n #'accuracy': 0}\\n )\\n logging.info(self._res)\\n for i, k in enumerate(self._par_names):\\n fitarg[k] = self._res.x[i]\\n\\n logging.debug(fitarg)\\n\\n cmd_string = \\\"lambda {0}: self.__calcLikelihood({0})\\\".format(\\n (\\\", \\\".join(self._par_names), \\\", \\\".join(self._par_names)))\\n\\n string_args = \\\", \\\".join(self._par_names)\\n global f # needs to be global for eval to find it\\n f = lambda *args: self.__calc_likelihood(*args)\\n\\n cmd_string = \\\"lambda %s: f(%s)\\\" % (string_args, string_args)\\n logging.debug(cmd_string)\\n\\n # work around so that the parameters get names for minuit\\n self._minimize_f = eval(cmd_string, globals(), locals())\\n self._minimize_f.errordef = minuit.Minuit.LEAST_SQUARES\\n\\n self._m = minuit.Minuit(self._minimize_f,\\n #list(fitarg['pinit'].values()),\\n **fitarg['pinit'],\\n #names=self._par_names\\n )\\n# print_level=kwargs['verbosity'],\\n# errordef=kwargs['up'],\\n# pedantic=kwargs['pedantic'],\\n #**fitarg)\\n\\n for p in self._par_names:\\n self._m.fixed[p] = fitarg['fix'][p]\\n self._m.limits[p] = fitarg['limits'][p]\\n self._m.errors[p] = fitarg['error'][p]\\n\\n self._m.tol = kwargs['tol']\\n self._m.strategy = kwargs['strategy']\\n\\n logging.debug(\\\"tol {0:.2e}, strategy: {1:n}\\\".format(\\n self._m.tol, self._m.strategy.strategy))\\n\\n self._m.migrad(ncall=kwargs['ncall']) #, precision = kwargs['precision'])\",\n \"def grad_wrapper(*wrapper_args, variables=None):\\n\\n @custom_gradient\\n def inner_recompute_grad(*dresult):\\n \\\"\\\"\\\"Nested custom gradient function for computing grads in reverse and forward mode autodiff.\\\"\\\"\\\"\\n # Gradient calculation for reverse mode autodiff.\\n with backprop.GradientTape() as t:\\n id_args = nest.map_structure(gen_array_ops.identity, args)\\n # Tuple `dresult` should contain at least one tensor.\\n assert len(dresult) >= 1\\n\\n if not context.executing_eagerly():\\n # XLA doesn't respect `tf.control_dependencies`. The code block\\n # below manually adds a data dependency to `dresult` to ensure\\n # recomputation of `f(*args, **kwargs)` happens after `dresult`.\\n\\n # This works even if `dresult[0]` is a size 0 tensor as reduce_max\\n # of a size 0 tensor returns -inf. Use reshape here to avoid reading\\n # the entire `dresult[0]`.\\n elem = math_ops.reduce_max(array_ops.reshape(dresult[0], [-1])[:1])\\n # Cast elem to bool in case elem is NaN.\\n elem_bool = math_ops.cast(elem, dtypes.bool)\\n dresult_dep = array_ops.where_v2(\\n elem_bool == elem_bool, 0., float(\\\"nan\\\")) # pylint: disable=comparison-with-itself\\n id_args = nest.map_structure(\\n lambda x: x + math_ops.cast(dresult_dep, x.dtype), id_args)\\n\\n t.watch(id_args)\\n if variables is not None:\\n t.watch(variables)\\n with variable_scope.variable_scope(current_var_scope):\\n recomputed_result = f(*id_args, **kwargs)\\n kw_vars = []\\n if variables is not None:\\n kw_vars = list(variables)\\n grads = t.gradient(\\n recomputed_result,\\n list(id_args) + kw_vars,\\n output_gradients=dresult,\\n unconnected_gradients=UnconnectedGradients.ZERO)\\n\\n def transpose(*t_args, **t_kwargs):\\n \\\"\\\"\\\"Gradient function calculation for forward mode autodiff.\\\"\\\"\\\"\\n # Just throw an error since gradients / activations are not stored on\\n # tape for recompute.\\n raise NotImplementedError(\\n \\\"recompute_grad tried to transpose grad of {}. \\\"\\n \\\"Consider not using recompute_grad in forward mode\\\"\\n \\\"autodiff\\\".format(f.__name__))\\n\\n return (grads[:len(id_args)], grads[len(id_args):]), transpose\\n\\n return inner_recompute_grad(*wrapper_args)\",\n \"def __call__(self, step, inputs, hparams={}):\\n\\t\\tstep+=1\\n\\n\\t\\t# apply gradient tape\\n\\t\\ttape, loss = self.tape_gradients(inputs, **hparams)\\n\\t\\t\\n\\t\\t# check nan in loss\\n\\t\\tif np.isnan(loss.numpy()):\\n\\t\\t\\tstring=\\\"Nan Loss on step %s:\\\\t rec loss = %s\\\\t, reg loss = %s\\\\t\\\" % (\\n\\t\\t\\t\\tstep, \\n\\t\\t\\t\\tself.reconstruction_loss.numpy(),\\n\\t\\t\\t\\tself.regularization_loss.numpy(),\\n\\t\\t\\t\\t)\\n\\t\\t\\treturn np.nan\\n\\n\\t\\t# optimize\\n\\t\\tself.run_optimizer(tape, loss)\\n\\n\\t\\tprint('\\\\033[Kstep %s:\\\\t rec loss = %s\\\\t, reg loss = %s\\\\t' % (\\n\\t\\t\\tstep, \\n\\t\\t\\tself.reconstruction_loss.numpy(),\\n\\t\\t\\tself.regularization_loss.numpy(),\\n\\t\\t\\t), \\\"\\\\r\\\", end=\\\"\\\")\\n\\n\\t\\treturn step\",\n \"def opt_step(latent_values, real_coding, loss_weight, mse, \\n generator, optimizer, ntimes, ninput):\\n with tf.GradientTape() as tape:\\n tape.watch(latent_values)\\n # results from generator\\n gen_output = generator(latent_values, training=False)\\n loss = mse_loss(mse, real_coding, gen_output[:, :(ntimes - 1), :, :], \\n loss_weight, ninput)\\n\\n # gradient of the loss ws to the input\\n gradient = tape.gradient(loss, latent_values)\\n # applies gradients to the input\\n optimizer.apply_gradients(zip([gradient], [latent_values]))\\n\\n return loss\",\n \"def __call__(self, origin, function, state, **kwargs):\\n direction = state['direction']\\n ak = 0.\\n if 'initial_alpha_step' in state:\\n bk = state['initial_alpha_step']\\n else:\\n bk = self.stepSize\\n v_bk = function(origin + bk * direction)\\n\\n while abs(bk - ak) > self.minStepSize:\\n v_ak = function(origin + ak * direction)\\n g_ak = numpy.dot(function.gradient(origin + ak * direction), direction)\\n ck = ak - .5 * (ak - bk) * g_ak / (g_ak - (v_ak - v_bk) / (ak - bk))\\n v_ck = function(origin + ck * direction)\\n\\n bk = ak\\n ak = ck\\n v_bk = v_ak\\n v_ak = v_ck\\n\\n state['alpha_step'] = ck\\n return origin + ck * direction\",\n \"def optimise_fn(self, x):\\n\\n success = self._set_material_parameters(x)\\n if not success:\\n return self._bad_metric()\\n\\n # some iterations are repeated so cache the results to avoid unnecessary iterations\\n cached_result_key = tuple(x)\\n metric_value = self.cached_results.get(cached_result_key)\\n\\n if metric_value is None:\\n print('--> Optimiser: {}'.format(self.material_model))\\n\\n sim_result = fs.run_simulation(stoma_cfg=self.stoma_cfg,\\n from_optimiser=True)\\n\\n # when the simulation fails we want a non-constant measure for the optimiser to use\\n metric_value = sim_result.metric_value if sim_result.success else self._bad_metric()\\n\\n self.cached_results[cached_result_key] = metric_value\\n\\n print('--> Optimiser: {} - metric={}'.format(self.material_model, metric_value))\\n else:\\n print('--> Optimiser: {} - metric={} (cached result)'.format(self.material_model, metric_value))\\n\\n return metric_value\",\n \"def MAXED(N, sigma2, R, f_def, params):\\n\\n # pull out algorithm-specific parameters\\n Omega = params['Omega']\\n\\n # create the function that we will maximize, Z\\n def Z(lam, N, sigma2, R, f_def, Omega):\\n \\\"\\\"\\\"A function, the maximization of which is equivalent to the\\n maximization of \\\"\\\"\\\"\\n\\n A = - np.sum(f_def * np.exp(- np.sum((lam * R.T).T, axis=0)))\\n B = - (Omega * np.sum(lam**2 * sigma2))**(0.5)\\n C = - np.sum(N * lam)\\n\\n # negate because it's a minimization\\n return - (A + B + C)\\n\\n # create a lambda\\n lam = np.ones(len(N))\\n\\n # apply the simulated annealing to the Z\\n mk = {'args': (N, sigma2, R, f_def, Omega)}\\n lam = basinhopping(Z, lam, minimizer_kwargs=mk).x\\n\\n # back out the spectrum values from the lam\\n return f_def * np.exp(-np.sum((lam * R.T).T, axis=0))\",\n \"def optimizing(theta, data = data, target = target):\\n # num = (sin(individual[0] - individual[1] / 8))**2 + (sin(individual[1] + individual[0] / 8))**2\\n # denum = ((individual[0] - 8.6998)**2 + (individual[1] - 6.7665)**2)**0.5 + 1\\n learner = MLPClassifier(hidden_layer_sizes=theta[0], learning_rate_init=theta[1], alpha=theta[2], verbose=True, early_stopping=True, n_iter_no_change=6)\\n\\n model = learner.fit(data, target)\\n return model.best_loss_ # return the best error/residual (best error is cloes to zero) The error of a model is the difference between your predicted outcome and the real observed outcome and therefore 0 is desired\\n\\n # individual as a factor containing x, y = to tetha which \",\n \"def gradientdescent(cost_func, theta, args=(), delta_func = 0):\\n step = 1\\n old_cost = 0\\n while True:\\n theta_old = theta.copy()\\n cost = cost_func(theta, *args)\\n delta = delta_func(theta, *args)\\n theta = theta - step * delta\\n if cost > old_cost and old_cost != 0:\\n step = step*0.7\\n if np.allclose(theta_old, theta):\\n break\\n old_cost = cost\\n return theta\",\n \"def poll(target, step, args=(), kwargs=None, timeout=None, max_tries=None, check_success=is_truthy,\\n step_function=step_constant, ignore_exceptions=(), poll_forever=False, collect_values=None, *a, **k):\\n\\n logging.info('Starting Polling')\\n\\n assert (timeout is not None or max_tries is not None) or poll_forever, \\\\\\n ('You did not specify a maximum number of tries or a timeout. Without either of these set, the polling '\\n 'function will poll forever. If this is the behavior you want, pass \\\"poll_forever=True\\\"')\\n\\n assert not ((timeout is not None or max_tries is not None) and poll_forever), \\\\\\n 'You cannot specify both the option to poll_forever and max_tries/timeout.'\\n\\n kwargs = kwargs or dict()\\n values = collect_values or Queue()\\n\\n max_time = Time.time() + timeout if timeout else None\\n tries = 0\\n logging.debug('Max Time: ' + str(max_time))\\n logging.debug('Max Tries: ' + str(max_tries))\\n\\n last_item = None\\n while True:\\n\\n if max_tries is not None and tries >= max_tries:\\n raise MaxCallException(values, last_item)\\n\\n try:\\n logging.debug('Arguments: ' + str(args))\\n val = target(*args, **kwargs)\\n logging.debug('Results from Target running: ' + str(val))\\n last_item = val\\n logging.info('Try #:' + str(tries))\\n DisplayMessage('Try #:' + str(tries))\\n except ignore_exceptions as e:\\n logging.error(str(e))\\n last_item = e\\n else:\\n # Condition passes, this is the only \\\"successful\\\" exit from the polling function\\n if check_target_success(val):\\n return val\\n\\n logging.debug('last result from poll: ' + str(last_item))\\n # Condition passes, this is the only \\\"successful\\\" exit from the polling function\\n if check_target_success(val):\\n return val\\n else:\\n values.put(last_item)\\n tries += 1\\n # Check the time after to make sure the poll function is called at least once\\n if max_time is not None and Time.time() >= max_time:\\n # raise TimeoutException(values, last_item)\\n logging.info('Time out reached.')\\n logging.info('Checking status of job: ' + val)\\n logging.info('Job will now sleep for an additional: ' + step)\\n logging.debug('Step value: ' + str(step))\\n Time.sleep(step)\\n step = step_function(step)\",\n \"def optimize(self, y = None, x=None, store_path=None, epochs = 25, learning_rate = 0.005, scoring_method = \\\"mse\\\", criterion = MSELoss(), \\n reparam_f = None, ODE_criterion = None, init_conditions = None, scale = True, force = None, backprop_f = None, backprop = False,\\n ode_coefs = None, solve = True, rounds = None, tr_score_prop = 0.5, q = None, eq_system = False, n_outputs = None, \\n nonlinear_ode = False, reg_type = \\\"nl_ham\\\"):\\n font = {'size' : 18}\\n plt.rc('font', **font)\\n \\n #self.multiple_ICs = True if len(init_conditions[0]) > 1 else False\\n self.n_outputs = n_outputs\\n if n_outputs != len(init_conditions):\\n assert False, \\\"n_outputs must match the len of ode_coefs and init_conds\\\"\\n self.nl = nonlinear_ode\\n self.log2 = np.log(2)\\n self.q = q\\n self.eq_system = eq_system\\n self.rounds = rounds\\n self.tr_score_prop = tr_score_prop\\n self.solve = solve\\n self.ode_coefs = ode_coefs\\n if self.batch_size > 1:\\n if reg_type == \\\"driven_pop\\\":\\n custom_loss = driven_pop_loss\\n force = fforce\\n elif reg_type == \\\"simple_pop\\\":\\n custom_loss = driven_pop_loss\\n force = no_fforce\\n elif reg_type == \\\"ham\\\":\\n custom_loss = ham_loss\\n elif reg_type == \\\"no_reg\\\":\\n custom_loss = no_reg_loss\\n elif reg_type == \\\"elastic\\\":\\n custom_loss = elastic_loss\\n elif reg_type == \\\"hennon\\\":\\n custom_loss = hennon_hailes_loss\\n else:\\n assert False\\n self.ODE_criterion = custom_loss\\n if backprop_f:\\n self.backprop_f = optimize_last_layer\\n else:\\n self.backprop_f = None\\n self.epochs = epochs\\n else:\\n self.ODE_criterion = ODE_criterion\\n self.backprop_f = backprop_f\\n\\n self.init_conditions = init_conditions\\n \\n self.scale = scale\\n\\n if self.batch_size > 1:\\n self.reparam_f = freparam\\n #self.force = fforce\\n else:\\n self.reparam_f = reparam_f\\n self.force = force\\n\\n self.scoring_method = scoring_method\\n self.criterion = criterion\\n self.epochs = epochs\\n self.learning_rate = learning_rate\\n\\n \\\"\\\"\\\"\\n if self.ODE: \\n if self.dt != None:\\n #self.alpha = self.leaking_rate[0] / self.dt\\n\\n start, stop = float(x[0]), float(x[-1])\\n nsteps = int((stop - start) / self.dt)\\n x = torch.linspace(start, stop, steps = nsteps, requires_grad=False).view(-1,1).to(self.device)\\n elif type(x) == type([]) and len(X) == 3:\\n x0, xf, nsteps = x #6*np.pi, 100\\n x = torch.linspace(x0, xf, steps = nsteps, requires_grad=False).view(-1,1).to(self.device)\\n else:\\n assert False, \\\"Please input start, stop, dt\\\"\\n else:\\n #ensure that X is a two dimensional tensor, or if X is None declare a tensor.\\n X = check_x(X, y, self.dev).to(self.device)\\n \\\"\\\"\\\"\\n \\n # Checks\\n if not self.ODE_order:\\n self.validate_data(y, x, self.verbose)\\n \\n # Initialize new random state\\n if self.reservoir_matrices != None:\\n if self.ODE_order:\\n \\n \\n self.reservoir_matrices.n_inputs_ = x.shape[1]\\n\\n else:\\n\\n self.reservoir_matrices.n_inputs_ = max(y.shape[1] - 1, 1) if type(x) == type(None) else x.shape[1]\\n \\n self.reservoir_matrices.gen_in_weights()\\n\\n self.random_state = Generator().manual_seed(self.seed + 2)\\n\\n init_device = self.device if not self.windowsOS else torch.device('cpu')\\n\\n if not self.ODE_order:\\n if type(y) == np.ndarray:\\n y = torch.tensor(y, device = init_device, requires_grad = False)\\n if len(y.shape) == 1:\\n y = y.view(-1, 1)\\n if y.device != self.device:\\n y = y.to(init_device)\\n self.y = y.type(self.dtype) \\n else:\\n self.y = None\\n\\n self.x = x.type(self.dtype) if x is not None else None #torch.ones(*y.shape)\\n\\n # Inform user\\n if self.verbose:\\n print(\\\"Model initialization and exploration run...\\\")\\n \\n if self.interactive:\\n self.fig, self.ax = pl.subplots(1,3, figsize = (16,4))\\n \\n self.errorz, self.errorz_step, self.length_progress = [], [], []\\n dim = len(self.free_parameters)\\n self.state = TurboState(dim, length_min = self.length_min, \\n batch_size=self.batch_size, success_tolerance = self.success_tolerance)\\n \\n self.count = 1\\n\\n\\n declaration_args = {'activation_f' : self.activation_function,\\n 'act_f_prime' : self.act_f_prime,\\n #'backprop' : self.backprop,\\n 'n_outputs' : self.n_outputs,\\n #'model_type' : self.model_type,\\n #'input_weight_type' : self.input_weight_type, \\n 'approximate_reservoir' : self.approximate_reservoir,\\n \\\"device\\\" : self.device,\\n \\\"reservoir\\\" : self.reservoir_matrices\\n }\\n train_args = {\\\"burn_in\\\" : self.esn_burn_in, \\n \\\"ODE_order\\\" : self.ODE_order,\\n #\\\"track_in_grad\\\" : self.track_in_grad,\\n \\\"force\\\" : self.force,\\n \\\"reparam_f\\\" : self.reparam_f,\\n \\\"init_conditions\\\" : self.init_conditions,\\n \\\"ode_coefs\\\" : self.ode_coefs,\\n \\\"q\\\" : self.q,\\n \\\"eq_system\\\" : self.eq_system,\\n \\\"nl\\\" : self.nl,\\n \\\"backprop_f\\\" : self.backprop_f,\\n \\\"epochs\\\" : self.epochs,\\n \\\"SOLVE\\\" : self.solve, \\n #\\\"track_in_grad\\\" : False,\\n \\\"init_conditions\\\" : self.init_conditions,\\n #\\\"SCALE\\\" : self.scale,\\n \\\"reparam_f\\\" : self.reparam_f,\\n \\\"ODE_criterion\\\" : self.ODE_criterion\\n #\\\"multiple_ICs\\\" : self.multiple_ICs\\n }\\n\\n backprop_args = {\\\"backprop_f\\\" : self.backprop_f,\\n \\\"epochs\\\" : self.epochs}\\n\\n test_args = {\\\"scoring_method\\\" : self.scoring_method,\\n \\\"reparam\\\": self.reparam_f,\\n \\\"ODE_criterion\\\" : self.ODE_criterion}\\n cv_args = {\\\"rounds\\\" : self.rounds,\\n \\\"tr_score_prop\\\" : self.tr_score_prop,\\n \\\"log_score\\\": self.log_score}\\n\\n self.parallel_arguments = {\\\"declaration_args\\\": declaration_args, #\\\"RC\\\" : RC,\\n \\\"train_args\\\": train_args,\\n \\\"test_args\\\" : test_args,\\n \\\"backprop_args\\\" : backprop_args,\\n \\\"device\\\" : self.device,\\n \\\"cv_args\\\" : cv_args\\n }\\n\\n X_init = get_initial_points(self.scaled_bounds.shape[1], self.initial_samples, device = self.device, dtype = self.dtype)\\n \\n if len(X_init) > self.batch_size:\\n for i in range(X_init.shape[0] // self.batch_size):\\n #print(i)\\n X_batch = X_init[ (i*self.batch_size) : ((i+1)*self.batch_size), : ]\\n Y_batch = self.eval_objective( X_batch ) \\n \\n if not i:\\n X_turbo = X_batch\\n Y_turbo = Y_batch \\n else:\\n Y_turbo = cat((Y_turbo, Y_batch), dim=0)\\n X_turbo = cat((X_turbo, X_batch), dim=0)\\n else:\\n\\n X_turbo = X_init\\n Y_turbo = self.eval_objective( X_init)\\n \\n #X_turbo.share_memory()\\n #Y_turbo = tensor(\\n # [self.eval_objective(x.view(1,-1)) for x in X_turbo], dtype=dtype, device=device).unsqueeze(-1)\\n X_turbo = X_turbo.to(self.device)\\n Y_turbo = Y_turbo.to(self.device)\\n\\n self.X_turbo, self.Y_turbo = X_turbo, Y_turbo\\n \\n n_init = self.initial_samples\\n\\n #append the errorz to errorz_step\\n self.errorz_step += [max(self.errorz)] * X_turbo.shape[0] #n_init\\n \\n self.count = 0\\n # Run until TuRBO converges\\n while not self.state.restart_triggered: \\n\\n # Fit a GP model\\n train_Y = (Y_turbo - Y_turbo.mean()) / Y_turbo.std()\\n likelihood = GaussianLikelihood(noise_constraint=Interval(1e-8, 1e-3))\\n model = SingleTaskGP(X_turbo, train_Y, likelihood=likelihood)\\n mll = ExactMarginalLogLikelihood(model.likelihood, model)\\n fit_gpytorch_model(mll)\\n\\n # Create a batch\\n X_next = generate_batch(\\n state=self.state,\\n model=model,\\n X=X_turbo,\\n Y=train_Y,\\n batch_size=self.batch_size,\\n n_candidates=min(5000, max(2000, 200 * dim)),\\n num_restarts=10,\\n raw_samples=512,\\n acqf=\\\"ts\\\",\\n device = self.device\\n )\\n X_next = X_next\\n\\n #assert 1 ==0, X_next\\n\\n #can be parallelized:\\n Y_next = self.eval_objective( X_next) #tensor()#.unsqueeze(-1)\\n #[self.eval_objective(x.view(1,-1)) for x in X_next],\\n print('Y_next', Y_next)\\n print(\\\"self.state\\\", self.state)\\n # Update state \\n self.state = update_state(state=self.state, Y_next=Y_next)\\n\\n # Append data\\n X_turbo = cat((X_turbo, X_next), dim=0)\\n Y_turbo = cat((Y_turbo, Y_next), dim=0)\\n \\n # Print current status\\n print( \\n f\\\"{len(X_turbo)}) Best score: {max(Y_next).item():.4f}, TR length: {self.state.length:.2e}\\\" + \\n f\\\" length {self.state.length}\\\"# Best value:.item() {state.best_value:.2e},\\n )\\n \\n print( \\n f\\\"TR length: {self.state.length:.2e},\\\" + f\\\" min length {self.state.length_min:.2e}\\\"\\n # + Best value:.item() {state.best_value:.2e},\\n )\\n\\n self.errorz_step += [min(self.errorz)] * self.batch_size\\n\\n #assert len(self.errorz) == len(self.errorz_step), \\\"err len: {}, err step: {}\\\".format(len(self.errorz), len(self.errorz_step) )\\n else:\\n display.clear_output()\\n\\n \\n #display.clear_output(wait=True) \\n #display.display(pl.gcf())\\n \\n # Save to disk if desired\\n if not store_path is None:\\n with open(store_path, 'w+') as output_file:\\n json.dump(best_arguments, output_file, indent=4)\\n \\n best_vals = X_turbo[torch.argmax(Y_turbo)]\\n\\n \\n \\n denormed_ = self.denormalize_bounds(best_vals)\\n \\n try:\\n denormed_ = denormalize_bounds(best_vals)\\n except:\\n print(\\\"FAIL\\\")\\n\\n best_vals = X_turbo[torch.argmax(Y_turbo)]\\n\\n #####Bad temporary code to change it back into a dictionary\\n denormed_free_parameters = list(zip(self.free_parameters, denormed_))\\n denormed_free_parameters = dict([ (item[0], item[1].item()) for item in denormed_free_parameters])\\n\\n best_hyper_parameters = denormed_free_parameters\\n for fixed_parameter in self.fixed_parameters:\\n best_hyper_parameters = {fixed_parameter : self.bounds[fixed_parameter], **best_hyper_parameters }\\n\\n #log_vars = ['connectivity', 'llambda', 'llambda2', 'noise', 'regularization', 'dt']\\n for var in self.log_vars:\\n if var in best_hyper_parameters:\\n best_hyper_parameters[var] = 10. ** best_hyper_parameters[var] \\n \\n # Return best parameters\\n return best_hyper_parameters #X_turbo, Y_turbo, state, best_vals, denormed_ #best_arguments\",\n \"def mpi_split_evaluator_run(target_evaluator,\\n termination_params=None,\\n core_params=None,\\n exception_handling_params=None,\\n log=None,\\n #---> Insertion starts\\n gradient_only=False,\\n line_search=True):\\n #<--- Insertion ends\\n from libtbx.mpi4py import MPI\\n comm = MPI.COMM_WORLD\\n rank = comm.Get_rank()\\n size = comm.Get_size()\\n\\n if (termination_params is None):\\n termination_params = termination_parameters()\\n if (core_params is None):\\n core_params = core_parameters()\\n if (exception_handling_params is None):\\n exception_handling_params = exception_handling_parameters()\\n x = target_evaluator.x\\n if (log is not None):\\n print(\\\"lbfgs minimizer():\\\", file=log)\\n print(\\\" x.size():\\\", x.size(), file=log)\\n print(\\\" m:\\\", core_params.m, file=log)\\n print(\\\" maxfev:\\\", core_params.maxfev, file=log)\\n print(\\\" gtol:\\\", core_params.gtol, file=log)\\n print(\\\" xtol:\\\", core_params.xtol, file=log)\\n print(\\\" stpmin:\\\", core_params.stpmin, file=log)\\n print(\\\" stpmax:\\\", core_params.stpmax, file=log)\\n print(\\\"lbfgs traditional_convergence_test:\\\", \\\\\\n termination_params.traditional_convergence_test, file=log)\\n minimizer = ext.minimizer(\\n x.size(),\\n core_params.m,\\n core_params.maxfev,\\n core_params.gtol,\\n core_params.xtol,\\n core_params.stpmin,\\n core_params.stpmax)\\n if (termination_params.traditional_convergence_test):\\n is_converged = ext.traditional_convergence_test(\\n x.size(),\\n termination_params.traditional_convergence_test_eps)\\n else:\\n is_converged = ext.drop_convergence_test(\\n n_test_points=termination_params.drop_convergence_test_n_test_points,\\n max_drop_eps=termination_params.drop_convergence_test_max_drop_eps,\\n iteration_coefficient\\n =termination_params.drop_convergence_test_iteration_coefficient)\\n callback_after_step = getattr(target_evaluator, \\\"callback_after_step\\\", None)\\n diag_mode = getattr(target_evaluator, \\\"diag_mode\\\", None)\\n if (diag_mode is not None): assert diag_mode in [\\\"once\\\", \\\"always\\\"]\\n f_min, x_min = None, None\\n f, g = None, None\\n try:\\n while 1:\\n if (diag_mode is None):\\n #XXX Only the diag_mode==None case is currently implemented, just as example\\n f_term, g_term = target_evaluator.compute_functional_and_gradients()\\n f_total = comm.reduce(f_term, MPI.SUM, 0)\\n g_total = comm.reduce(g_term, MPI.SUM, 0)\\n if rank==0: transmit = (f_total,g_total)\\n else: transmit = None\\n f, g = comm.bcast(transmit, root=0)\\n if False and rank==0: # for debug\\n print (\\\"%s %10.4f\\\"%(\\\"MPI stp\\\",f),\\\"[\\\",\\\" \\\".join([\\\"%10.4f\\\"%a for a in x]),\\\"]\\\")\\n d = None\\n else:\\n f, g, d = target_evaluator.compute_functional_gradients_diag()\\n if (diag_mode == \\\"once\\\"):\\n diag_mode = None\\n if (f_min is None):\\n if (not termination_params.traditional_convergence_test):\\n is_converged(f)\\n f_min, x_min = f, x.deep_copy()\\n elif (f_min > f):\\n f_min, x_min = f, x.deep_copy()\\n if (log is not None):\\n print(\\\"lbfgs minimizer.run():\\\" \\\\\\n \\\" f=%.6g, |g|=%.6g, x_min=%.6g, x_mean=%.6g, x_max=%.6g\\\" % (\\n f, g.norm(), flex.min(x), flex.mean(x), flex.max(x)), file=log)\\n if (d is None):\\n #---> Insertion starts\\n if (minimizer.run(x, f, g, gradient_only,line_search)): continue\\n #<--- Insertion ends\\n else:\\n #---> Insertion starts\\n if (minimizer.run(x, f, g, d, gradient_only,line_search)): continue\\n #<--- Insertion ends\\n if (log is not None):\\n print(\\\"lbfgs minimizer step\\\", file=log)\\n if (callback_after_step is not None):\\n if (callback_after_step(minimizer) is True):\\n if (log is not None):\\n print(\\\"lbfgs minimizer stop: callback_after_step is True\\\", file=log)\\n break\\n if (termination_params.traditional_convergence_test):\\n if ( minimizer.iter() >= termination_params.min_iterations\\n and is_converged(x, g)):\\n if (log is not None):\\n print(\\\"lbfgs minimizer stop: traditional_convergence_test\\\", file=log)\\n break\\n else:\\n if (is_converged(f)):\\n if (log is not None):\\n print(\\\"lbfgs minimizer stop: drop_convergence_test\\\", file=log)\\n break\\n if ( termination_params.max_iterations is not None\\n and minimizer.iter() >= termination_params.max_iterations):\\n if (log is not None):\\n print(\\\"lbfgs minimizer stop: max_iterations\\\", file=log)\\n break\\n if ( termination_params.max_calls is not None\\n and minimizer.nfun() > termination_params.max_calls):\\n if (log is not None):\\n print(\\\"lbfgs minimizer stop: max_calls\\\", file=log)\\n break\\n if (d is None):\\n #---> Insertion starts\\n if (not minimizer.run(x, f, g, gradient_only,line_search)): break\\n #<--- Insertion ends\\n else:\\n #---> Insertion starts\\n if (not minimizer.run(x, f, g, d, gradient_only,line_search)): break\\n #<--- Insertion ends\\n except RuntimeError as e:\\n minimizer.error = str(e)\\n if (log is not None):\\n print(\\\"lbfgs minimizer exception:\\\", str(e), file=log)\\n if (x_min is not None):\\n x.clear()\\n x.extend(x_min)\\n error_classification = exception_handling_params.filter(\\n minimizer.error, x.size(), x, g)\\n if (error_classification > 0):\\n raise\\n elif (error_classification < 0):\\n minimizer.is_unusual_error = True\\n else:\\n minimizer.is_unusual_error = False\\n else:\\n minimizer.error = None\\n minimizer.is_unusual_error = None\\n if (log is not None):\\n print(\\\"lbfgs minimizer done.\\\", file=log)\\n return minimizer\",\n \"def minimize_batch(target_fn, gradient_fn, theta_0, tolerance=0.0000001):\\n\\n step_sizes = [ 100, 10, 1, 0.1, 0.01, 0.001, 0.0001, 0.00001]\\n\\n theta = theta_0\\n target_fn = safe(target_fn)\\n value = target_fn(theta)\\n\\n while True:\\n gradient = gradient_fn(theta)\\n next_thetas = [step(theta, gradient, -step_size)\\n for step_size in step_sizes]\\n next_theta = min(next_thetas, key=target_fn)\\n next_value = target_fn(next_theta)\\n\\n if abs(value - next_value) < tolerance:\\n return theta\\n else:\\n theta, value = next_theta, next_value\",\n \"def produce_max(self, *args, **kwargs):\\n raise NotImplementedError('This interaction has no produce_max method yet!')\",\n \"def _optimize(self, X, y, W, steps):\\n\\n X = X.flatten(1)\\n\\n min_x, max_x = X.min(), X.max()\\n len_x = max_x - min_x\\n \\n bestd = 1\\n bestp = min_x\\n minerr = W.sum()\\n\\n if len_x > 0.0:\\n for p in np.arange(min_x, max_x, len_x/steps):\\n for d in [-1, 1]:\\n gy = np.ones((y.size))\\n gy[X*d < p*d] = -1\\n err = np.sum((gy != y)*W)\\n if err < minerr:\\n minerr = err\\n bestd = d\\n bestp = p\\n\\n return minerr, bestd, bestp\",\n \"def gd(x0,gradient,learning_rate=1.0,min_step=1e-16,max_iters=1000,**kwargs):\\n x = x0; i = 0; step_size = np.Inf\\n while step_size > min_step and i < max_iters:\\n x0 = x\\n grad = gradient(x0)\\n x = x0 - learning_rate*grad\\n step_size = np.linalg.norm(x-x0)\\n i += 1\\n\\n if step_size <= min_step:\\n stop = True\\n else:\\n stop = False\\n \\n specs = {\\n 'iterations' : i,\\n 'final_step' : step_size,\\n 'final_gradient' : np.linalg.norm(grad),\\n 'stop' : stop\\n }\\n return x, specs\",\n \"def optimize(opt, target, n_agents, n_variables, n_iterations, lb, ub, hyperparams):\\n\\n # Creating the SearchSpace\\n space = SearchSpace(n_agents=n_agents, n_variables=n_variables,\\n n_iterations=n_iterations, lower_bound=lb, upper_bound=ub)\\n\\n # Creating the Function\\n function = Function(pointer=target)\\n\\n # Creating Optimizer\\n if opt.__name__ is not 'BH':\\n optimizer = opt(hyperparams=hyperparams)\\n else:\\n optimizer = opt()\\n\\n # Creating the optimization task\\n task = Opytimizer(space=space, optimizer=optimizer, function=function)\\n\\n return task.start(store_best_only=True)\",\n \"def solver_mtw(Xf, mXf, Ls, y, M, alpha, beta1, beta2, epsilon, gamma, coef1,\\n coef2, R, b1, b2, sigmas, concomitant=False,\\n stable=False, tol=1e-4, max_iter=1000, tol_ot=1e-5,\\n max_iter_ot=20, max_iter_cd=2000,\\n positive=False, n_jobs=1, tol_cd=1e-5, gpu=False,\\n ot_threshold=0):\\n log = {'loss': [], 'dloss': [], 'log_sinkhorn1': [], 'log_sinkhorn2': [],\\n 'stable': stable, \\\"objcd\\\": [], \\\"fot1\\\": [0.], \\\"fot2\\\": [0.],\\n 'reweighting_loss': [], \\\"n_coords\\\": [], \\\"obj\\\": 0.}\\n n_samples, n_features = Xf[0].shape\\n n_tasks = len(Xf)\\n if n_jobs == -1:\\n n_jobs = n_tasks\\n marginals1, marginals2 = np.ones((2, n_tasks, n_features)) / n_features\\n\\n theta1 = coef1.copy()\\n theta2 = coef2.copy()\\n theta = theta1 - theta2\\n\\n thetaold = theta.copy()\\n\\n ot_img = True\\n if len(M) == n_features:\\n ot_img = False\\n\\n update_ot_1 = set_ot_func(stable, ot_img)\\n update_ot_2 = set_ot_func(stable, ot_img)\\n\\n xp = utils.set_module(gpu)\\n M = xp.asarray(- M / epsilon)\\n if b1 is not None:\\n b1 = xp.asarray(b1)\\n if b2 is not None:\\n b2 = xp.asarray(b2)\\n\\n thetabar1 = np.ones_like(coef1).mean(axis=-1)\\n thetabar2 = np.ones_like(coef2).mean(axis=-1)\\n\\n if positive:\\n theta2 *= 0.\\n thetabar2 *= 0.\\n theta = theta1\\n a = n_samples * alpha * gamma\\n beta1 = n_samples * beta1\\n beta2 = n_samples * beta2\\n\\n if concomitant:\\n sigma0 = 0.01 * np.linalg.norm(y, axis=1).min() / (n_samples ** 0.5)\\n else:\\n sigma0 = 0.\\n with Parallel(n_jobs=n_jobs, backend=\\\"threading\\\") as pll:\\n if alpha == 0.:\\n theta, R, sigmas, mx = update_coefs(pll, Xf, y, theta, R,\\n Ls, marginals1,\\n sigmas, a, beta1,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd,\\n positive=positive)\\n obj = 0.5 * (R ** 2).sum(axis=1).dot(1 / sigmas) / n_samples\\n obj += beta1 * abs(theta).sum() + 0.5 * sigmas.sum()\\n theta1, theta2 = utils.get_unsigned(theta)\\n log['loss'].append(obj)\\n else:\\n for i in range(max_iter):\\n obj = 0.\\n if not positive:\\n Y1 = utils.residual(Xf, - theta2, y)\\n else:\\n Y1 = y\\n theta1, R, sigmas, mxp = update_coefs(pll, Xf, Y1, theta1, R,\\n Ls,\\n marginals1,\\n sigmas,\\n a, beta1,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd)\\n if not positive:\\n Y2 = utils.residual(Xf, theta1, y)\\n theta2, R, sigmas, mx = update_coefs(pll, mXf, Y2, theta2,\\n R,\\n Ls,\\n marginals2,\\n sigmas,\\n a, beta2,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd)\\n theta = theta1 - theta2\\n else:\\n theta = theta1\\n\\n dx = abs(theta - thetaold) / max(1, thetaold.max(),\\n theta.max())\\n dx = dx.max()\\n thetaold = theta.copy()\\n if alpha:\\n if (theta1 > ot_threshold).any(0).all():\\n fot1, log_ot1, marginals1, b1, q1 = \\\\\\n update_ot_1(theta1, M, epsilon, gamma,\\n b=b1, tol=tol_ot,\\n max_iter=max_iter_ot,\\n threshold=ot_threshold)\\n if fot1 is None or not theta1.max(0).all():\\n warnings.warn(\\\"Numerical errors. Moving in \\\"\\n \\\"log-domain.\\\")\\n b1 = xp.log(b1 + 1e-100, out=b1)\\n stable = True\\n update_ot_1 = set_ot_func(True, ot_img)\\n fot1, log_ot1, marginals1, b1, q1 = \\\\\\n update_ot_1(theta1, M, epsilon, gamma, b=b1,\\n tol=tol_ot, max_iter=max_iter_ot,\\n threshold=ot_threshold)\\n\\n log[\\\"log_sinkhorn1\\\"].append(log_ot1)\\n thetabar1 = q1\\n log[\\\"fot1\\\"].append(fot1)\\n obj += alpha * fot1\\n if not positive and (theta2 > ot_threshold).any(0).all():\\n fot2, log_ot2, marginals2, b2, q2 = \\\\\\n update_ot_2(theta2, M, epsilon, gamma,\\n b=b2, tol=tol_ot, max_iter=max_iter_ot)\\n\\n if fot2 is None or not theta2.max(0).all():\\n warnings.warn(\\\"Numerical errors. Moving in \\\"\\n \\\"log-domain.\\\")\\n b2 = xp.log(b2 + 1e-100, out=b2)\\n stable = True\\n update_ot_2 = set_ot_func(True, ot_img)\\n fot2, log_ot2, marginals2, b2, q2 = \\\\\\n update_ot_2(theta2, M, epsilon, gamma,\\n b=b2, tol=tol_ot,\\n max_iter=max_iter_ot)\\n\\n log[\\\"log_sinkhorn2\\\"].append(log_ot2)\\n thetabar2 = q2\\n log[\\\"fot2\\\"].append(fot2)\\n obj += alpha * fot2\\n\\n log['loss'].append(obj)\\n log['dloss'].append(dx)\\n\\n if dx < tol:\\n break\\n if i == max_iter - 1:\\n warnings.warn('Objective did not converge.' +\\n ' You might want' +\\n ' to increase the number of iterations.' +\\n ' Fitting data with very small alpha and' +\\n ' beta may cause precision problems.',\\n ConvergenceWarning)\\n log['stable'] = stable\\n\\n if positive:\\n theta2 *= 0.\\n thetabar2 = xp.zeros_like(thetabar1)\\n try:\\n thetabar2 = thetabar2.get()\\n except AttributeError:\\n pass\\n return (theta1, theta2, thetabar1, thetabar2, log, sigmas, b1, b2, R)\",\n \"def optimize(self, state, algorithm, distances):\\n\\n if self.__current_job is not None:\\n raise ServiceError('Optimization in progress. Wait till the end, before submitting next state.', 3)\\n\\n assert isinstance(state, State)\\n assert isinstance(algorithm, Algorithm)\\n assert isinstance(distances, Distances)\\n\\n data = {\\n 'state': json.dumps(state.to_dict()),\\n 'key': self.key,\\n 'distances': json.dumps(distances.to_dict()),\\n 'algorithm': json.dumps(algorithm.to_dict()),\\n 'previous_task': self.__previous_job\\n }\\n\\n try:\\n response = requests.post('{}/api/v1/solve'.format(self.URL), data=data, timeout=10)\\n except (Timeout, ConnectionError):\\n raise ServiceError('Service unavailable: timeout.', 4)\\n\\n result = self._validate(response)\\n self.__current_job = result.get('jid')\\n return self.__current_job\",\n \"def _generic_minimize(method, loss, x0,\\n verbose=False,\\n num_iters=1000,\\n tol=1e-4,\\n state=None,\\n full_output=False,\\n suppress_warnings=False,\\n **kwargs):\\n # Flatten the loss\\n _x0, unflatten = flatten(x0)\\n _objective = lambda x_flat, itr: loss(unflatten(x_flat), itr)\\n\\n if verbose:\\n print(\\\"Fitting with {}.\\\".format(method))\\n\\n # Specify callback for fitting\\n itr = [0]\\n def callback(x_flat):\\n itr[0] += 1\\n print(\\\"Iteration {} loss: {:.3f}\\\".format(itr[0], loss(unflatten(x_flat), -1)))\\n\\n # Wrap the gradient to avoid NaNs\\n def safe_grad(x, itr):\\n g = grad(_objective)(x, itr)\\n g[~np.isfinite(g)] = 1e8\\n return g\\n\\n # Call the optimizer. Pass in -1 as the iteration since it is unused.\\n result = minimize(_objective, _x0, args=(-1,),\\n jac=safe_grad,\\n method=method,\\n callback=callback if verbose else None,\\n options=dict(maxiter=num_iters, disp=verbose),\\n tol=tol,\\n **kwargs)\\n if verbose:\\n print(\\\"{} completed with message: \\\\n{}\\\".format(method, result.message))\\n\\n if not suppress_warnings and not result.success:\\n warn(\\\"{} failed with message:\\\\n{}\\\".format(method, result.message))\\n\\n if full_output:\\n return unflatten(result.x), result\\n else:\\n return unflatten(result.x)\",\n \"def run_method(trial, method,\\n cl_ctx=None,\\n queue=None,\\n clear_memoized_objects=False,\\n true_sol_name=\\\"True Solution\\\",\\n comp_sol_name=\\\"Computed Solution\\\", **kwargs):\\n if clear_memoized_objects:\\n global memoized_objects\\n memoized_objects = {}\\n\\n if cl_ctx is None:\\n raise ValueError(\\\"Missing cl_ctx\\\")\\n if queue is None:\\n raise ValueError(\\\"Missing queue\\\")\\n\\n # Get boundary ids\\n scatterer_bdy_id = kwargs['scatterer_bdy_id']\\n outer_bdy_id = kwargs['outer_bdy_id']\\n\\n # Get degree and wave number\\n degree = trial['degree']\\n wave_number = trial['kappa']\\n\\n # Get options prefix and solver parameters, if any\\n options_prefix = kwargs.get('options_prefix', None)\\n solver_parameters = dict(kwargs.get('solver_parameters', None))\\n\\n # Get prepared trial args in kwargs\\n prepared_trial = prepare_trial(trial, true_sol_name, cl_ctx, queue)\\n mesh, fspace, vfspace, true_sol, true_sol_grad_expr = prepared_trial\\n\\n # Create a place to memoize any objects if necessary\\n tuple_trial = trial_to_tuple(trial)\\n memo_key = tuple_trial[:2]\\n if memo_key not in memoized_objects:\\n memoized_objects[memo_key] = {}\\n\\n comp_sol = None\\n\\n # Handle any special kwargs and get computed solution\\n if method == 'pml':\\n # Get required objects\\n pml_max = kwargs['pml_max']\\n pml_min = kwargs['pml_min']\\n\\n # Get optional argumetns\\n pml_type = kwargs.get('pml_type', None)\\n quad_const = kwargs.get('quad_const', None)\\n speed = kwargs.get('speed', None)\\n\\n # Make tensor function space\\n if 'tfspace' not in memoized_objects[memo_key]:\\n memoized_objects[memo_key]['tfspace'] = \\\\\\n TensorFunctionSpace(mesh, 'CG', degree)\\n\\n tfspace = memoized_objects[memo_key]['tfspace']\\n\\n snes, comp_sol = pml(mesh, scatterer_bdy_id, outer_bdy_id, wave_number,\\n options_prefix=options_prefix,\\n solver_parameters=solver_parameters,\\n fspace=fspace, tfspace=tfspace,\\n true_sol_grad_expr=true_sol_grad_expr,\\n pml_type=pml_type, quad_const=quad_const,\\n speed=speed,\\n pml_min=pml_min,\\n pml_max=pml_max,\\n )\\n snes_or_ksp = snes\\n\\n elif method == 'nonlocal':\\n # Build DG spaces if not already built\\n if 'dgfspace' not in memoized_objects[memo_key]:\\n memoized_objects[memo_key]['dgfspace'] = \\\\\\n FunctionSpace(mesh, 'DG', degree)\\n if 'dgvfspace' not in memoized_objects[memo_key]:\\n memoized_objects[memo_key]['dgvfspace'] = \\\\\\n VectorFunctionSpace(mesh, 'DG', degree)\\n\\n dgfspace = memoized_objects[memo_key]['dgfspace']\\n dgvfspace = memoized_objects[memo_key]['dgvfspace']\\n\\n # Get opencl array context\\n from meshmode.array_context import PyOpenCLArrayContext\\n actx = PyOpenCLArrayContext(queue)\\n\\n # Build connection fd -> meshmode if not already built\\n if 'meshmode_src_connection' not in memoized_objects[memo_key]:\\n from meshmode.interop.firedrake import build_connection_from_firedrake\\n memoized_objects[memo_key]['meshmode_src_connection'] = \\\\\\n build_connection_from_firedrake(\\n actx,\\n dgfspace,\\n grp_factory=None,\\n restrict_to_boundary=scatterer_bdy_id)\\n\\n meshmode_src_connection = memoized_objects[memo_key]['meshmode_src_connection']\\n\\n # Set defaults for qbx kwargs\\n qbx_order = kwargs.get('qbx_order', degree+2)\\n fine_order = kwargs.get('fine_order', 4 * degree)\\n fmm_order = kwargs.get('FMM Order', None)\\n fmm_tol = kwargs.get('FMM Tol', None)\\n # make sure got either fmm_order xor fmm_tol\\n if fmm_order is None and fmm_tol is None:\\n raise ValueError(\\\"At least one of 'fmm_order', 'fmm_tol' must not \\\"\\n \\\"be *None*\\\")\\n if fmm_order is not None and fmm_tol is not None:\\n raise ValueError(\\\"At most one of 'fmm_order', 'fmm_tol' must not \\\"\\n \\\"be *None*\\\")\\n # if got fmm_tol, make a level-to-order\\n fmm_level_to_order = None\\n if fmm_tol is not None:\\n if not isinstance(fmm_tol, float):\\n raise TypeError(\\\"fmm_tol of type '%s' is not of type float\\\" % type(fmm_tol))\\n if fmm_tol <= 0.0:\\n raise ValueError(\\\"fmm_tol of '%s' is less than or equal to 0.0\\\" % fmm_tol)\\n from sumpy.expansion.level_to_order import SimpleExpansionOrderFinder \\n fmm_level_to_order = SimpleExpansionOrderFinder(fmm_tol)\\n # Otherwise, make sure we got a valid fmm_order\\n else:\\n if not isinstance(fmm_order, int):\\n if fmm_order != False:\\n raise TypeError(\\\"fmm_order of type '%s' is not of type int\\\" % type(fmm_order))\\n if fmm_order != False and fmm_order < 1:\\n raise ValueError(\\\"fmm_order of '%s' is less than 1\\\" % fmm_order)\\n\\n qbx_kwargs = {'qbx_order': qbx_order,\\n 'fine_order': fine_order,\\n 'fmm_order': fmm_order,\\n 'fmm_level_to_order': fmm_level_to_order,\\n 'fmm_backend': 'fmmlib',\\n }\\n # }}}\\n\\n ksp, comp_sol = nonlocal_integral_eq(\\n mesh, scatterer_bdy_id, outer_bdy_id,\\n wave_number,\\n options_prefix=options_prefix,\\n solver_parameters=solver_parameters,\\n fspace=fspace, vfspace=vfspace,\\n true_sol_grad_expr=true_sol_grad_expr,\\n actx=actx,\\n dgfspace=dgfspace,\\n dgvfspace=dgvfspace,\\n meshmode_src_connection=meshmode_src_connection,\\n qbx_kwargs=qbx_kwargs,\\n )\\n\\n snes_or_ksp = ksp\\n\\n elif method == 'transmission':\\n\\n snes, comp_sol = transmission(mesh, scatterer_bdy_id, outer_bdy_id,\\n wave_number,\\n options_prefix=options_prefix,\\n solver_parameters=solver_parameters,\\n fspace=fspace,\\n true_sol_grad_expr=true_sol_grad_expr,\\n )\\n snes_or_ksp = snes\\n else:\\n raise ValueError(\\\"Invalid method\\\")\\n\\n comp_sol.rename(name=comp_sol_name)\\n return true_sol, comp_sol, snes_or_ksp\",\n \"def fit_to_target_func(self, func_target, list_x, algo = 'DE', copy = False, **args_optim):\\n func_to_fit = self.clone() if copy else self \\n return_fit = args_optim.pop('return_fit', False) # return the fit val\\n bounds = func_to_fit.theta_bounds\\n if not(_is_fully_bounded(bounds)):\\n SystemError(\\\"Can't fit with unknown bounds\\\")\\n \\n def SquareErrors(params):\\n func_to_fit.theta = params\\n res = pFunc_base.square_dist(func_to_fit, func_target, list_x)\\n return res\\n \\n if(algo == 'DE'):\\n import scipy.optimize\\n resDE = scipy.optimize.differential_evolution(SquareErrors, bounds, **args_optim)\\n else:\\n raise NotImplementedError('Only DE has been implemented so far')\\n \\n fit = SquareErrors(resDE['x'])\\n logger.info(fit)\\n if(return_fit):\\n return func_to_fit, fit\\n else:\\n return func_to_fit\",\n \"def back_prop(net, input_values, desired_output, r=1, minimum_accuracy=-0.001):\\n raise NotImplementedError\",\n \"def parallel_nelder_mead_worker(obj_func, simplex, f_vals, j, P, opt_params):\\n # Unpack the input parameters\\n alpha = opt_params[0] # reflection parameter\\n beta = opt_params[1] # contraction parameter\\n gamma = opt_params[2] # expansion parameter\\n my_point = simplex[j, :] # vertex to update\\n my_val = f_vals[j] # value at the vertex to update\\n best_val = f_vals[0] # best value in the vertex\\n next_val = f_vals[j - 1] # next best point in the simplex\\n evals = 0\\n\\n # Calculate the centroid of the \\\"good\\\" simplex points\\n N = simplex.shape[0] # number of points in simplex\\n centroid = np.mean(simplex[0 : (N - P), :], axis=0)\\n\\n # Calculate the reflection point and its function value\\n r_point = centroid + alpha * (centroid - my_point)\\n r_val = obj_func(r_point)\\n evals += 1\\n\\n # Case 1: the reflection point is better than best point\\n if r_val < best_val:\\n e_point = r_point + gamma * (r_point - centroid)\\n e_val = obj_func(e_point) # Calculate expansion point\\n evals += 1\\n if e_val < r_val:\\n new_point = e_point\\n new_val = e_val\\n else:\\n new_point = r_point\\n new_val = r_val\\n # Case 2: the reflection point is better than the next best point\\n elif r_val < next_val:\\n new_point = r_point # Report reflection point\\n new_val = r_val\\n # Case 3: the reflection point is worse than the next best point\\n else:\\n if r_val < my_val:\\n temp_point = r_point # Check whether reflection or original point\\n temp_val = r_val # is better and use it temporarily\\n else:\\n temp_point = my_point\\n temp_val = my_val\\n c_point = temp_point + beta * (centroid - temp_point)\\n c_val = obj_func(c_point) # Calculate contraction point\\n evals += 1\\n if c_val < temp_val:\\n new_point = c_point\\n new_val = c_val # Check whether the contraction point is better\\n else:\\n new_point = temp_point\\n new_val = temp_val\\n\\n # Return the outputs\\n return new_point, new_val, evals\",\n \"def example():\\n Optimizer = BFGS(f, g)\\n startPoint = 100 * numpy.ones(2);\\n res = Optimizer.optimize(startPoint,\\n epsilon=1e-5,\\n maxIterations=10)\\n print res\\n pass\",\n \"def solve(self, example_name, max_iter = 100, is_check_stop = True, maximum_line_search = 10):\\n logger.debug(\\\"[+ +] Initial Obj.Val.: %.5e\\\"%(self.get_obj_fun_value()))\\n start_time = tm.time()\\n for i in range(max_iter):\\n if i == 1: # skip the compiling time \\n start_time = tm.time()\\n iter_start_time = tm.time()\\n self.backward_pass()\\n backward_time = tm.time()\\n obj, isStop = self.forward_pass(max_line_search=maximum_line_search)\\n forward_time = tm.time()\\n logger.debug(\\\"[+ +] Iter.No.%3d BWTime:%.3e FWTime:%.3e Obj.Val.:%.5e\\\"%(\\n i, backward_time-iter_start_time,forward_time-backward_time,obj))\\n result_path = os.path.join(\\\"logs\\\", example_name, str(i) +\\\".mat\\\")\\n io.savemat(result_path,{\\\"trajectory\\\": self.get_traj()})\\n if isStop and is_check_stop:\\n break\\n end_time = tm.time()\\n logger.debug(\\\"[+ +] Completed! All Time:%.5e\\\"%(end_time-start_time))\",\n \"def logexp_optimise(fn, x, **kwargs):\\n def transform(x):\\n theta = logexp_to_natural(x)\\n y,grad = fn(theta)\\n # get gradients back to our space\\n grad *= logexp_gradientfactor(theta)\\n return (y,grad)\\n res = spo.minimize(transform, natural_to_logexp(x), jac=True,\\n **kwargs)\\n res.x = logexp_to_natural(res.x)\\n return res\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\r\\n\\r\\n m = len(values)\\r\\n cost_history = []\\r\\n\\r\\n for i in range (num_iterations):\\r\\n \\r\\n h = numpy.dot(features, theta)\\r\\n \\r\\n theta = theta - alpha / m * numpy.dot((h-values),features)\\r\\n \\r\\n cost = compute_cost(features, values, theta)\\r\\n \\r\\n cost_history.append(cost)\\r\\n\\r\\n return theta, pandas.Series(cost_history) # leave this line for the grader\\r\",\n \"def _newtons_method_gmres_action(f, initial_guess, max_iter=50, tol=1e-12):\\n\\n output_dim = len(f(initial_guess))\\n \\n @np.vectorize\\n def sum_values(dictionary):\\n return sum(dictionary.values())\\n \\n def create_action(x0):\\n \\n def L_fun(x):\\n \\\"\\\"\\\"\\n Action\\n Returns J_f(x0)*x by setting the values of 'x' as the initial derivatives for the variables in x0.\\n \\\"\\\"\\\"\\n \\n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\\n action = sum_values(ad.get_deriv(f_x0))\\n return action\\n \\n L = LinearOperator(shape=(output_dim, len(x0)), matvec=L_fun)\\n \\n return L\\n \\n x0 = initial_guess\\n for iter_num in range(max_iter):\\n L = create_action(x0)\\n b = -1 * np.array(f(x0))\\n if len(x0) == 1:\\n b = np.array([b])\\n step, _ = gmres(L, b, tol = tol, atol = 'legacy')\\n xnext = x0 + step \\n if np.all(np.abs(xnext - x0) < tol):\\n return (xnext, iter_num + 1);\\n x0 = xnext\\n \\n raise RuntimeError(\\\"Failed to converge after {0} iterations, value is {1}\\\".format(max_iter, x0) );\",\n \"def optimize(self, num_restarts=1, max_iters=100, max_f_eval=300.0, method='Anneal'):\\n dic = DictVectorizer()\\n # flatten the parameters\\n init_params,bounds=dic.fit_transform(self.params)\\n #we minimise minus the marginal likelihood\\n def objective(params_flatten):\\n self.params=dic.inverse_transform(params_flatten,bounds)\\n val = -self.log_marginal_likelihood()\\n return val# we want to maximize it\\n \\n \\n #run ptimisation with multiple restarts\\n optml=np.inf\\n for i in range(num_restarts):\\n #minimise function\\n if method=='Anneal':\\n res=dual_annealing(objective,bounds, maxiter=max_iters, maxfun=max_f_eval, x0=init_params)\\n else:\\n \\n res = minimize(objective, init_params, \\n bounds=bounds, method=method,options={'maxiter': max_iters, 'disp': False})\\n #print(\\\"Iteration \\\"+str(i)+\\\" \\\",-res.fun)\\n if res.fun<optml:\\n params_best=res.x #init_params \\n optml=res.fun\\n init_params=bounds[:,0]+(bounds[:,1]-bounds[:,0])*np.random.rand(len(bounds[:,0]))\\n print(\\\"Iteration \\\"+str(i)+\\\" \\\",-res.fun)\\n #params_best=res.x\\n #optml=res.fun\\n self.params=dic.inverse_transform(params_best,bounds)\\n return -optml\",\n \"def __max_step(self, batch):\\n\\n # short hand and optimizer\\n policy = self.mc.get('policy', target=False)\\n policy_parameters = list(policy.parameters())\\n opt_outer = optim.Adam(policy_parameters, lr=self.outer_lr)\\n\\n # optimize\\n opt_outer.zero_grad()\\n obj = -self.obj(batch)\\n obj.backward()\\n opt_outer.step()\",\n \"def solve(self, problem, x=None, reuselinesearch=False):\\n man = problem.manifold\\n verbosity = problem.verbosity\\n objective = problem.cost\\n gradient = problem.grad\\n\\n if not reuselinesearch or self.linesearch is None:\\n self.linesearch = deepcopy(self._linesearch)\\n linesearch = self.linesearch\\n\\n # If no starting point is specified, generate one at random.\\n if x is None:\\n x = man.rand()\\n\\n # Initialize iteration counter and timer\\n iter = 0\\n stepsize = np.nan\\n time0 = time.time()\\n\\n if verbosity >= 1:\\n print(\\\"Optimizing...\\\")\\n if verbosity >= 2:\\n print(\\\" iter\\\\t\\\\t cost val\\\\t grad. norm\\\")\\n\\n # Calculate initial cost-related quantities\\n cost = objective(x)\\n grad = gradient(x)\\n gradnorm = man.norm(x, grad)\\n def _Pgrad(_x):\\n return problem.precon(_x, gradient(_x))\\n Pgrad = problem.precon(x, grad)\\n gradPgrad = man.inner(x, grad, Pgrad)\\n\\n # Initial descent direction is the negative gradient\\n desc_dir = -Pgrad\\n\\n self._start_optlog(extraiterfields=['gradnorm'],\\n solverparams={'beta_type': self._beta_type,\\n 'orth_value': self._orth_value,\\n 'linesearcher': linesearch})\\n\\n while True:\\n if verbosity >= 2:\\n print(\\\"%5d\\\\t%+.16e\\\\t%.8e\\\" % (iter, cost, gradnorm))\\n\\n if self._logverbosity >= 2:\\n self._append_optlog(iter, x, cost, gradnorm=gradnorm)\\n\\n stop_reason = self._check_stopping_criterion(time0, gradnorm=gradnorm, iter=iter + 1, stepsize=stepsize)\\n\\n if stop_reason:\\n if verbosity >= 1:\\n print(stop_reason)\\n print('')\\n break\\n\\n # The line search algorithms require the directional derivative of\\n # the cost at the current point x along the search direction.\\n df0 = man.inner(x, grad, desc_dir)\\n\\n # If we didn't get a descent direction: restart, i.e., switch to\\n # the negative gradient. Equivalent to resetting the CG direction\\n # to a steepest descent step, which discards the past information.\\n if df0 >= 0:\\n # Or we switch to the negative gradient direction.\\n if verbosity >= 3:\\n print(\\\"Conjugate gradient info: got an ascent direction \\\"\\n \\\"(df0 = %.2f), reset to the (preconditioned) \\\"\\n \\\"steepest descent direction.\\\" % df0)\\n # Reset to negative gradient: this discards the CG memory.\\n desc_dir = -Pgrad\\n df0 = -gradPgrad\\n\\n # Execute line search\\n stepsize, newx = linesearch.search(objective, man, x, desc_dir, cost, df0, _Pgrad)\\n\\n # Compute the new cost-related quantities for newx\\n newcost = objective(newx)\\n newgrad = gradient(newx)\\n newgradnorm = man.norm(newx, newgrad)\\n Pnewgrad = problem.precon(newx, newgrad)\\n newgradPnewgrad = man.inner(newx, newgrad, Pnewgrad)\\n\\n # Apply the CG scheme to compute the next search direction\\n oldgrad = man.transp(x, newx, grad)\\n orth_grads = man.inner(newx, oldgrad, Pnewgrad) / newgradPnewgrad\\n\\n # Powell's restart strategy (see page 12 of Hager and Zhang's\\n # survey on conjugate gradient methods, for example)\\n if abs(orth_grads) >= self._orth_value:\\n beta = 0\\n desc_dir = -Pnewgrad\\n else:\\n desc_dir = man.transp(x, newx, desc_dir)\\n if self._beta_type == BetaTypes.DaiYuan:\\n diff = newgrad - oldgrad\\n beta = newgradPnewgrad / man.inner(newx, diff, desc_dir)\\n elif self._beta_type == BetaTypes.PolakRibiere:\\n diff = newgrad - oldgrad\\n ip_diff = man.inner(newx, Pnewgrad, diff)\\n beta = ip_diff / gradPgrad\\n elif self._beta_type == BetaTypes.Hybrid1:\\n diff = newgrad - oldgrad\\n beta_DY = newgradPnewgrad / man.inner(newx, diff, desc_dir)\\n ip_diff = man.inner(newx, Pnewgrad, diff)\\n try:\\n beta_HS = ip_diff / man.inner(newx, diff, desc_dir)\\n except ZeroDivisionError:\\n beta_HS = 1\\n beta = max(0, min(beta_DY, beta_HS))\\n elif self._beta_type == BetaTypes.Hybrid2:\\n diff = newgrad - oldgrad\\n beta_DY = newgradPnewgrad / man.inner(newx, diff, desc_dir)\\n ip_diff = man.inner(newx, Pnewgrad, diff)\\n try:\\n beta_HS = ip_diff / man.inner(newx, diff, desc_dir)\\n except ZeroDivisionError:\\n beta_HS = 1\\n c2 = linesearch.c2\\n beta = max(-(1 - c2) / (1 + c2) * beta_DY, min(beta_DY, beta_HS))\\n else:\\n types = \\\", \\\".join([\\\"BetaTypes.%s\\\" % t for t in BetaTypes._fields])\\n raise ValueError(\\\"Unknown beta_type %s. Should be one of %s.\\\" % (self._beta_type, types))\\n\\n desc_dir = -Pnewgrad + beta * desc_dir\\n\\n # Update the necessary variables for the next iteration.\\n x = newx\\n cost = newcost\\n grad = newgrad\\n Pgrad = Pnewgrad\\n gradnorm = newgradnorm\\n gradPgrad = newgradPnewgrad\\n\\n iter += 1\\n \\n return x, iter + 1, time.time() - time0\",\n \"def optimize(self, args):\\n\\n ############################\\n # Get the data\\n ############################\\n\\n # Read the CSV file ignoring the header and the first column (which\\n # contains the file name of the image used for extracting the data in\\n # a row)\\n try:\\n data = np.genfromtxt(args.featuresFile, delimiter=',',\\n skip_header=1)\\n data = data[:, 1:]\\n except:\\n print('Could not read CSV file: {}'.format(args.featuresFile))\\n return -1\\n\\n x = data[:, :-1]\\n y = np.squeeze(data[:, -1:])\\n\\n ############################\\n # Execute the optimization\\n ############################\\n\\n tunningParams = [\\n {\\n 'kernel': ['linear'],\\n 'C': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3]\\n },\\n {\\n 'kernel': ['rbf'],\\n 'gamma': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3],\\n 'C': [1e-3, 1e-2, 1e-1, 1, 1e+1, 1e+2, 1e+3]\\n },\\n ]\\n\\n scores = ['precision', 'recall']\\n\\n for score in scores:\\n print('# Tuning hyper-parameters for {}\\\\n'.format(score))\\n\\n clf = GridSearchCV(svm.SVC(C=1), tunningParams, cv=5,\\n scoring=format('{}_macro'.format(score)))\\n clf.fit(x, y)\\n\\n print('Best parameters set found on development set:\\\\n')\\n print(clf.best_params_)\\n\\n print('\\\\nGrid scores on development set:\\\\n')\\n means = clf.cv_results_['mean_test_score']\\n stds = clf.cv_results_['std_test_score']\\n for mean, std, params in zip(means, stds, clf.cv_results_['params']):\\n print('{:.3f} (+/-{:.3f}) for {}'.format(mean, std * 2, params))\\n\\n #print('\\\\nDetailed classification report:\\\\n')\\n #print('The model is trained on the full development set.')\\n #print('The scores are computed on the full evaluation set.\\\\n')\\n #y_true, y_pred = y_test, clf.predict(X_test)\\n #print(classification_report(y_true, y_pred))\\n #print()\\n\\n return 0\",\n \"def __init__(self, optimizer='BFGS', optimizer_kwargs=None,\\n lossprime=True, max_iterations = 1000000):\\n\\n user_kwargs = optimizer_kwargs\\n optimizer_kwargs = {}\\n print(f\\\"in {optimizer}: max_iterations = {max_iterations}\\\")\\n if optimizer == 'BFGS':\\n from scipy.optimize import minimize as optimizer\\n optimizer_kwargs = {\\n 'method' : 'BFGS',\\n 'options': {'gtol': 1e-15,\\n 'maxiter': max_iterations}\\n }\\n #optimizer_kwargs = {'method':'BFGS', 'gtol': 1e-15, }\\n elif optimizer == 'L-BFGS-B':\\n from scipy.optimize import minimize as optimizer\\n optimizer_kwargs = {\\n 'method': 'L-BFGS-B',\\n 'options': {'ftol': 1e-05,\\n 'gtol': 1e-08,\\n 'maxfun': max_iterations,\\n 'maxiter': max_iterations}\\n }\\n import scipy\\n from distutils.version import StrictVersion\\n if StrictVersion(scipy.__version__) >= StrictVersion('0.17.0'):\\n optimizer_kwargs['options']['maxls'] = 2000\\n elif optimizer == 'TNC':\\n from scipy.optimize import minimize as optimizer\\n optimizer_kwargs = {\\n 'method': 'TNC',\\n 'options': {'ftol': 0.,\\n 'xtol': 0.,\\n 'gtol': 1e-08,\\n 'maxiter': max_iterations, }\\n }\\n elif optimizer == 'Newton-CG':\\n from scipy.optimize import minimize as optimizer\\n optimizer_kwargs = {\\n 'method': 'Newton-CG',\\n 'options': {'xtol': 1e-15,\\n 'maxiter': max_iterations,}\\n }\\n\\n elif optimizer == 'Nelder-Mead':\\n from scipy.optimize import minimize as optimizer\\n optimizer_kwargs = {\\n 'method': 'Nelder-Mead',\\n 'options': {'maxfun': max_iterations,\\n 'maxiter': max_iterations, }\\n }\\n lossprime = False\\n\\n if user_kwargs:\\n optimizer_kwargs.update(user_kwargs)\\n self.optimizer = optimizer\\n self.optimizer_kwargs = optimizer_kwargs\\n self.lossprime = lossprime\",\n \"def RunParallelSteps(steps, max_parallel=None, halt_on_error=False,\\n return_values=False):\\n def ReturnWrapper(queue, fn):\\n \\\"\\\"\\\"Put the return value of |fn| into |queue|.\\\"\\\"\\\"\\n queue.put(fn())\\n\\n full_steps = []\\n queues = []\\n with cros_build_lib.ContextManagerStack() as stack:\\n if return_values:\\n # We use a managed queue here, because the child process will wait for the\\n # queue(pipe) to be flushed (i.e., when items are read from the queue)\\n # before exiting, and with a regular queue this may result in hangs for\\n # large return values. But with a managed queue, the manager process will\\n # read the items and hold on to them until the managed queue goes out of\\n # scope and is cleaned up.\\n manager = stack.Add(Manager)\\n for step in steps:\\n queue = manager.Queue()\\n queues.append(queue)\\n full_steps.append(functools.partial(ReturnWrapper, queue, step))\\n else:\\n full_steps = steps\\n\\n with _BackgroundTask.ParallelTasks(full_steps, max_parallel=max_parallel,\\n halt_on_error=halt_on_error):\\n pass\\n\\n if return_values:\\n return [queue.get_nowait() for queue in queues]\",\n \"def evaluate(Agent, rules, wrappers, params_path=None, steps=1024):\\n\\n score = 0.0\\n\\n agent = Agent()\\n\\n if params_path is not None:\\n agent.load_state_dict(params_path)\\n\\n env = CARLE()\\n\\n\\n for wrapper in wrappers:\\n env = wrapper[0](env)\\n env.reward_scale = wrapper[1]\\n\\n env.batch_size = steps*len(rules)\\n\\n if wrapper[2] is not None:\\n env.load_state_dict(torch.load(wrapper[2]))\\n\\n env.eval()\\n\\n #env.set_no_grad()\\n\\n total_steps = 0\\n score_trace = []\\n for ruleset in rules:\\n\\n env.inner_env.birth = ruleset[0]\\n env.inner_env.survive = ruleset[0]\\n\\n obs = env.reset()\\n\\n for step in range(steps):\\n\\n action = agent(obs)\\n\\n obs, reward, done, info = env.step(action)\\n\\n score += reward.detach().sum().cpu().numpy()\\n score_trace.append(reward.detach().sum().cpu().numpy())\\n\\n total_steps += 1\\n\\n print(\\\"cumulative score = {:.3e} at total steps = {}, rulset = {}\\\".format(\\\\\\n score, total_steps, ruleset))\\n\\n score /= total_steps\\n \\n return score, score_trace\",\n \"def clgrad(obj, exe, arg, delta=DELTA):\\n f, x = get_method_and_copy_of_attribute(obj, exe, arg)\\n def grad_f(*args, **kwargs):\\n grad_val = numpy.zeros(x.shape)\\n it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])\\n for xi in it:\\n i = it.multi_index\\n xi += delta/2\\n fp = f(*args, **kwargs)\\n xi -= delta\\n fm = f(*args, **kwargs)\\n xi += delta/2\\n grad_val[i] = (fp - fm)/delta\\n return grad_val\\n return grad_f\",\n \"def optimize_svr(data, targets):\\r\\n def svc_crossval(C,epsilon,loss_n):\\r\\n\\r\\n return svc_cv(C=C, epsilon=epsilon,loss_n=loss_n, data=data, targets=targets)\\r\\n\\r\\n optimizer = BayesianOptimization(\\r\\n f=svc_crossval,\\r\\n pbounds={\\\"C\\\": (0.0001, 1000), \\\"epsilon\\\": (0, 0.2),'loss_n':(0,1)},\\r\\n random_state=1234,\\r\\n verbose=2\\r\\n )\\r\\n logger=JSONLogger(path=\\\"./linsvrlogs.json\\\")\\r\\n optimizer.subscribe(Events.OPTMIZATION_STEP,logger)\\r\\n optimizer.maximize(init_points=50,n_iter=300)\\r\\n with open('./linsvrlogs.json','a',encoding='utf-8')as f:\\r\\n f.write(str(optimizer.max))\",\n \"def minimize_neldermead(func, x0, args=(), callback=None,\\n maxiter=None, maxfev=None, disp=False,\\n return_all=False, initial_simplex=None,\\n xatol=1e-4, fatol=1e-4, **unknown_options):\\n maxfun = maxfev\\n retall = return_all\\n\\n rho = 1\\n chi = 2\\n psi = 0.5\\n sigma = 0.5\\n nonzdelt = 0.05\\n zdelt = 0.00025\\n\\n if initial_simplex is None:\\n N = len(x0)\\n\\n sim = numpy.zeros((N + 1, N), dtype=x0.dtype)\\n sim[0] = x0\\n for k in range(N):\\n y = numpy.array(x0, copy=True)\\n if y[k] != 0:\\n y[k] = (1 + nonzdelt) * y[k]\\n else:\\n y[k] = zdelt\\n sim[k + 1] = y\\n\\n maxiter = 10\\n maxfun = 10\\n\\n one2np1 = list(range(1, N + 1))\\n fsim = numpy.zeros((N + 1,), float)\\n\\n for k in range(N + 1):\\n fsim[k] = func(sim[k])\\n\\n ind = numpy.argsort(fsim)\\n fsim = numpy.take(fsim, ind, 0)\\n # sort so sim[0,:] has the lowest function value\\n sim = numpy.take(sim, ind, 0)\\n raise Exception()\\n print('aaaaffaaaaaa')\\n\\n iterations = 1\\n\\n while iterations < maxiter:\\n if (numpy.max(numpy.ravel(numpy.abs(sim[1:] - sim[0]))) <= xatol and\\n numpy.max(numpy.abs(fsim[0] - fsim[1:])) <= fatol):\\n break\\n logger.debug('itr: %s' % iterations)\\n print('aaaaaaaaaa')\\n xbar = numpy.add.reduce(sim[:-1], 0) / N\\n xr = (1 + rho) * xbar - rho * sim[-1]\\n fxr = func(xr)\\n doshrink = 0\\n\\n if fxr < fsim[0]:\\n xe = (1 + rho * chi) * xbar - rho * chi * sim[-1]\\n fxe = func(xe)\\n\\n if fxe < fxr:\\n sim[-1] = xe\\n fsim[-1] = fxe\\n else:\\n sim[-1] = xr\\n fsim[-1] = fxr\\n else: # fsim[0] <= fxr\\n if fxr < fsim[-2]:\\n sim[-1] = xr\\n fsim[-1] = fxr\\n else: # fxr >= fsim[-2]\\n # Perform contraction\\n if fxr < fsim[-1]:\\n xc = (1 + psi * rho) * xbar - psi * rho * sim[-1]\\n fxc = func(xc)\\n\\n if fxc <= fxr:\\n sim[-1] = xc\\n fsim[-1] = fxc\\n else:\\n doshrink = 1\\n else:\\n # Perform an inside contraction\\n xcc = (1 - psi) * xbar + psi * sim[-1]\\n fxcc = func(xcc)\\n\\n if fxcc < fsim[-1]:\\n sim[-1] = xcc\\n fsim[-1] = fxcc\\n else:\\n doshrink = 1\\n\\n if doshrink:\\n for j in one2np1:\\n sim[j] = sim[0] + sigma * (sim[j] - sim[0])\\n fsim[j] = func(sim[j])\\n\\n ind = numpy.argsort(fsim)\\n sim = numpy.take(sim, ind, 0)\\n fsim = numpy.take(fsim, ind, 0)\\n if callback is not None:\\n callback(sim[0])\\n iterations += 1\\n\\n x = sim[0]\\n fval = numpy.min(fsim)\\n warnflag = 0\\n\\n result = OptimizeResult(fun=fval, nit=iterations, nfev=0,\\n status=warnflag, success=(warnflag == 0),\\n message=None, x=x, final_simplex=(sim, fsim))\\n return result\",\n \"def optimize_mlp(data, targets):\\r\\n def mlp_crossval(h1,h2,h3,ac,so):\\r\\n\\r\\n return mlp(\\r\\n h1=int(h1),\\r\\n h2=int(h2),\\r\\n h3=int(h3),\\r\\n ac=ac,\\r\\n so=so,\\r\\n data=data,\\r\\n targets=targets,\\r\\n )\\r\\n\\r\\n optimizer = BayesianOptimization(\\r\\n f=mlp_crossval,\\r\\n pbounds={\\r\\n \\\"h1\\\": (1, 300),\\r\\n \\\"h2\\\": (1, 300),\\r\\n \\\"h3\\\": (1, 300),\\r\\n \\\"ac\\\":(0,3),\\r\\n 'so': (0,3)\\r\\n },\\r\\n random_state=1234,\\r\\n verbose=2\\r\\n )\\r\\n logger=JSONLogger(path=\\\"./MLPreglogs.json\\\")\\r\\n optimizer.subscribe(Events.OPTMIZATION_STEP,logger)\\r\\n optimizer.maximize(init_points=50,n_iter=300)\\r\\n with open('./MLPreglogs.json','a',encoding='utf-8')as f:\\r\\n f.write(str(optimizer.max))\",\n \"def projected_gradient_descent(self, x, y):\\n x_adv = x.clone().detach().requires_grad_(True).to(x.device)\\n targeted = self.y_target is not None\\n num_channels = x.shape[1]\\n\\n if self.random:\\n x_adv = random_perturbation(x_adv, self.norm, self.eps)\\n\\n for i in range(self.num_steps):\\n _x_adv = x_adv.clone().detach().requires_grad_(True)\\n\\n prediction = self.model(_x_adv)\\n loss = self.loss_fn(prediction, self.y_target if targeted else y)\\n loss.backward()\\n\\n with torch.no_grad():\\n # Force the gradient step to be a fixed size in a certain norm\\n if self.norm == 'inf':\\n gradients = _x_adv.grad.sign() * self.step_size\\n else:\\n # Note .view() assumes batched image data as 4D tensor\\n gradients = _x_adv.grad * self.step_size / _x_adv.grad.view(\\n _x_adv.shape[0], -1) \\\\\\n .norm(self.norm, dim=-1) \\\\\\n .view(-1, num_channels, 1, 1)\\n\\n if targeted:\\n # Targeted: Gradient descent with on the loss of the (incorrect) target label\\n # w.r.t. the image data\\n x_adv -= gradients\\n else:\\n # Untargeted: Gradient ascent on the loss of the correct label w.r.t.\\n # the model parameters\\n x_adv += gradients\\n\\n # Project back into l_norm ball and correct range\\n if self.norm == 'inf':\\n # Workaround as PyTorch doesn't have elementwise clip\\n x_adv = torch.max(torch.min(x_adv, x + self.eps), x - self.eps)\\n else:\\n delta = x_adv - x\\n\\n # Assume x and x_adv are batched tensors where the first dimension is\\n # a batch dimension\\n mask = delta.view(delta.shape[0], -1).norm(self.norm,\\n dim=1) <= self.eps\\n\\n scaling_factor = delta.view(delta.shape[0], -1).norm(self.norm,\\n dim=1)\\n scaling_factor[mask] = self.eps\\n\\n # .view() assumes batched images as a 4D Tensor\\n delta *= self.eps / scaling_factor.view(-1, 1, 1, 1)\\n\\n x_adv = x + delta\\n\\n x_adv = x_adv.clamp(*self.clamp)\\n\\n return x_adv.detach()\",\n \"def downhill(F, xStart, args=None, side=0.1, ftol=1.0e-6, xtol=1.0e-6, maxiter=1000, maxfunc=1000, maxiternochange=10):\\n # TODO: check the types of the input ???\\n\\n # print \\\"Entering downhill\\\"\\n n = len(xStart)\\n x = np.zeros((n+1, n), dtype=float) #point null matrix, n+1 rows, n columns\\n f = np.zeros(n+1, dtype=float) # null vector, n+1 columns\\n p_count = 0 # counter for detecting a plateau\\n f_count = 0 # counter for the number of function call\\n f_best_count = 0 # counter for the number of iterations in which the best solution does not change\\n f_best_prev = 0.0 # holds the best value from the previous iteration\\n epsilon = 0.001 # tolerance for considering two values as equal\\n # max_iter_no_change = 10 # maximum number of accepted iterations with no change in the optimal solution\\n precision = 2\\n round_map = partial(round, ndigits=precision) # partial function for rounding purposes\\n\\n # initial simplex\\n x[0] = xStart\\n for i in xrange(1, n+1):\\n x[i] = xStart\\n x[i,i-1] = xStart[i-1] + side\\n\\n # print \\\"Evaluate the starting points\\\"\\n # compute the value of F at the vertices of the simplex\\n for i in xrange(n+1):\\n f[i] = F(x[i], args)\\n # p_count += 1\\n\\n # main loop\\n # print \\\"Start iterating\\\"\\n for k in xrange(maxiter):\\n\\n # check the number of function calls\\n if f_count > maxfunc:\\n print \\\"Stopping criteria: maximum number of function calls\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXFUNCALL'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXFUNCALL'}\\n\\n # find the best and worst vertex (consider a minimization problem)\\n iLo = np.argmin(f) # best vertex\\n iHi = np.argmax(f) # worst vertex\\n\\n # print k,\\\" \\\", f[iLo]\\n #\\n # if f[iLo] < -0.310000:\\n # print f[iLo]\\n # print x[iLo]\\n # print x\\n # sys.exit(1)\\n # print \\\"k: \\\", k, \\\" f_best_prev: \\\", f_best_prev, \\\" f[iLo]: \\\", f[iLo], \\\" f_best_count: \\\", f_best_count\\n # print \\\"Beginning of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\\\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\\n # print \\\"x: \\\", x, \\\" f: \\\", f\\n # print \\\"=========================================================================================\\\"\\n # check if the solution has changed from the previous iterations\\n if f[iLo] < f_best_prev:\\n f_best_prev = f[iLo]\\n f_best_count = 0\\n else:\\n f_best_count += 1\\n\\n if f_best_count > maxiternochange:\\n print \\\"Stopping criteria: maximum number of iterations with no improvement in the best solution\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'NOIMPROVEMENT'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'NOIMPROVEMENT'}\\n\\n if abs(f[iLo] - f[iHi]) < ftol: # If difference between highest and lowest is smaller than ftol, return\\n print \\\"Stopping criteria: difference between highest and lowest points is smaller than tolerance\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXTOLERANCE'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXTOLERANCE'}\\n # compute the move vector d\\n d = (-(n+1) * x[iHi] + np.sum(x, axis=0)) / n\\n # print \\\"d: \\\", d\\n\\n # check for convergence\\n if sqrt(np.dot(d, d)/n) < xtol: # length of the vector d\\n print \\\"Stopping criteria: length of step d smaller than tolerance\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'SMALLSTEP'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'SMALLSTEP'}\\n # try reflection\\n xNew = np.array(map(round_map, x[iHi] + 2 * d))\\n fNew = F(xNew, args)\\n f_count += 1\\n # print \\\"Reflected point: \\\", xNew, \\\" value: \\\", fNew\\n\\n # check for no improvement over the worst point\\n # and for plateau condition\\n if f[iHi] - epsilon <= fNew <= f[iHi] + epsilon:\\n p_count += 1\\n # print \\\"No improvement here\\\"\\n\\n if p_count == n+2: # we reflected all vertices with no improvement\\n print \\\"Stopping criteria: Probably we landed on a plateau... exiting\\\" # TODO: restart instead of exiting\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'PLATEAU'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'PLATEAU'}\\n\\n\\n else:\\n p_count = 0\\n\\n\\n if fNew <= f[iLo]: # if the new value is better than the best so far,\\n x[iHi] = xNew # substitute the worst vertex with the new one\\n f[iHi] = fNew\\n\\n # try to expand the reflection\\n xNew = np.array(map(round_map, x[iHi] + d))\\n fNew = F(xNew, args)\\n f_count += 1\\n # print \\\"Expanded point: \\\", xNew, \\\" value: \\\", fNew\\n\\n if fNew <= f[iHi]: # in the original source version it is f[iLo] (?)\\n x[iHi] = xNew\\n f[iHi] = fNew\\n else:\\n # try reflection again\\n if fNew <= f[iHi]:\\n x[iHi] = xNew\\n f[iHi] = fNew\\n else:\\n # try contraction\\n xNew = np.array(map(round_map, x[iHi] + 0.5 * d))\\n fNew = F(xNew, args)\\n f_count += 1\\n # print \\\"Contracted point: \\\", xNew, \\\" value: \\\", fNew\\n\\n if fNew <= f[iHi]: # accept contraction\\n x[iHi] = xNew\\n f[iHi] = fNew\\n else:\\n # shrink\\n for i in xrange(len(x)):\\n if i != iLo:\\n x[i] = np.array(map(round_map, x[i] - x[iLo] * 0.5))\\n f[i] = F(x[i], args)\\n f_count += 1\\n\\n # print \\\"End of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\\\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\\n # print \\\"x: \\\", x, \\\" f: \\\", f\\n # print \\\"*\\\"*50\\n # print \\\"\\\"\\n\\n\\n\\n print \\\"Stopping criteria: maximum number of iterations\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXITERATION'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXITERATION'}\",\n \"def maximize(self,x0,method='fmin',**kwargs):\\n return self._optimize(x0,'max',method,**kwargs)\",\n \"def minimize(self, func, grad, x0, args=()):\\n learning_rate = self._learning_rate\\n best_x = x = x0\\n best_value = func(x, *args)\\n iters_without_improve = 0\\n\\n for iteration in range(self._max_iterations):\\n gradient = grad(x, *args)\\n\\n # If absolute values of all partial derivatives are equal to 0 with specified accuracy, then parameters are\\n # close enough to the minimum and there is no need to continue gradient descent.\\n if np.abs(gradient).max() <= self._accuracy:\\n break\\n\\n x = x - learning_rate * gradient\\n\\n # If new values of x haven't lead to decrease of the function value for the specified number of iteration,\\n # the x is reverted to its previous best value and the learning rate is reduced\\n value = func(x, *args)\\n if value > best_value:\\n iters_without_improve += 1\\n if iters_without_improve >= self._lr_reduce_patience:\\n x = best_x\\n learning_rate *= self._lr_reduce_factor\\n else:\\n iters_without_improve = 0\\n best_value = value\\n best_x = x\\n\\n return best_x\",\n \"def lbfgs(self, pstart, Nepochs=50, bounds=None, disp_p=False,\\n maxfun=15000, args=(), pass_self=False, res=False,\\n callback=None):\\n\\n self.params = pstart\\n self.bounds = self._parse_bounds(bounds)\\n self.Nepochs = Nepochs\\n self.disp_p = disp_p \\n\\n # Restart the counters\\n self.iteration = 0\\n self.t_store = time.time()\\n self.of_list = []\\n\\n # Get initial of value\\n of = self.objective(self.params, *args)\\n self.of_list.append(self._get_value(of)) \\n\\n def of(params, *args, **kwargs):\\n \\\"\\\"\\\"Modify the objective function slightly to allow storing\\n intermediate objective values without re-evaluating the function\\n \\\"\\\"\\\"\\n if pass_self == True:\\n arglist = list(args)\\n arglist.append(self)\\n args = tuple(arglist)\\n\\n out = value_and_grad(self.objective)(params, *args, **kwargs)\\n self.of_last = self._get_value(out[0])\\n return out\\n\\n def cb(xk):\\n \\\"\\\"\\\"Callback function for the SciPy minimizer\\n \\\"\\\"\\\"\\n self.iteration += 1\\n t_current = time.time()\\n t_elapsed = t_current - self.t_store\\n self.t_store = t_current\\n \\n self.of_list.append(self.of_last)\\n self.params = xk\\n self._disp(t_elapsed)\\n\\n # Call the custom callback function if any\\n if callback is not None:\\n callback(self)\\n\\n res_opt = minimize(of, self.params, args=args, method='L-BFGS-B',\\n jac=True, bounds=self.bounds, tol=None, callback=cb,\\n options={'disp': False,\\n 'maxcor': 10,\\n 'ftol': 1e-8,\\n 'gtol': 1e-5,\\n 'eps': 1e-08,\\n 'maxfun': maxfun,\\n 'maxiter': Nepochs,\\n 'iprint': -1,\\n 'maxls': 20})\\n\\n if res == False:\\n return (res_opt.x, self.of_list)\\n else:\\n return (res_opt.x, self.of_list, res_opt)\",\n \"def find_mle_by_grad_descent(initial_sensor_loc, \\n\\t\\t obj_loc, distance, lr=0.001, num_iters = 1000): \\n\\tsensor_loc = initial_sensor_loc\\n\\t# Your code: finish the gradient descent\\n\\n\\treturn sensor_loc\",\n \"def optimize_gp_hyperparams(x, y, optimization_steps, learning_rate,\\r\\n kernel=rational_quadratic_kernel_torch, params=None):\\r\\n x = np.array(x).reshape(-1, 1)\\r\\n y = np.array(y).reshape(-1, 1)\\r\\n N = len(x)\\r\\n\\r\\n # tranform our training set in Tensor\\r\\n x_tensor = torch.from_numpy(x).float()\\r\\n y_tensor = torch.from_numpy(y).float()\\r\\n\\r\\n # we should define our hyperparameters as torch parameters where we keep track of\\r\\n # the operations to get hte gradients from them\\r\\n m = np.abs(y[-1][0])\\r\\n mu = torch.tensor(m).float()\\r\\n s = np.var(y)\\r\\n sig = torch.tensor(s).float()\\r\\n if params:\\r\\n lambda_param = nn.Parameter(torch.tensor(params['ls']), requires_grad=True)\\r\\n alpha_param = nn.Parameter(torch.tensor(params['a']), requires_grad=True)\\r\\n output_variance = nn.Parameter(torch.tensor(params['ov']), requires_grad=True)\\r\\n noise_variance = nn.Parameter(torch.tensor(params['nv']), requires_grad=True)\\r\\n mu_param = nn.Parameter(torch.tensor(params['mu']), requires_grad=True)\\r\\n sig_param = nn.Parameter(torch.tensor(params['sig']), requires_grad=True)\\r\\n\\r\\n else:\\r\\n lambda_param = nn.Parameter(torch.tensor(1.), requires_grad=True)\\r\\n alpha_param = nn.Parameter(torch.tensor(1.), requires_grad=True)\\r\\n output_variance = nn.Parameter(torch.tensor(1.), requires_grad=True)\\r\\n noise_variance = nn.Parameter(torch.tensor(2.5), requires_grad=True)\\r\\n mu_param = nn.Parameter(mu, requires_grad=True)\\r\\n sig_param = nn.Parameter(sig, requires_grad=True)\\r\\n\\r\\n # we use Adam as optimizer\\r\\n optim = torch.optim.Adam([lambda_param, alpha_param, output_variance,\\r\\n noise_variance, mu_param, sig_param], lr=learning_rate)\\r\\n\\r\\n # optimization loop using the log-likelihood that involves the cholesky decomposition\\r\\n nlls = []\\r\\n lambdas = []\\r\\n output_variances = []\\r\\n noise_variances = []\\r\\n iterations = optimization_steps\\r\\n for i in range(iterations):\\r\\n if lambda_param.item() == lambda_param.item():\\r\\n return_dict = {'ls': lambda_param.item(),\\r\\n 'a': alpha_param.item(),\\r\\n 'ov': output_variance.item(),\\r\\n 'nv': noise_variance.item(),\\r\\n 'mu': mu_param.item(),\\r\\n 'sig': sig_param.item()}\\r\\n assert noise_variance >= 0, f\\\"ouch! {i, noise_variance}\\\"\\r\\n optim.zero_grad()\\r\\n K = kernel(x_tensor, x_tensor, lambda_param, alpha_param,\\r\\n output_variance) + noise_variance * torch.eye(N)\\r\\n try:\\r\\n cholesky = torch.cholesky(K)\\r\\n _alpha_temp, _ = torch.solve(y_tensor, cholesky)\\r\\n _alpha, _ = torch.solve(_alpha_temp, cholesky.t())\\r\\n except:\\r\\n return return_dict\\r\\n nll = N / 2 * torch.log(torch.tensor(2 * np.pi)) + 0.5 * torch.matmul(y_tensor.transpose(0, 1), _alpha) + \\\\\\r\\n torch.sum(torch.log(torch.diag(cholesky)))\\r\\n\\r\\n # we have to add the log-likelihood of the prior\\r\\n norm = distributions.Normal(loc=m, scale=s)\\r\\n prior_negloglike = torch.log(lambda_param) - torch.log(torch.exp(norm.log_prob(lambda_param)))\\r\\n\\r\\n nll += 0.9 * prior_negloglike\\r\\n nll.backward()\\r\\n\\r\\n nlls.append(nll.item())\\r\\n lambdas.append(lambda_param.item())\\r\\n output_variances.append(output_variance.item())\\r\\n noise_variances.append(noise_variance.item())\\r\\n optim.step()\\r\\n\\r\\n # projected in the constraints (lengthscale and output variance should be positive)\\r\\n for p in [lambda_param, output_variance]:\\r\\n p.data.clamp_(min=0.0000001)\\r\\n noise_variance.data.clamp_(min=0.001, max=0.05)\\r\\n alpha_param.data.clamp_(min=0.001, max=0.1)\\r\\n # mu_param.data.clamp_(min=0.01, max=40)\\r\\n # sig_param.data.clamp_(min=0.01, max=40)\\r\\n\\r\\n return_dict = {'ls': lambda_param.item(),\\r\\n 'a': alpha_param.item(),\\r\\n 'ov': output_variance.item(),\\r\\n 'nv': noise_variance.item(),\\r\\n 'mu': mu_param.item(),\\r\\n 'sig': sig_param.item()}\\r\\n\\r\\n return return_dict\",\n \"def inner_recompute_grad(*dresult):\\n # Gradient calculation for reverse mode autodiff.\\n with backprop.GradientTape() as t:\\n id_args = nest.map_structure(gen_array_ops.identity, args)\\n # Tuple `dresult` should contain at least one tensor.\\n assert len(dresult) >= 1\\n\\n if not context.executing_eagerly():\\n # XLA doesn't respect `tf.control_dependencies`. The code block\\n # below manually adds a data dependency to `dresult` to ensure\\n # recomputation of `f(*args, **kwargs)` happens after `dresult`.\\n\\n # This works even if `dresult[0]` is a size 0 tensor as reduce_max\\n # of a size 0 tensor returns -inf. Use reshape here to avoid reading\\n # the entire `dresult[0]`.\\n elem = math_ops.reduce_max(array_ops.reshape(dresult[0], [-1])[:1])\\n # Cast elem to bool in case elem is NaN.\\n elem_bool = math_ops.cast(elem, dtypes.bool)\\n dresult_dep = array_ops.where_v2(\\n elem_bool == elem_bool, 0., float(\\\"nan\\\")) # pylint: disable=comparison-with-itself\\n id_args = nest.map_structure(\\n lambda x: x + math_ops.cast(dresult_dep, x.dtype), id_args)\\n\\n t.watch(id_args)\\n if variables is not None:\\n t.watch(variables)\\n with variable_scope.variable_scope(current_var_scope):\\n recomputed_result = f(*id_args, **kwargs)\\n kw_vars = []\\n if variables is not None:\\n kw_vars = list(variables)\\n grads = t.gradient(\\n recomputed_result,\\n list(id_args) + kw_vars,\\n output_gradients=dresult,\\n unconnected_gradients=UnconnectedGradients.ZERO)\\n\\n def transpose(*t_args, **t_kwargs):\\n \\\"\\\"\\\"Gradient function calculation for forward mode autodiff.\\\"\\\"\\\"\\n # Just throw an error since gradients / activations are not stored on\\n # tape for recompute.\\n raise NotImplementedError(\\n \\\"recompute_grad tried to transpose grad of {}. \\\"\\n \\\"Consider not using recompute_grad in forward mode\\\"\\n \\\"autodiff\\\".format(f.__name__))\\n\\n return (grads[:len(id_args)], grads[len(id_args):]), transpose\",\n \"def optimizer(targets_float32, predictions_float32, learning_rate, global_step, coeff_l2_norm_pred_error, coeff_grad_error, scope):\\n if coeff_l2_norm_pred_error < 0.:\\n raise ValueError('`coeff_l2_norm_pred_error` is not positive.')\\n if coeff_grad_error < 0.:\\n raise ValueError('`coeff_grad_error` is not positive.')\\n if not coeff_l2_norm_pred_error and not coeff_grad_error:\\n raise ValueError('`coeff_l2_norm_pred_error` and `coeff_grad_error` are equal to 0.')\\n \\n # If `coeff_l2_norm_pred_error` is equal to 0.0, we\\n # should not allocate memory for the computation of\\n # the l2-norm prediction error. Similarly, if `coeff_grad_error`\\n # is equal to 0.0, we should not allocate memory for\\n # the computation of the gradient error.\\n loss_float32 = tf.constant(0.,\\n dtype=tf.float32)\\n dict_errors = {}\\n if coeff_l2_norm_pred_error:\\n dict_errors['l2_norm_pred_error'] = coeff_l2_norm_pred_error*pnn.tfutils.prediction_error_l2_norm(targets_float32,\\n predictions_float32)\\n loss_float32 += dict_errors['l2_norm_pred_error']\\n if coeff_grad_error:\\n dict_errors['grad_error'] = coeff_grad_error*pnn.tfutils.prediction_error_gradient(targets_float32,\\n predictions_float32)\\n loss_float32 += dict_errors['grad_error']\\n weight_decay = 5.e-4*weight_l2_norm()\\n loss_float32 += weight_decay\\n optimization = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(\\n loss_float32,\\n var_list=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=scope),\\n global_step=global_step\\n )\\n return (dict_errors, weight_decay, optimization)\",\n \"def Solve(self, cost, termination=None, ExtraArgs=(), **kwds):\\n # process and activate input settings\\n sigint_callback = kwds.pop('sigint_callback', None)\\n settings = self._process_inputs(kwds)\\n disp = settings['disp'] if 'disp' in settings else False\\n echo = settings['callback'] if 'callback' in settings else None\\n# for key in settings:\\n# exec \\\"%s = settings['%s']\\\" % (key,key)\\n if disp in ['verbose', 'all']: verbose = True\\n else: verbose = False\\n #-------------------------------------------------------------\\n\\n from python_map import python_map\\n if self._map != python_map:\\n #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp'\\n from mystic.monitors import Null\\n evalmon = Null()\\n else: evalmon = self._evalmon\\n fcalls, cost = wrap_function(cost, ExtraArgs, evalmon)\\n\\n # set up signal handler\\n #self._EARLYEXIT = False\\n self._generateHandler(sigint_callback) \\n\\n # activate signal_handler\\n #import threading as thread\\n #mainthread = isinstance(thread.current_thread(), thread._MainThread)\\n #if mainthread: #XXX: if not mainthread, signal will raise ValueError\\n import signal\\n if self._handle_sigint:\\n signal.signal(signal.SIGINT,self.signal_handler)\\n\\n # register termination function\\n if termination is not None: self.SetTermination(termination)\\n\\n # get the nested solver instance\\n solver = self._AbstractEnsembleSolver__get_solver_instance()\\n #-------------------------------------------------------------\\n\\n # generate starting points\\n initial_values = self._InitialPoints()\\n\\n # run optimizer for each grid point\\n from copy import deepcopy as _copy\\n op = [_copy(solver) for i in range(len(initial_values))]\\n #cf = [cost for i in range(len(initial_values))]\\n vb = [verbose for i in range(len(initial_values))]\\n cb = [echo for i in range(len(initial_values))] #XXX: remove?\\n at = self.id if self.id else 0 # start at self.id\\n id = range(at,at+len(initial_values))\\n\\n # generate the local_optimize function\\n def local_optimize(solver, x0, rank=None, disp=False, callback=None):\\n from copy import deepcopy as _copy\\n from mystic.tools import isNull\\n solver.id = rank\\n solver.SetInitialPoints(x0)\\n if solver._useStrictRange: #XXX: always, settable, or sync'd ?\\n solver.SetStrictRanges(min=solver._strictMin, \\\\\\n max=solver._strictMax) # or lower,upper ?\\n solver.Solve(cost, disp=disp, callback=callback)\\n sm = solver._stepmon\\n em = solver._evalmon\\n if isNull(sm): sm = ([],[],[],[])\\n else: sm = (_copy(sm._x),_copy(sm._y),_copy(sm._id),_copy(sm._info))\\n if isNull(em): em = ([],[],[],[])\\n else: em = (_copy(em._x),_copy(em._y),_copy(em._id),_copy(em._info))\\n return solver, sm, em\\n\\n # map:: solver = local_optimize(solver, x0, id, verbose)\\n results = self._map(local_optimize, op, initial_values, id, \\\\\\n vb, cb, **self._mapconfig)\\n\\n # save initial state\\n self._AbstractSolver__save_state()\\n #XXX: HACK TO GET CONTENT OF ALL MONITORS\\n # reconnect monitors; save all solvers\\n from mystic.monitors import Monitor\\n while results: #XXX: option to not save allSolvers? skip this and _copy\\n _solver, _stepmon, _evalmon = results.pop()\\n sm = Monitor()\\n sm._x,sm._y,sm._id,sm._info = _stepmon\\n _solver._stepmon.extend(sm)\\n del sm\\n em = Monitor()\\n em._x,em._y,em._id,em._info = _evalmon\\n _solver._evalmon.extend(em)\\n del em\\n self._allSolvers[len(results)] = _solver\\n del results, _solver, _stepmon, _evalmon\\n #XXX: END HACK\\n\\n # get the results with the lowest energy\\n self._bestSolver = self._allSolvers[0]\\n bestpath = self._bestSolver._stepmon\\n besteval = self._bestSolver._evalmon\\n self._total_evals = self._bestSolver.evaluations\\n for solver in self._allSolvers[1:]:\\n self._total_evals += solver.evaluations # add func evals\\n if solver.bestEnergy < self._bestSolver.bestEnergy:\\n self._bestSolver = solver\\n bestpath = solver._stepmon\\n besteval = solver._evalmon\\n\\n # return results to internals\\n self.population = self._bestSolver.population #XXX: pointer? copy?\\n self.popEnergy = self._bestSolver.popEnergy #XXX: pointer? copy?\\n self.bestSolution = self._bestSolver.bestSolution #XXX: pointer? copy?\\n self.bestEnergy = self._bestSolver.bestEnergy\\n self.trialSolution = self._bestSolver.trialSolution #XXX: pointer? copy?\\n self._fcalls = self._bestSolver._fcalls #XXX: pointer? copy?\\n self._maxiter = self._bestSolver._maxiter\\n self._maxfun = self._bestSolver._maxfun\\n\\n # write 'bests' to monitors #XXX: non-best monitors may be useful too\\n self._stepmon = bestpath #XXX: pointer? copy?\\n self._evalmon = besteval #XXX: pointer? copy?\\n self.energy_history = None\\n self.solution_history = None\\n #from mystic.tools import isNull\\n #if isNull(bestpath):\\n # self._stepmon = bestpath\\n #else:\\n # for i in range(len(bestpath.y)):\\n # self._stepmon(bestpath.x[i], bestpath.y[i], self.id)\\n # #XXX: could apply callback here, or in exec'd code\\n #if isNull(besteval):\\n # self._evalmon = besteval\\n #else:\\n # for i in range(len(besteval.y)):\\n # self._evalmon(besteval.x[i], besteval.y[i])\\n #-------------------------------------------------------------\\n\\n # restore default handler for signal interrupts\\n if self._handle_sigint:\\n signal.signal(signal.SIGINT,signal.default_int_handler)\\n\\n # log any termination messages\\n msg = self.Terminated(disp=disp, info=True)\\n if msg: self._stepmon.info('STOP(\\\"%s\\\")' % msg)\\n # save final state\\n self._AbstractSolver__save_state(force=True)\\n return\",\n \"def process_solve_kwargs(**kwargs):\\n\\n tol = kwargs.get('tol', DEFAULT_TOL)\\n maxiter = kwargs.get('maxiter', MAX_ITER)\\n Ainv = kwargs.get('Ainv', None)\\n verbose = kwargs.get('verbose', False)\\n\\n if VERBOSE:\\n print(\\\"tol:\\\", tol)\\n print(\\\"maxiter:\\\", maxiter)\\n print(\\\"Ainv:\\\", Ainv)\\n\\n return tol, int(maxiter), Ainv, verbose\",\n \"def maximum(x, y):\\r\\n # see decorator for function body\\r\",\n \"def optimize(model, deep=3, data_version=\\\"version_6\\\", first_loc=1, end_loc=7):\\n if model == \\\"Regressor\\\":\\n # preprocess for MLP preceptron\\n _, _, X_del, y_del, _, _ = \\\\\\n pre_processing.merge_split(data_version=data_version, first_loc=first_loc, end_loc=end_loc)\\n\\n # setup a MLP preceptron\\n regressor = MLPRegressor(solver='lbfgs', random_state=1)\\n\\n # implement hyper search\\n regressor_search = hyper_search.hyper_search(regressor, X_del, y_del, deep=deep, version=data_version)\\n\\n return regressor_search\\n\\n elif model == \\\"Classifier\\\":\\n # preprocess for MLP preceptron\\n _, _, X_del, y_del, _, _ = \\\\\\n pre_processing.merge_split(data_version=data_version, first_loc=first_loc, end_loc=end_loc, regressor=False)\\n\\n # setup a MLP preceptron\\n classifier = MLPClassifier(solver='lbfgs', random_state=1)\\n\\n # implement hyper search\\n classifier_search = hyper_search.hyper_search(classifier, X_del, y_del, deep=deep, version=data_version)\\n\\n return classifier_search\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.651425","0.60995185","0.59783125","0.5357869","0.5349476","0.53483707","0.5300958","0.5280729","0.5255571","0.51577455","0.51000774","0.50822264","0.5080444","0.50465363","0.50355375","0.50104886","0.4993036","0.49904832","0.49328518","0.49109367","0.49103644","0.49053922","0.48841238","0.48546988","0.4821072","0.48169795","0.47867662","0.4776207","0.4774509","0.47604144","0.4758903","0.47574618","0.47568217","0.47492707","0.47464785","0.4737874","0.47333694","0.4725963","0.4701539","0.46833605","0.46828243","0.46796852","0.46691728","0.4665812","0.46489543","0.46435377","0.4641546","0.4628266","0.4623394","0.46214557","0.46194714","0.46149307","0.461404","0.46104255","0.460786","0.4600202","0.46001127","0.4597939","0.4582215","0.458129","0.4580315","0.45772538","0.4576474","0.45735282","0.45711303","0.45701253","0.45686474","0.4568146","0.45494643","0.45473078","0.454513","0.4544663","0.45435613","0.45427823","0.45404446","0.45384118","0.45242354","0.45213","0.45164484","0.4511574","0.45098054","0.45090595","0.45028988","0.44970065","0.4495341","0.44925025","0.4489671","0.44892073","0.4485883","0.4473467","0.44732678","0.44725874","0.44711408","0.44642693","0.44621223","0.4458216","0.44577867","0.4449824","0.4449086","0.44485608"],"string":"[\n \"0.651425\",\n \"0.60995185\",\n \"0.59783125\",\n \"0.5357869\",\n \"0.5349476\",\n \"0.53483707\",\n \"0.5300958\",\n \"0.5280729\",\n \"0.5255571\",\n \"0.51577455\",\n \"0.51000774\",\n \"0.50822264\",\n \"0.5080444\",\n \"0.50465363\",\n \"0.50355375\",\n \"0.50104886\",\n \"0.4993036\",\n \"0.49904832\",\n \"0.49328518\",\n \"0.49109367\",\n \"0.49103644\",\n \"0.49053922\",\n \"0.48841238\",\n \"0.48546988\",\n \"0.4821072\",\n \"0.48169795\",\n \"0.47867662\",\n \"0.4776207\",\n \"0.4774509\",\n \"0.47604144\",\n \"0.4758903\",\n \"0.47574618\",\n \"0.47568217\",\n \"0.47492707\",\n \"0.47464785\",\n \"0.4737874\",\n \"0.47333694\",\n \"0.4725963\",\n \"0.4701539\",\n \"0.46833605\",\n \"0.46828243\",\n \"0.46796852\",\n \"0.46691728\",\n \"0.4665812\",\n \"0.46489543\",\n \"0.46435377\",\n \"0.4641546\",\n \"0.4628266\",\n \"0.4623394\",\n \"0.46214557\",\n \"0.46194714\",\n \"0.46149307\",\n \"0.461404\",\n \"0.46104255\",\n \"0.460786\",\n \"0.4600202\",\n \"0.46001127\",\n \"0.4597939\",\n \"0.4582215\",\n \"0.458129\",\n \"0.4580315\",\n \"0.45772538\",\n \"0.4576474\",\n \"0.45735282\",\n \"0.45711303\",\n \"0.45701253\",\n \"0.45686474\",\n \"0.4568146\",\n \"0.45494643\",\n \"0.45473078\",\n \"0.454513\",\n \"0.4544663\",\n \"0.45435613\",\n \"0.45427823\",\n \"0.45404446\",\n \"0.45384118\",\n \"0.45242354\",\n \"0.45213\",\n \"0.45164484\",\n \"0.4511574\",\n \"0.45098054\",\n \"0.45090595\",\n \"0.45028988\",\n \"0.44970065\",\n \"0.4495341\",\n \"0.44925025\",\n \"0.4489671\",\n \"0.44892073\",\n \"0.4485883\",\n \"0.4473467\",\n \"0.44732678\",\n \"0.44725874\",\n \"0.44711408\",\n \"0.44642693\",\n \"0.44621223\",\n \"0.4458216\",\n \"0.44577867\",\n \"0.4449824\",\n \"0.4449086\",\n \"0.44485608\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77414405"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":10488,"cells":{"query":{"kind":"string","value":"optimizes the current library to maximize the result of the target function using gradient descent from `trials` different staring positions. Only the result from the best run will be returned"},"document":{"kind":"string","value":"def optimize_library_descent_multiple(self, target, direction='max',\n trials=4, multiprocessing=False,\n ret_error=False, **kwargs):\n \n # pass some parameters down to the optimization function to call\n kwargs['target'] = target\n kwargs['direction'] = direction\n \n # initialize the list of jobs with an optimization job starting from the\n # current interaction matrix\n joblist = [(self.init_arguments, 'optimize_library_descent', kwargs)]\n sens_mat = self.sens_mat #< store matrix to restore it later\n\n # set the ensemble of sensitivity matrices to try\n self.choose_sensitivity_matrix(density='auto')\n self.parameters['initialize_state']['sensitivity'] = 'ensemble'\n\n # add additional jobs with random initial interaction matrices\n init_arguments = self.init_arguments\n for _ in range(trials - 1):\n joblist.append((copy.deepcopy(init_arguments),\n 'optimize_library_descent', kwargs))\n \n # restore interaction matrix of this object\n self.sens_mat = sens_mat\n \n if multiprocessing:\n # calculate all results in parallel\n pool = mp.Pool(processes=self.get_number_of_cores())\n result_iter = pool.imap_unordered(_run_job, joblist)\n \n else:\n # create a generator over which we iterate later\n result_iter = (_run_job(job) for job in joblist)\n \n # find the best result by iterating over all results\n result_best, values = None, []\n for result in result_iter:\n values.append(result[0])\n # check whether this run improved the result\n if result_best is None:\n result_best = result\n elif ((direction == 'max' and result[0] > result_best[0]) or\n (direction == 'min' and result[0] < result_best[0])):\n result_best = result\n \n # sort the best state and store it in the current object\n state = self.sort_sensitivity_matrix(result_best[1])\n self.sens_mat = state.copy()\n\n if ret_error:\n # replace the best value by a tuple of the best value and its error\n value_best = result_best[0]\n value_err = np.abs(value_best - np.median(values))\n result_best = ((value_best, value_err), ) + result_best[1:]\n return result_best"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def optimize(\n # trials,\n random_state=SEED):\n\n space = {\n 'max_depth': scope.int(hp.uniform('max_depth', 5, 15)),\n 'subsample': hp.uniform('subsample', 0.03, 1),\n 'learning_rate' : hp.loguniform('learning_rate', np.log(0.005), np.log(0.5)) - 0.0001,\n 'colsample_bytree': hp.uniform('colsample_bytree', 0.3, 1),\n 'reg_alpha': hp.loguniform('reg_alpha', np.log(0.005), np.log(5)) - 0.0001,\n 'reg_lambda': hp.loguniform('reg_lambda', np.log(1), np.log(5)),\n 'bagging_freq': hp.choice('bagging_freq', [0, 1]),\n 'num_leaves': scope.int(hp.uniform('num_leaves', 10, 128)),\n 'n_estimators': 1000,\n 'boosting': 'gbdt',\n 'objective': 'multiclass',\n 'num_class': 12,\n 'metric': 'None',\n 'is_unbalance': 'true',\n # 'min_data_per_group': 1000,\n 'verbose': -1,\n 'random_seed': 42,\n \n }\n\n # Use the fmin function from Hyperopt to find the best hyperparameters\n best = fmin(score_model, space, algo=tpe.suggest,\n # trials=trials,\n max_evals=hyperopt_niters)\n return best","def optimize(maxiter: int = 1000,\n tol = None,\n save_steps: int = 1,\n c0: float = 0.62,\n c1: float = 0.1,\n c2: float = 0.602,\n c3: float = 0.101,\n c4: float = 0):\n _spsa_vars = [c0, c1, c2, c3, c4]\n theta = self.vectorizer.vector\n nb_params = len(theta)\n use_exact_grads = 'grads' in self._method\n \n if save_steps:\n theta_vec = [theta]\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\n \n \n pbar = tqdm(total=maxiter, disable=not self.progbar)\n def callback(_):\n pbar.clear()\n pbar.update()\n val = round(self.loss, 5)\n pbar.set_description(str(val))\n\n if self.loss_target is not None:\n if self.loss < self.loss_target:\n # returning True doesn't terminate optimization\n pbar.close()\n raise KeyboardInterrupt\n \n for ii in range(maxiter):\n \n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\n delta = 2 * randint(0, 2, size=nb_params) - 1\n # plus and minus directions\n \n if use_exact_grads:\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\n else:\n theta_plus = theta + c_spsa * delta\n theta_minus = theta - c_spsa * delta\n\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\n # derivative estimate\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\n # updated theta\n theta = theta - a_spsa * g_spsa\n \n callback(ii)\n \n if tol is not None:\n if (cost_plus + cost_minus)/2 < tol:\n pbar.close()\n break\n \n if save_steps:\n theta_vec.append(theta)\n cost_vec.append(cost_plus/2+cost_minus/2)\n \n \n result_dict = {'hyper_parameters':_spsa_vars,\n 'maxiter':maxiter,\n 'theta_opt':theta,\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\n if save_steps:\n result_dict['theta_history'] = theta_vec\n result_dict['cost_history'] = cost_vec\n self.result_dict = result_dict\n pbar.close()\n\n return self.inject_res_vector_and_return_tn()","def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\n TrainingTarget, TestData, ValData):\n # Gradient Descent Solution for Linear Regression\n La = 2\n # learningRate = 0.01\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\n\n for i in range(0, 400):\n\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\n Delta_E_D = -np.dot(\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\n TRAINING_PHI[i])\n La_Delta_E_W = np.dot(La, W_Now)\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\n Delta_W = -np.dot(learningRate, Delta_E)\n W_T_Next = W_Now + Delta_W\n W_Now = W_T_Next\n\n #-----------------TrainingData Accuracy---------------------#\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\n\n #-----------------ValidationData Accuracy---------------------#\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\n\n #-----------------TestingData Accuracy---------------------#\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\n\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])","def optimize_library_descent(self, target, direction='max', steps=100,\n multiprocessing=False, ret_info=False,\n args=None):\n # get the target function to call\n target_function = getattr(self, target)\n if args is not None:\n target_function = functools.partial(target_function, **args)\n\n # initialize the optimizer\n value = target_function()\n value_best, state_best = value, self.sens_mat.copy()\n \n if ret_info:\n # store extra information\n start_time = time.time()\n info = {'values': {}}\n values_count = self.parameters['optimizer_values_count']\n values_step = max(1, steps // values_count)\n \n if multiprocessing:\n # run the calculations in multiple processes\n pool_size = self.get_number_of_cores()\n pool = mp.Pool(processes=pool_size)\n if ret_info:\n values_step = max(1, values_step // pool_size)\n \n # iterate for given number of steps\n for step in range(int(steps) // pool_size):\n joblist = []\n init_arguments = self.init_arguments\n for _ in range(pool_size):\n # modify the current state and add it to the job list\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n params = init_arguments['parameters'] \n params['sensitivity_matrix'] = self.sens_mat\n params['initialize_state']['sensitivity'] = 'exact'\n \n joblist.append((copy.deepcopy(init_arguments), target))\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # run all the jobs\n results = pool.map(_run_job, joblist)\n \n # find the best result \n if direction == 'max':\n res_best = np.argmax(results)\n if results[res_best] > value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n elif direction == 'min':\n res_best = np.argmin(results)\n if results[res_best] < value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n else:\n raise ValueError('Unsupported direction `%s`' % direction)\n \n if ret_info and step % values_step == 0:\n info['values'][step * pool_size] = results[res_best]\n \n else:\n # run the calculations in this process\n for step in range(int(steps)):\n # modify the current state\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # get the value of the new state\n value = target_function()\n \n improved = ((direction == 'max' and value > value_best) or\n (direction == 'min' and value < value_best))\n if improved:\n # save the state as the new best value\n value_best, state_best = value, self.sens_mat.copy()\n else:\n # undo last change\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n if ret_info and step % values_step == 0:\n info['values'][step] = value_best\n\n # sort the best state and store it in the current object\n state_best = self.sort_sensitivity_matrix(state_best)\n self.sens_mat = state_best.copy()\n\n if ret_info:\n info['total_time'] = time.time() - start_time \n info['states_considered'] = steps\n info['performance'] = steps / info['total_time']\n return value_best, state_best, info\n else:\n return value_best, state_best","def _make_spsa_optimizer(self):\n def optimize(maxiter: int = 1000,\n tol = None,\n save_steps: int = 1,\n c0: float = 0.62,\n c1: float = 0.1,\n c2: float = 0.602,\n c3: float = 0.101,\n c4: float = 0):\n \"\"\"\n This method is heavily based on qiskits optimizers.spsa method, \n adapted here to worth with on quibs tn's without exact gradients \n\n Parameters\n ----------\n maxiter: Maximum number of iterations to perform.\n tol : None or float stops optim if tol is reached (default none - completes all steps)\n save_steps: Save intermediate info every save_steps step. It has a min. value of 1.\n last_avg: Averaged parameters over the last_avg iterations.\n If last_avg = 1, only the last iteration is considered. It has a min. value of 1.\n c0: The initial a. Step size to update parameters.\n c1: The initial c. The step size used to approximate gradient.\n c2: The alpha in the paper, and it is used to adjust a (c0) at each iteration.\n c3: The gamma in the paper, and it is used to adjust c (c1) at each iteration.\n c4: The parameter used to control a as well.\n \n Returns\n -------\n TYPE : updated object? (same return as TNOptimize)\n \"\"\"\n _spsa_vars = [c0, c1, c2, c3, c4]\n theta = self.vectorizer.vector\n nb_params = len(theta)\n use_exact_grads = 'grads' in self._method\n \n if save_steps:\n theta_vec = [theta]\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\n \n \n pbar = tqdm(total=maxiter, disable=not self.progbar)\n def callback(_):\n pbar.clear()\n pbar.update()\n val = round(self.loss, 5)\n pbar.set_description(str(val))\n\n if self.loss_target is not None:\n if self.loss < self.loss_target:\n # returning True doesn't terminate optimization\n pbar.close()\n raise KeyboardInterrupt\n \n for ii in range(maxiter):\n \n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\n delta = 2 * randint(0, 2, size=nb_params) - 1\n # plus and minus directions\n \n if use_exact_grads:\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\n else:\n theta_plus = theta + c_spsa * delta\n theta_minus = theta - c_spsa * delta\n\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\n # derivative estimate\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\n # updated theta\n theta = theta - a_spsa * g_spsa\n \n callback(ii)\n \n if tol is not None:\n if (cost_plus + cost_minus)/2 < tol:\n pbar.close()\n break\n \n if save_steps:\n theta_vec.append(theta)\n cost_vec.append(cost_plus/2+cost_minus/2)\n \n \n result_dict = {'hyper_parameters':_spsa_vars,\n 'maxiter':maxiter,\n 'theta_opt':theta,\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\n if save_steps:\n result_dict['theta_history'] = theta_vec\n result_dict['cost_history'] = cost_vec\n self.result_dict = result_dict\n pbar.close()\n\n return self.inject_res_vector_and_return_tn()\n return optimize","def optimize(self, trial):\r\n num_leaves = trial.suggest_int(\"num_leaves\", 6, 50)\r\n min_child_samples = trial.suggest_int(\"min_child_samples\", 100, 500)\r\n min_child_weight = trial.suggest_uniform(\"min_child_weight\", 1, 7)\r\n subsample = trial.suggest_uniform(\"subsample\", 0.6, 1)\r\n colsample_bytree = trial.suggest_uniform(\"colsample_bytree\", 0.6, 1)\r\n reg_alpha = trial.suggest_uniform(\"reg_alpha\", 0.1, 100)\r\n reg_lambda = trial.suggest_uniform(\"reg_lambda\", 0.1, 100)\r\n\r\n model = LGBMRegressor(\r\n num_leaves=num_leaves,\r\n min_child_samples=min_child_samples,\r\n min_child_weight=min_child_weight,\r\n subsample=subsample,\r\n colsample_bytree=colsample_bytree,\r\n reg_alpha=reg_alpha,\r\n reg_lambda=reg_lambda,\r\n )\r\n\r\n model = ModelTrainer(file_object=self.file_object).get_trained_model(\r\n model, self.X_train, self.y_train\r\n )\r\n r_squared, rmse = ModelScorer(file_object=self.file_object).get_model_scores(\r\n model, self.X_test, self.y_test\r\n )\r\n\r\n return r_squared","def _optimize(self) -> None:\n\n for i, agent in enumerate(self.agents):\n states, actions, rewards, next_states, dones = self.memory.sample()\n\n actor_next_state = self._agent_states(i, next_states)\n next_actions = torch.cat(\n [a.actor_target(actor_next_state) for a in self.agents], 1\n )\n next_q = agent.critic_target(next_states, next_actions).detach()\n target_q = rewards[:, i].view(-1, 1) + self.gamma * next_q * (\n 1 - dones[:, i].view(-1, 1)\n )\n local_q = agent.critic_local(states, actions)\n\n value_loss = agent.loss_fn(local_q, target_q)\n agent.value_optimizer.zero_grad()\n value_loss.backward()\n agent.value_optimizer.step()\n\n local_actions = []\n for i, a in enumerate(self.agents):\n local_states = self._agent_states(i, states)\n local_actions.append(\n a.actor_local(local_states)\n if a == agent\n else a.actor_local(local_states).detach()\n )\n local_actions = torch.cat(local_actions, 1)\n policy_loss = -agent.critic_local(states, local_actions).mean()\n\n agent.policy_optimizer.zero_grad()\n policy_loss.backward()\n agent.policy_optimizer.step()\n\n self._update_target_model(agent.critic_local, agent.critic_target)\n self._update_target_model(agent.actor_local, agent.actor_target)","def hyperopt_func(model_dict, model_param_names, training_param_names, param_space, datasets, max_evals=30):\n tester = fitness(model_dict, model_param_names, training_param_names, datasets)\n trials = Trials()\n \n timer_start = timer()\n best = fmin(fn=tester.objective, \n space=param_space, \n algo=tpe.suggest, \n max_evals=max_evals, \n trials=trials, \n rstate=np.random.RandomState(50))\n timer_end = timer()\n print('Total training time (min):',(timer_end-timer_start)/60)\n results = sorted(trials.results, key = lambda x: x['loss'])\n return results","def optimize(self,\n max_grad_norm=0.5,\n learning_rate=7e-4,\n rms_decay=0.99,\n rms_epsilon=1e-5):\n grads = tf.gradients(tf.negative(self.objective), self.variables)\n if max_grad_norm is not None:\n grads, _ = tf.clip_by_global_norm(grads, max_grad_norm)\n trainer = tf.train.RMSPropOptimizer(learning_rate=learning_rate,\n decay=rms_decay,\n epsilon=rms_epsilon)\n return trainer.apply_gradients(list(zip(grads, self.variables)))","def maximize(func, grad_func, x, y, theta_0, alpha_0=0.01, max_it=100):\n return minimize(negate(func), negate_all(grad_func), x, y, theta_0, alpha_0=0.01, max_it=100)","def optimizer(self):\n \n # taken from https://github.com/germain-hug/Deep-RL-Keras/blob/master/DDPG/actor.py\n # I believe this is a work around to get keras to learn **given a gradient**\n # As opposed to bunch of x_train, y_trains?\n \n #Inputs\n state_pl = self.model.input\n action_grads_pl = K.placeholder(shape=(None,1)) \n \n #Find grad_(pars) mu(state)\n mu_pl = self.model.output\n pars = self.model.trainable_weights\n pars_grad_mu = tf.gradients(mu_pl, pars, -action_grads_pl)\n \n #grads_and_pars = zip(pars_grad_mu, pars) #keras needs this form\n #updates = tf.train.AdamOptimizer(self.lr).apply_gradients(grads_and_pars)\n\n # The gradients as defined above work on my mac, but not ubuntu.\n # Below I am trying a workaround. I changed the keras source code \n # To get this working. Specifically, I make the optimizer.get_updates()\n # function accept custom gradients. It was easy to do.\n \n opt = Adam(self.lr)\n loss = pars_grad_mu #placeholder, I won't use it\n updates = opt.get_updates(loss = loss, params = pars, grads = pars_grad_mu)\n\n return K.function(inputs = [state_pl, action_grads_pl], outputs = [], updates = updates)\n #return K.function(inputs = [state_pl, action_grads_pl], outputs = [updates])","def optimize(self, max_iters=1e3, messages=False, use_counter=False,\\\n factr=1e7, pgtol=1e-05):\n logger.debug('Beginning MLE to optimize hyperparams. grad_method=%s'\\\n % self.grad_method)\n\n # setup the optimization\n try:\n x0 = self._transform_parameters(self.parameters)\n assert np.all(np.isfinite(x0))\n except:\n logger.error('Transformation failed for initial values. '\\\n + 'Ensure constraints are met or the value is not too small.')\n raise\n\n # filter out the fixed parameters\n free = np.logical_not(self._fixed_indicies)\n x0 = x0[free]\n\n # setup the counter\n if use_counter:\n self._counter = solver_counter(disp=True)\n else:\n self._counter = None\n\n # run the optimization\n try:\n x_opt, f_opt, opt = fmin_l_bfgs_b(func=self._objective_grad, x0=x0,\\\n factr=factr, pgtol=pgtol, maxiter=max_iters, disp=messages)\n except (KeyboardInterrupt,IndexError):\n logger.info('Keyboard interrupt raised. Cleaning up...')\n if self._counter is not None and self._counter.backup is not None:\n self.parameters = self._counter.backup[1]\n logger.info('will return best parameter set with'\\\n + 'log-likelihood = %.4g' % self._counter.backup[0])\n else:\n logger.info('Function Evals: %d. Exit status: %s' % (f_opt, opt['warnflag']))\n # extract the optimal value and set the parameters to this\n transformed_parameters = self._previous_parameters \n transformed_parameters[free] = x_opt\n self.parameters = self._untransform_parameters(transformed_parameters)\n return opt","def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\n return x_best, -y_best","def optimization_step(self):\n \n if \"CSS\" in self.algorithm:\n \n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\n \n var_list = [self.x_tilda, self.minibatch_set]\n \n if (self.num_samples > 0) and (not self.mixture):\n \n if ((self.mf_steps > 0) and self.alpha >0) or\\\n self.gibbs_steps > 0: \n \n var_list.append(self.sampler_theta)\n \n elif \"CD\" in self.algorithm:\n \n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \n \n var_list = [self.minibatch_set]\n \n var_list.append(self.learning_rate)\n \n if self.use_momentum:\n \n var_list.append(self.momentum)\n \n output_vars = [self.pseudo_cost]\n \n if self.report_p_tilda:\n \n output_vars.append(self.p_tilda)\n \n else:\n \n output_vars.append(theano.shared(0))\n \n opt_step = theano.function(inputs = var_list,\n outputs = output_vars,\n updates = self.updates,\n givens = input_dict,\n on_unused_input='warn')\n \n return opt_step","def fit(self, w):\n w_former = w\n w_next = w\n w_t = w\n w_t_100 = w\n w_diff = 10000\n i = 0\n #tim_beg = t.time()\n # use two part to calculate the a(w,w0):calculate the gradient using regular or SDG, batch = 10\n # calculate the gradient and update the w,w0\n while i < 10000 and np.abs(w_diff) > 0.00001:\n loss_func = self.lost\n grads = self.gradient(loss_func)\n # calculate the y_pred(eta)\n w_next = w_former - grads(w_former) / (10000)\n k =self.lost(w_next) - self.lost(w_former)\n m = np.dot(w_next-w_former, grads(w_former).T)\n if i != 0 and i % 100 == 0:\n w_t = w_t_100\n w_t_100 = w_next\n w_diff = 1 / len(w) * (np.sum(np.abs(w_t_100 - w_t)))\n i_loss = self.lost(w_next)\n print(\"Iteration < %d > with loss < %f >\" % (i, i_loss))\n #self.los_plt.append(i_loss)\n #tim = t.time() - tim_beg\n #self.tim.append(tim)\n i += 1\n w_former = w_next\n #plt.plot(self.tim, self.los_plt)\n #plt.xlabel(\"time\")\n #plt.ylabel('loss')\n #plt.show()\n if i >= 10000:\n print(\"~Optimization stops because finishing iteration~\")\n if np.abs(w_diff) <= 0.00001:\n print(\"~Optimization stops because of difference between weights are less than 0.00001~\")\n self.w_result = w_next","def minimize(self):\n self.normalize()\n p0s = self.spacedvals(method='random')\n if self.n_spots > 1:\n opts = self.multifit(p0s)\n else:\n opts = self.singlefit(p0s)\n self.yf = [self.solve(theta) for theta in opts]\n self.bestps = opts\n return opts","def evaltr(x_solution): \n \n large = 10.0**30\n pred = np.zeros(cfg.ntrain)\n e0 = 0.0 # mean of observed values\n y=0.0\n for i in range(cfg.ntrain): # Computation of correct piece\n e0 += cfg.a_unscaled[i][-1]\n pind = 0\n ipbest = 0\n pbest = -large # for max\n \n for j1 in range(cfg.nomax):\n ipmin=pind\n pmin=large # for min\n for _ in range(cfg.jk[j1]):\n piece=x_solution[(pind+1)*cfg.nfea-1] \n for j3 in range(cfg.nfea-1): #\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\n if piece < pmin:\n ipmin = pind\n pmin = piece\n pind += 1 \n \n if pmin > pbest:\n ipbest = ipmin\n pbest = pmin\n \n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\n for j1 in range(cfg.nfea-1):\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\n y += pred[i]\n \n y = y/cfg.ntrain \n e0 = e0/cfg.ntrain\n \n # Computation of indices\n rmse = 0.0\n mae = 0.0\n e1 = 0.0\n for i in range(cfg.ntrain):\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \n e1 += (cfg.a_unscaled[i][-1] - e0)**2\n ce = 1.0 - rmse/e1 \n rmse = np.sqrt(rmse/cfg.ntrain)\n mae = mae/cfg.ntrain \n\n if cfg.ntrain > 1:\n sx=0.0\n sy=0.0\n rcor=0.0\n for i in range(cfg.ntrain):\n sx += (pred[i]-y)**2\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \n\n r = rcor/np.sqrt(sx*sy)\n \n return rmse,mae,ce,r","def optimize(self):\n # Loop through every WD and WS individually\n wd_array = self.fi_subset.floris.flow_field.wind_directions\n ws_array = self.fi_subset.floris.flow_field.wind_speeds\n for nwsi, ws in enumerate(ws_array):\n\n self.fi_subset.reinitialize(wind_speeds=[ws])\n\n for nwdi, wd in enumerate(wd_array):\n # Find turbines to optimize\n turbs_to_opt = self._turbs_to_opt_subset[nwdi, nwsi, :]\n if not any(turbs_to_opt):\n continue # Nothing to do here: no turbines to optimize\n\n # Extract current optimization problem variables (normalized)\n yaw_lb = self._minimum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt]\n yaw_ub = self._maximum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt]\n bnds = [(a, b) for a, b in zip(yaw_lb, yaw_ub)]\n x0 = self._x0_subset_norm[nwdi, nwsi, turbs_to_opt]\n\n J0 = self._farm_power_baseline_subset[nwdi, nwsi]\n yaw_template = self._yaw_angles_template_subset[nwdi, nwsi, :]\n turbine_weights = self._turbine_weights_subset[nwdi, nwsi, :]\n yaw_template = np.tile(yaw_template, (1, 1, 1))\n turbine_weights = np.tile(turbine_weights, (1, 1, 1))\n\n # Define cost function\n def cost(x):\n x_full = np.array(yaw_template, copy=True)\n x_full[0, 0, turbs_to_opt] = x * self._normalization_length\n return (\n - 1.0 * self._calculate_farm_power(\n yaw_angles=x_full,\n wd_array=[wd],\n turbine_weights=turbine_weights\n )[0, 0] / J0\n )\n\n # Perform optimization\n residual_plant = minimize(\n fun=cost,\n x0=x0,\n bounds=bnds,\n method=self.opt_method,\n options=self.opt_options,\n )\n\n # Undo normalization/masks and save results to self\n self._farm_power_opt_subset[nwdi, nwsi] = -residual_plant.fun * J0\n self._yaw_angles_opt_subset[nwdi, nwsi, turbs_to_opt] = (\n residual_plant.x * self._normalization_length\n )\n\n # Finalize optimization, i.e., retrieve full solutions\n df_opt = self._finalize()\n return df_opt","def _objective(self, trial, X, y, weights=None, split=None):\n\n # Generate even weights if none\n if weights is None:\n weights = pd.Series(np.ones(len(y)), index=y.index)\n else:\n weights = pd.Series(weights, index=y.index)\n\n # Execute trial function\n try:\n res = eval(self.function)\n except:\n raise RuntimeError(f\"Optuna execution error: {self.function}\")\n\n # If indicator result is tuple, select the one of interest\n if isinstance(res, tuple):\n res = res[self.idx]\n\n # Ensure result is a dataframe with same index as X\n res = pd.DataFrame(res, index=X.index)\n\n # If indicator result is dataframe, select the one of interest\n if len(res.columns) > 1:\n res = pd.DataFrame(res.iloc[:, self.idx])\n\n # y may be a subset of X, so reduce result to y and convert to series\n res_y = res.reindex(y.index).iloc[:, 0].replace([np.inf, -np.inf], np.nan)\n\n # Save all trial results for pruning and reporting\n # Only the best trial will eventually be saved to limit storage requirements\n self.res_y.append(res_y) # Save results\n\n # Indicator result may be all NANs based on parameter set\n # Return FALSE and alert\n if np.isnan(res_y).sum() / len(res_y) > .95: # Most or all NANs\n self.res_y_corr.append(np.zeros(len(y)))\n if split is not None:\n return tuple([False] * (len(split) - 1))\n else:\n return False\n\n # Obtain correlation for entire dataset\n if self.spearman:\n corr = _weighted_spearman(np.array(y), np.array(res_y), np.array(weights))\n else:\n corr = _weighted_pearson(np.array(y), np.array(res_y), np.array(weights))\n\n # Save correlation for res_y\n self.res_y_corr.append(corr)\n\n # Multi-objective optimization\n # Obtain correlation to target for each split for Optuna to maximize\n if split is not None:\n mo = []\n for i, e in enumerate(split):\n if i == 0:\n s = e\n continue\n\n # y could be a subset of X, use index of X to filter y\n idx = X[s:e].index\n\n # Filter y based on X split\n y_se = np.array(y[y.index.isin(idx)]).astype('float64')\n\n # Filter y predictions based on X split\n res_y_se = np.array(res_y[res_y.index.isin(idx)]).astype('float64')\n\n # Filter weights based on X split\n weights_se = np.array(weights[weights.index.isin(idx)]).astype('float64')\n\n if np.isnan(res_y_se).sum() / len(res_y_se) > .95:\n return tuple([False]*(len(split)-1))\n\n if self.spearman:\n mo.append(_weighted_spearman(y_se, res_y_se, weights_se))\n else:\n mo.append(_weighted_pearson(y_se, res_y_se, weights_se))\n s = e\n return tuple(mo)\n\n # Single objective optimization return corr for entire dataset\n else:\n return corr","def optimize(self, num_restarts=1, max_iters=100, max_f_eval=300.0, method='Anneal'):\n dic = DictVectorizer()\n # flatten the parameters\n init_params,bounds=dic.fit_transform(self.params)\n #we minimise minus the marginal likelihood\n def objective(params_flatten):\n self.params=dic.inverse_transform(params_flatten,bounds)\n val = -self.log_marginal_likelihood()\n return val# we want to maximize it\n \n \n #run ptimisation with multiple restarts\n optml=np.inf\n for i in range(num_restarts):\n #minimise function\n if method=='Anneal':\n res=dual_annealing(objective,bounds, maxiter=max_iters, maxfun=max_f_eval, x0=init_params)\n else:\n \n res = minimize(objective, init_params, \n bounds=bounds, method=method,options={'maxiter': max_iters, 'disp': False})\n #print(\"Iteration \"+str(i)+\" \",-res.fun)\n if res.fun<optml:\n params_best=res.x #init_params \n optml=res.fun\n init_params=bounds[:,0]+(bounds[:,1]-bounds[:,0])*np.random.rand(len(bounds[:,0]))\n print(\"Iteration \"+str(i)+\" \",-res.fun)\n #params_best=res.x\n #optml=res.fun\n self.params=dic.inverse_transform(params_best,bounds)\n return -optml","def approximate_gradient(self, theta, c, iter):\n\n true_theta = utils.true_param(theta)\n\n if self.history_count > 0:\n current_goal, _ = self.average_evaluations(30)\n else:\n current_goal = SPSA_minimization.BAD_GOAL\n\n logging.info(f'{__file__} > current_goal: {current_goal}')\n\n print(f'current optimizer mean goal: {current_goal:0.5f} (low is better, lowest: -1.0, highest: 1.0)')\n # print(f'Sample, optimizer goal = -(engine match score) or -(3.0 pts/4 games) or -0.75')\n\n bernouilli = self.create_bernouilli(theta)\n\n count = 0\n while True:\n logging.info(f'{__file__} Apply bernouilli term to theta, theta={theta}, c={c}, bernouilli={bernouilli}')\n # Calculate two evaluations of f at points M + c * bernouilli and\n # M - c * bernouilli to estimate the gradient. We do not want to\n # use a null gradient, so we loop until the two functions evaluations\n # are different. Another trick is that we use the same seed for the\n # random generator for the two function evaluations, to reduce the\n # variance of the gradient if the evaluations use simulations (like\n # in games).\n state = random.getstate()\n theta1 = utils.linear_combinaison(1.0, theta, c, bernouilli)\n logging.info(f'{__file__} theta1: {theta1}')\n\n # Apply parameter limits\n logging.info(f'{__file__} > Apply limits to theta1 before sending to engine')\n theta1 = utils.apply_limits(theta1)\n logging.info(f'{__file__} theta1 with limits: {theta1}')\n logging.info(f'{__file__} > run 1st match with theta1: {theta1}')\n\n random.setstate(state)\n theta2 = utils.linear_combinaison(1.0, theta, -c, bernouilli)\n logging.info(f'{__file__} theta2: {theta2}')\n\n # Apply parameter limits\n logging.info(f'{__file__} > Apply limits to theta2 before sending to engine')\n theta2 = utils.apply_limits(theta2)\n logging.info(f'{__file__} theta2 with limits: {theta2}')\n logging.info(f'{__file__} > run 2nd match with theta2: {theta2}')\n\n # Run the 2 matches in parallel after iteration 1.\n manager = multiprocessing.Manager()\n res = manager.dict()\n thetas = [theta1, theta2]\n\n if iter < self.iter_parallel_start:\n print('Run match 1 ...')\n true_param = utils.true_param(theta1)\n print('test_engine param:')\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\n print(f' {name}: {val[\"value\"]}, ({val[\"value\"] - val1[\"value\"]:+})')\n\n print('base_engine param:')\n for name, val in utils.true_param(theta).items():\n print(f' {name}: {val[\"value\"]}')\n\n t1 = time.perf_counter()\n f1 = self.evaluate_goal(theta1, theta, 0, res, iter)\n logging.info(f'f1 elapse: {time.perf_counter() - t1:0.2f}s')\n print(f'Done match 1!, elapse: {time.perf_counter() - t1:0.2f}sec')\n print(f'goal after match 1: {f1:0.5f}')\n\n # Run match 2\n print('Run match 2 ...')\n true_param = utils.true_param(theta2)\n print('test_engine param:')\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\n print(f' {name}: {val[\"value\"]}, ({val[\"value\"] - val1[\"value\"]:+})')\n\n print('base_engine param:')\n for name, val in utils.true_param(theta).items():\n print(f' {name}: {val[\"value\"]}')\n\n t1 = time.perf_counter()\n f2 = self.evaluate_goal(theta2, theta, 1, res, iter)\n logging.info(f'f2 elapse: {time.perf_counter() - t1:0.2f}s')\n print(f'Done match 2!, elapse: {time.perf_counter() - t1:0.2f}sec')\n print(f'goal after match 2: {f2:0.5f}')\n\n print('Done engine match!')\n else:\n print('Run 2 matches in parallel ...')\n t1 = time.perf_counter()\n jobs = []\n for i in range(2):\n print(f'Run match {i + 1} ...')\n\n true_param = utils.true_param(thetas[i])\n print('test_engine param:')\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\n print(f' {name}: {val[\"value\"]}, ({val[\"value\"] - val1[\"value\"]:+})')\n\n print('base_engine param:')\n for name, val in utils.true_param(theta).items():\n print(f' {name}: {val[\"value\"]}')\n\n p = multiprocessing.Process(target=self.evaluate_goal, args=(thetas[i], theta, i, res, iter))\n jobs.append(p)\n p.start()\n\n for num, proc in enumerate(jobs):\n proc.join()\n\n # If match is done in parallel, update the history count, eval and theta here.\n self.history_eval[self.history_count % 1000] = res.values()[num]\n self.history_theta[self.history_count % 1000] = thetas[num]\n self.history_count += 1\n\n print(f'Done match {num + 1}!, elapse: {time.perf_counter() - t1:0.2f}sec')\n\n logging.info(f'parallel elapse: {time.perf_counter() - t1:0.2f}s')\n\n print('Done engine match!')\n\n f1, f2 = res.values()[0], res.values()[1]\n\n logging.info(f'{__file__} > f1: {f1}, f2: {f2}')\n print(f'optimizer goal after match 1: {f1:0.5f} (low is better)')\n print(f'optimizer goal after match 2: {f2:0.5f} (low is better)')\n\n if f1 != f2:\n break\n\n print('perf is the same in match 1 and 2, launch new matches ...')\n\n count = count + 1\n logging.info(f'{__file__} > f1 and f2 are the same, try the engine match again. num_tries = {count}')\n\n if count >= 100:\n logging.info(f'{__file__} > too many evaluation to find a gradient, function seems flat')\n break\n\n # Update the gradient\n gradient = copy.deepcopy(theta)\n # print(f'Basic gradient after 2 engine matches:')\n for name, value in theta.items():\n gradient[name]['value'] = (f1 - f2) / (2.0 * c * bernouilli[name]['value'])\n # print(f' {name}: {gradient[name][\"value\"]}')\n logging.info(f'{__file__} > {name} gradient: {gradient}')\n\n if (f1 > current_goal) and (f2 > current_goal):\n logging.info(f'{__file__} > function seems not decreasing')\n gradient = utils.linear_combinaison(0.1, gradient)\n\n print('Modify the gradient because the results of engine matches\\n'\n 'did not improve when using the new param. But we will not\\n'\n 're-run the engine matches.')\n\n print('Modified gradient at alpha=0.1:')\n for n, v in gradient.items():\n print(f' {n}: {v[\"value\"]}')\n\n # For the correction factor used in the running average for the gradient,\n # see the paper \"Adam: A Method For Stochastic Optimization, Kingma and Lei Ba\"\n\n beta = 0.9\n correction = 1.0 / 1.0 - pow(beta, self.iter)\n\n gradient = utils.linear_combinaison((1 - beta), gradient, beta, self.previous_gradient)\n gradient = utils.linear_combinaison(correction, gradient)\n\n # print('New gradient after applying correction:')\n # for n, v in gradient.items():\n # print(f' {n}: {v[\"value\"]}')\n\n # Store the current gradient for the next time, to calculate the running average\n self.previous_gradient = gradient\n\n # Store the best the two evals f1 and f2 (or both)\n if (f1 <= current_goal):\n self.best_eval[self.best_count % 1000] = f1\n self.best_theta[self.best_count % 1000] = theta1\n self.best_count += 1\n\n if (f2 <= current_goal):\n self.best_eval[self.best_count % 1000] = f2\n self.best_theta[self.best_count % 1000] = theta2\n self.best_count += 1\n\n logging.info(f'{__file__} > final gradient: {gradient}')\n \n # Return the estimation of the new gradient\n return gradient","def optimize_model(self, gradient_clamping_value=None):\n # TODO: worry about this later\n # if self.kwargs['use_PER']:\n # # Create batch with PrioritizedReplayBuffer/PER:\n # transitions, importance_sampling_weights = self.replayBuffer.sample(self.batch_size)\n # batch = EXPPER(*zip(*transitions))\n # importance_sampling_weights = torch.from_numpy(importance_sampling_weights)\n # if self.use_cuda:\n # importance_sampling_weights = importance_sampling_weights.cuda()\n\n self.optimizer.zero_grad()\n transitions, batch = self.sample_from_replay_buffer(self.batch_size)\n\n next_state_batch, state_batch, action_batch, reward_batch, \\\n non_terminal_batch = self.create_tensors_for_optimization(batch,\n use_cuda=self.use_cuda)\n\n dqn_loss = compute_loss(states=state_batch,\n actions=action_batch,\n next_states=next_state_batch,\n rewards=reward_batch,\n non_terminals=non_terminal_batch,\n model=self.model,\n target_model=self.target_model,\n gamma=self.GAMMA,\n use_double=self.use_double,\n use_dueling=self.use_dueling,\n iteration_count=self.target_update_count)\n\n dqn_loss.backward()\n\n if gradient_clamping_value is not None:\n torch.nn.utils.clip_grad_norm(self.model.parameters(), gradient_clamping_value)\n\n self.optimizer.step()\n\n # TODO: Worry about this later\n #loss_per_item = dqn_loss\n #loss_np = loss_per_item.cpu().data.numpy()\n #if self.kwargs['use_PER']:\n # for (idx, new_error) in zip(batch.idx, loss_np):\n # new_priority = self.replayBuffer.priority(new_error)\n # self.replayBuffer.update(idx, new_priority)\n\n #return loss_np","def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\r\n\r\n\t\r\n\tif grad == 'NO':\r\n\t\tif method == 'Powell' :\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'Nelder-Mead':\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t options = {'ftol': 0.0001})\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'default':\r\n\t\t\tres = opt.minimize(Ulike,init_par, \r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\r\n\telif grad == 'YES':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \r\n \t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\r\n\t\treturn res.x, res.nit \r\n\t\t\t\r\n\t\t\r\n\telif grad == 'HESS':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\r\n\t\t\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \r\n\t\treturn res.x, res.nit","def fit(self, X, y, weights=None, idx=0, verbose=False, early_stop=None, split=None):\n\n start_time = timer()\n self.idx = idx\n self.split = split\n\n # Display Optuna trial messages\n if not verbose:\n optuna.logging.set_verbosity(optuna.logging.ERROR)\n\n # Single objective optimization\n if split is None:\n\n # Create optuna study maximizing correlation\n self.study = optuna.create_study(direction='maximize', study_name=self.function)\n\n # Set required early stopping variables\n self.study.early_stop = early_stop\n self.study.early_stop_count = 0\n self.study.best_score = None\n\n # Start optimization trial\n try:\n self.study.optimize(lambda trial: _objective(self, trial, X, y, weights),\n n_trials=self.n_trials, callbacks=[_single_early_stopping_opt])\n\n # Early stopping (not officially supported by Optuna)\n except optuna.exceptions.OptunaError:\n pass\n\n # Keep only results of best trial for prune and reporting\n self.res_y = self.res_y[self.study.best_trial.number]\n self.res_y.name = col_name(self.function, self.study.best_trial.params)\n self.res_y_corr = self.res_y_corr[self.study.best_trial.number]\n\n # Multi objective optimization\n else:\n\n # Create study to maximize eash split\n sampler = optuna.samplers.NSGAIISampler()\n self.study = optuna.create_study(directions=(len(split)-1) * ['maximize'], sampler=sampler,\n study_name=self.function)\n\n # Early stopping variables\n self.study.early_stop = early_stop\n self.study.early_stop_count = 0\n\n # Custom best trial variables (Optuna \"best\" are immutable)\n self.study.top_trial = 0\n self.study.top_params = None\n self.study.top_value = None\n\n # Start optimization trial\n try:\n self.study.optimize(lambda trial: _objective(self, trial, X, y, weights, split),\n n_trials=self.n_trials, callbacks=[_multi_early_stopping_opt])\n\n # Early stopping (not officially supported by Optuna)\n except optuna.exceptions.OptunaError:\n pass\n\n # Validation checks\n if np.mean(self.study.trials[self.study.top_trial].values) != self.study.top_value:\n raise RuntimeError(\"Top trial score invalid\")\n if len(self.res_y) != len(self.study.trials) or len(self.res_y) != len(self.res_y_corr):\n raise RuntimeError(\"Total results does not equal trials\")\n\n # Keep only results of best trial for prune and reporting\n self.res_y = self.res_y[self.study.top_trial]\n self.res_y.name = col_name(self.function, self.study.trials[self.study.top_trial].params)\n self.res_y_corr = self.res_y_corr[self.study.top_trial]\n\n end_time = timer()\n self.time = round(end_time - start_time, 2)\n\n return self","def optimize(self):\n \n if self.verbose:\n print('Starting grid search with bounds: [' + \\\n ';'.join(['%5g to %5g']*len(self.steps))%tuple([(self.steps[i][0], self.steps[i][-1]) for i in range(len(self.steps))]) +']')\n\n for params in self._get_next_point():\n self.transform.set_params(params)\n\n v, _ = self.measure.value_and_derivatives(self.transform)\n\n if v < self.best_value:\n self.best_value = v\n self.best_params = params\n# print('New best value %2.4f at ('%v, ', '.join(['%8.3f']*len(params))%tuple(params), ')')\n\n self.value_history.append(v)\n self.last_value = v\n self.iteration += 1\n\n if self.report_freq > 0 and (self.iteration % self.report_freq == 0) and self.report_func is not None:\n self.report_func(self)\n\n # Set the best transform\n self.transform.set_params(self.best_params)\n self.last_value = self.best_value\n return self.best_value","def set_optimal_parameters(self):\n # Getting the best trial based on the test errors\n idx = self.trial_losses.index(min(self.trial_losses))\n self.best_trial = self.trial_list[idx]\n self.objective.parse_trial(self.best_trial)","def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\n \n costs = []\n \n for i in range(num_iterations):\n \n \n # Cost and gradient calculation \n grads, cost = propagate(w, b, X, Y)\n\n # Retrieve derivatives from grads\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n \n # update rule (Gradient Descent)\n w = w - learning_rate * dw\n b = b - learning_rate * db\n\n # Record the change of costs\n if i % 100 == 0:\n costs.append(cost)\n \n # Print the cost every 100 training iterations\n if print_cost and i % 100 == 0:\n print (\"Cost after iteration %i: %f\" %(i, cost))\n \n params = {\"w\": w,\n \"b\": b}\n \n grads = {\"dw\": dw,\n \"db\": db}\n \n return params, grads, costs","def optimizing(theta, data = data, target = target):\n # num = (sin(individual[0] - individual[1] / 8))**2 + (sin(individual[1] + individual[0] / 8))**2\n # denum = ((individual[0] - 8.6998)**2 + (individual[1] - 6.7665)**2)**0.5 + 1\n learner = MLPClassifier(hidden_layer_sizes=theta[0], learning_rate_init=theta[1], alpha=theta[2], verbose=True, early_stopping=True, n_iter_no_change=6)\n\n model = learner.fit(data, target)\n return model.best_loss_ # return the best error/residual (best error is cloes to zero) The error of a model is the difference between your predicted outcome and the real observed outcome and therefore 0 is desired\n\n # individual as a factor containing x, y = to tetha which ","def find_best_params(self, n_trials=120):\r\n self.logger_object.log(\r\n self.file_object,\r\n \"Entered find_best_params method of HyperparametersTuner class.\",\r\n )\r\n try:\r\n optimization_function = partial(self.optimize)\r\n study = optuna.create_study(direction=\"maximize\")\r\n study.optimize(optimization_function, n_trials=n_trials)\r\n self.logger_object.log(\r\n self.file_object, f\"Successfully ran {n_trials} optuna study trials.\"\r\n )\r\n\r\n self.tuned_hyperparams[\"LGBM Regression\"].append(study.best_params)\r\n self.logger_object.log(\r\n self.file_object,\r\n \"Successfully appended best model parameters as a dictionary.\",\r\n )\r\n\r\n with (open(str(Config.TUNED_HYPERPARAMS_FILE_PATH), \"w\")) as outfile:\r\n json.dump(self.tuned_hyperparams[\"LGBM Regression\"], outfile, indent=1)\r\n self.logger_object.log(\r\n self.file_object,\r\n \"Successfully dumped the best parameters in best_params.json .\",\r\n )\r\n except Exception as e:\r\n self.logger_object.log(\r\n self.file_object,\r\n f\"Exception occured in find_best_params method of HyperparametersTuner class. Exception message: {e}\",\r\n )\r\n self.logger_object.log(\r\n self.file_object,\r\n \"Dumping best parameters unsuccessful. Exited find_best_params method of HyperparametersTuner class\",\r\n )\r\n raise Exception()","def minimize(self, func, grad, x0, args=()):\n learning_rate = self._learning_rate\n best_x = x = x0\n best_value = func(x, *args)\n iters_without_improve = 0\n\n for iteration in range(self._max_iterations):\n gradient = grad(x, *args)\n\n # If absolute values of all partial derivatives are equal to 0 with specified accuracy, then parameters are\n # close enough to the minimum and there is no need to continue gradient descent.\n if np.abs(gradient).max() <= self._accuracy:\n break\n\n x = x - learning_rate * gradient\n\n # If new values of x haven't lead to decrease of the function value for the specified number of iteration,\n # the x is reverted to its previous best value and the learning rate is reduced\n value = func(x, *args)\n if value > best_value:\n iters_without_improve += 1\n if iters_without_improve >= self._lr_reduce_patience:\n x = best_x\n learning_rate *= self._lr_reduce_factor\n else:\n iters_without_improve = 0\n best_value = value\n best_x = x\n\n return best_x","def opt_wrapper(m, **kwargs):\r\n m.optimize(**kwargs)\r\n return m.optimization_runs[-1]","def optimize(self, X, y, *args):\n self.loss_function.set_space(X, y, *args)\n self.betas_ = fastgradalgo(\n self.loss_function,\n t_init=self.eta_init,\n max_iter=self.max_iter\n )\n return self.betas_","def opt_wrapper(m, **kwargs):\n m.optimize(**kwargs)\n return m.optimization_runs[-1]","def run():\n trials = 100\n\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\n\n mean_penalty = []\n median_penalty = []\n std_penalty = []\n\n mean_trial_time = []\n median_trial_time = []\n std_trial_time = []\n\n mean_success_rate = []\n median_success_rate = []\n std_success_rate = []\n\n for m in multipliers:\n all_penalties = [] # All penalties from trail sets\n all_average_trial_time = []\n all_success_rates = []\n\n for i in range(0, 20):\n # print \"Trial set:\", i\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n agent = e.create_agent(LearnerAgent) # create agent\n agent.mult = m\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\n\n sim.run(n_trials=trials) # run for a specified number of trials\n\n all_penalties.append(agent.all_trails_penalties)\n all_average_trial_time.append(agent.time/float(trials))\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\n\n mean_penalty.append(np.mean(all_penalties))\n median_penalty.append(np.median(all_penalties))\n std_penalty.append(np.std(all_penalties))\n\n mean_trial_time.append(np.mean(all_average_trial_time))\n median_trial_time.append(np.median(all_average_trial_time))\n std_trial_time.append(np.std(all_average_trial_time))\n\n mean_success_rate.append(np.mean(all_success_rates))\n median_success_rate.append(np.median(all_success_rates))\n std_success_rate.append(np.std(all_success_rates))\n\n for i in range(0, len(multipliers)):\n print \"\"\n print \"Multiplier:\", multipliers[i]\n print \"\"\n print \"Mean penalty per {} trials:\".format(trials), mean_penalty[i]\n print \"Median penalty per {} trials:\".format(trials), median_penalty[i]\n print \"Std.Dev. penalty per {} trials:\".format(trials), std_penalty[i]\n\n print \"\"\n print \"Mean trial time:\", mean_trial_time[i]\n print \"Median trial time:\", median_trial_time[i]\n print \"Std.Dev. trial time:\", std_trial_time[i]\n\n print \"\"\n print \"Mean success rate per {} trials:\".format(trials), mean_success_rate[i]\n print \"Median success rate per {} trials:\".format(trials), median_success_rate[i]\n print \"Std.Dev. success rate per {} trials:\".format(trials), std_success_rate[i]","def optimize(w, b, X, Y, num_iterations,learning_rate,print_cost = False):\n costs = []\n for i in range(num_iterations):\n\n # Cost and gradient calculation (≈ 1-4 lines of code)\n ### START CODE HERE ###\n grads,cost = propagate(w,b,X,Y)\n ### END CODE HERE ###\n\n # Retrieve derivatives from grads\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n\n # update rule (≈ 2 lines of code)\n ### START CODE HERE ###\n w = w - learning_rate*dw\n b = b - learning_rate*db\n ### END CODE HERE ###\n\n # Record the costs\n if i % 100 == 0:\n costs.append(cost)\n\n # Print the cost every 100 training examples\n if print_cost and i%100==0:\n print(\"Cost after iteration %i: %f\"%(i,cost))\n\n params = {\n \"w\":w,\n \"b\":b\n }\n grads = {\n \"dw\":dw,\n \"db\":db\n }\n return params,grads,costs","def makeOptimizationStep(modelNet, targetNet, gameMemory, optimizer):\n statesBatch, actionsBatch, nextStatesBatch, rewardsBatch, terminalMask = gameMemory.getBatch()\n currentQValues = modelNet(statesBatch).gather(1, actionsBatch.unsqueeze(1))\n nextQValues = targetNet(nextStatesBatch).max(1)[0].detach()\n nextQValues[terminalMask == 1] = 0\n expectedQValues = rewardsBatch + nextQValues * DISCOUNT_FACTOR\n expectedQValues = torch.tensor(expectedQValues).unsqueeze(1).to(DEVICE)\n loss = F.smooth_l1_loss(currentQValues, expectedQValues)\n optimizer.zero_grad()\n loss.backward()\n for param in modelNet.parameters():\n param.grad.data.clamp_(-1, 1)\n optimizer.step()","def tune_model(self):\n acc = 0\n ### Early Stop Mechanism\n loss = previous_loss = float(\"inf\")\n patience_left = self.config.patience\n ### Early Stop Mechanism\n\n self.generator = Generator(self.model.config, training_strategy=self.training_strategy)\n self.evaluator = Evaluator(model=self.model,data_type=self.teston, debug=self.debug, tuning=True)\n \n for cur_epoch_idx in range(self.config.epochs):\n loss = self.train_model_epoch(cur_epoch_idx, tuning=True)\n ### Early Stop Mechanism\n ### start to check if the loss is still decreasing after an interval. \n ### Example, if early_stop_epoch == 50, the trainer will check loss every 50 epoche.\n ### TODO: change to support different metrics.\n if ((cur_epoch_idx + 1) % self.config.early_stop_epoch) == 0: \n if patience_left > 0 and previous_loss <= loss:\n patience_left -= 1\n print('%s more chances before the trainer stops the training. (prev_loss, curr_loss): (%.f, %.f)' % \\\n (patience_left, previous_loss, loss))\n\n elif patience_left == 0 and previous_loss <= loss:\n self.evaluator.result_queue.put(Evaluator.TEST_BATCH_EARLY_STOP)\n break\n else:\n patience_left = self.config.patience\n\n previous_loss = loss\n\n self.generator.stop()\n self.evaluator.test(cur_epoch_idx)\n acc = self.evaluator.output_queue.get()\n self.evaluator.stop()\n\n return acc","def optimizer() -> pd.DataFrame:\n global iteration, coefs_all\n\n X_train, X_test, y_train, y_test = train_test()\n\n # Number of observations in train & test set\n n_train = len(X_train)\n n_test = len(X_test)\n n_coefs = X_train.shape[1]\n\n # Initialize coefficients\n coefs_init = np.random.normal(\n loc=conf.coef_mu, \n scale=conf.coef_sigma, \n size=n_coefs\n )\n coefs_all = coefs_init.copy()\n\n # Coefficients shall be bounded\n bounds = [conf.coef_bounds] * n_coefs\n iteration = 0\n\n # Run optimization\n result = minimize( \n fun=lambda x: loss_func(x, X_train, y_train, n_train),\n callback=lambda x: callback_func(x, X_train, y_train, n_train),\n x0=coefs_init,\n bounds=bounds\n )\n # Collect optimal coefficients\n coefs = pd.Series(data=result.x, index=X_train.columns, name=\"coefs\")\n coefs_df = pd.DataFrame(data=coefs_all, columns=X_train.columns).T\n coefs_df.index.name = \"area\"\n\n rmse_train = result.fun\n rmse_test = loss_func(\n coefs=coefs, \n X=X_test, \n y=y_test, \n n=n_test, \n )\n print(\"\\n\")\n print (f\"Train RMSE: {rmse_train:.4f}\")\n print (f\"Test RMSE: {rmse_test:.4f}\")\n\n return coefs_df","def objective(self, trial):\n # Suggest start row IDs\n selected = [self.all_df.index.max()]\n for i in range(self.n_points):\n id_min = 3 * (self.n_points - len(selected) + 1)\n id_max = selected[-1] - 3\n if id_min + 3 > id_max:\n return np.inf\n new = trial.suggest_int(str(i), id_min, id_max)\n selected.append(new)\n start_ids = sorted(selected)[:-1]\n # Create subsets\n subsets = self.create_subsets(start_ids)\n # Curve fitting for each subset\n df_list = [self.curve_fit(df, num)\n for (num, df) in enumerate(subsets, start=1)]\n # Calculate the error\n return self.error_f(df_list)","def objective(trial):\n # The parameters that we will calibrate the model for are shown here.\n # Optuna trial i\n BOD = trial.suggest_uniform(\"BOD\", 0, 1) #Review ranges here\n k_r = trial.suggest_uniform(\"k_r\", 0, 1) #Review Ranges here \n \n def ChLa(t):\n return 1 # Need to link to data\n\n def I(x):\n return 1 # Need to link to data\n\n K_z = 2 * 10**(-5) # p.51\n a = K_z\n k_b = 0.1 # Table 5\n th_b = 1.047 # Table 5\n k_r = 0.1 # Table 5\n YCHO2 = 0.0083 # Table 5\n th_p = 1.036 # Table 5\n th_s = 1.065 # Table 5\n th_r = 1.047 # Table 5\n\n def Temp(t):\n \"\"\"\n Function that maps time to temperature\n \"\"\"\n return 20 # Need to link to data\n\n def P_max(t):\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\n\n def L_min(t):\n I = 1 # Need to link to PAR data\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\n K_2 = 15\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\n \n # f deals with sink and source terms \n def f(x, t):\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \n\n L = 200 # Length of domain\n dt = 1 / 48 # Mesh spacing in t\n F = a * dt # a * dt / dx**2\n T = 100 # Simulation time stop\n\n # Solving the PDE\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\n \n # Creating some bogus targets while database errors are happening\n DO_data = DO + np.random.random(len(DO))\n\n # Using mean squared error as the measure of fit, where we want\n # to minimize this number\n return ((DO - DO_data)**2).mean()","def fit(self):\n if self.minimizer == \"differential_evolution\":\n kwargs = {\"maxiter\": self._maxiter}\n elif self.minimizer == \"shgo\":\n kwargs = {\"options\": {\"maxiter\": self._maxiter,\n \"jac\": self.cost_func.jac_cost}}\n elif self.minimizer == \"dual_annealing\":\n kwargs = {\"maxiter\": self._maxiter, \"local_search_options\": {\n \"jac\": self.cost_func.jac_cost}}\n fun = self.cost_func.eval_cost\n bounds = self.value_ranges\n algorithm = getattr(optimize, self.minimizer)\n result = algorithm(fun, bounds, **kwargs)\n self._popt = result.x\n if result.success:\n self._status = 0\n elif \"Maximum number of iteration\" in result.message:\n self._status = 1\n else:\n self._status = 2","def target_and_grad(x, ref_params, data_modelers, SIM, params):\n target_functional = 0\n grad = np.zeros(len(x))\n\n save_name = params.geometry.optimized_detector_name\n if not all(params.geometry.fix.panel_rotations) and not all(params.geometry.fix.panel_rotations):\n geometry_refiner.update_detector(x, ref_params, SIM, save_name)\n\n all_shot_sigZ = []\n for i_shot in data_modelers:\n Modeler = data_modelers[i_shot]\n\n neg_LL, neg_LL_grad, model_pix, per_shot_sigZ = model(x, ref_params, i_shot, Modeler, SIM)\n all_shot_sigZ.append(per_shot_sigZ)\n\n # accumulate the target functional for this rank/shot\n target_functional += neg_LL\n\n if params.use_restraints:\n for name in ref_params:\n par = ref_params[name]\n if not par.is_global and not par.fix:\n val = par.get_restraint_val(x[par.xpos])\n target_functional += val\n\n # accumulate the gradients for this rank/shot\n for name in ref_params:\n if name in neg_LL_grad:\n par = ref_params[name]\n grad[par.xpos] += neg_LL_grad[name]\n # for restraints only update the per-shot restraint gradients here\n if params.use_restraints and not par.is_global and not par.fix:\n grad[par.xpos] += par.get_restraint_deriv(x[par.xpos])\n\n # sum the target functional and the gradients across all ranks\n target_functional = COMM.bcast(COMM.reduce(target_functional))\n grad = COMM.bcast(COMM.reduce(grad))\n\n if params.use_restraints and params.geometry.betas.close_distances is not None:\n target_functional += np.std(SIM.D.close_distances) / params.geometry.betas.close_distances\n\n ## add in the detector parameter restraints\n if params.use_restraints:\n for name in ref_params:\n par = ref_params[name]\n if par.is_global and not par.fix:\n target_functional += par.get_restraint_val(x[par.xpos])\n grad[par.xpos] += par.get_restraint_deriv(x[par.xpos])\n\n all_shot_sigZ = COMM.reduce(all_shot_sigZ)\n if COMM.rank == 0:\n all_shot_sigZ = np.median(all_shot_sigZ)\n\n return target_functional, grad, all_shot_sigZ","def solver_mtw(Xf, mXf, Ls, y, M, alpha, beta1, beta2, epsilon, gamma, coef1,\n coef2, R, b1, b2, sigmas, concomitant=False,\n stable=False, tol=1e-4, max_iter=1000, tol_ot=1e-5,\n max_iter_ot=20, max_iter_cd=2000,\n positive=False, n_jobs=1, tol_cd=1e-5, gpu=False,\n ot_threshold=0):\n log = {'loss': [], 'dloss': [], 'log_sinkhorn1': [], 'log_sinkhorn2': [],\n 'stable': stable, \"objcd\": [], \"fot1\": [0.], \"fot2\": [0.],\n 'reweighting_loss': [], \"n_coords\": [], \"obj\": 0.}\n n_samples, n_features = Xf[0].shape\n n_tasks = len(Xf)\n if n_jobs == -1:\n n_jobs = n_tasks\n marginals1, marginals2 = np.ones((2, n_tasks, n_features)) / n_features\n\n theta1 = coef1.copy()\n theta2 = coef2.copy()\n theta = theta1 - theta2\n\n thetaold = theta.copy()\n\n ot_img = True\n if len(M) == n_features:\n ot_img = False\n\n update_ot_1 = set_ot_func(stable, ot_img)\n update_ot_2 = set_ot_func(stable, ot_img)\n\n xp = utils.set_module(gpu)\n M = xp.asarray(- M / epsilon)\n if b1 is not None:\n b1 = xp.asarray(b1)\n if b2 is not None:\n b2 = xp.asarray(b2)\n\n thetabar1 = np.ones_like(coef1).mean(axis=-1)\n thetabar2 = np.ones_like(coef2).mean(axis=-1)\n\n if positive:\n theta2 *= 0.\n thetabar2 *= 0.\n theta = theta1\n a = n_samples * alpha * gamma\n beta1 = n_samples * beta1\n beta2 = n_samples * beta2\n\n if concomitant:\n sigma0 = 0.01 * np.linalg.norm(y, axis=1).min() / (n_samples ** 0.5)\n else:\n sigma0 = 0.\n with Parallel(n_jobs=n_jobs, backend=\"threading\") as pll:\n if alpha == 0.:\n theta, R, sigmas, mx = update_coefs(pll, Xf, y, theta, R,\n Ls, marginals1,\n sigmas, a, beta1,\n sigma0,\n tol=tol_cd,\n max_iter=max_iter_cd,\n positive=positive)\n obj = 0.5 * (R ** 2).sum(axis=1).dot(1 / sigmas) / n_samples\n obj += beta1 * abs(theta).sum() + 0.5 * sigmas.sum()\n theta1, theta2 = utils.get_unsigned(theta)\n log['loss'].append(obj)\n else:\n for i in range(max_iter):\n obj = 0.\n if not positive:\n Y1 = utils.residual(Xf, - theta2, y)\n else:\n Y1 = y\n theta1, R, sigmas, mxp = update_coefs(pll, Xf, Y1, theta1, R,\n Ls,\n marginals1,\n sigmas,\n a, beta1,\n sigma0,\n tol=tol_cd,\n max_iter=max_iter_cd)\n if not positive:\n Y2 = utils.residual(Xf, theta1, y)\n theta2, R, sigmas, mx = update_coefs(pll, mXf, Y2, theta2,\n R,\n Ls,\n marginals2,\n sigmas,\n a, beta2,\n sigma0,\n tol=tol_cd,\n max_iter=max_iter_cd)\n theta = theta1 - theta2\n else:\n theta = theta1\n\n dx = abs(theta - thetaold) / max(1, thetaold.max(),\n theta.max())\n dx = dx.max()\n thetaold = theta.copy()\n if alpha:\n if (theta1 > ot_threshold).any(0).all():\n fot1, log_ot1, marginals1, b1, q1 = \\\n update_ot_1(theta1, M, epsilon, gamma,\n b=b1, tol=tol_ot,\n max_iter=max_iter_ot,\n threshold=ot_threshold)\n if fot1 is None or not theta1.max(0).all():\n warnings.warn(\"Numerical errors. Moving in \"\n \"log-domain.\")\n b1 = xp.log(b1 + 1e-100, out=b1)\n stable = True\n update_ot_1 = set_ot_func(True, ot_img)\n fot1, log_ot1, marginals1, b1, q1 = \\\n update_ot_1(theta1, M, epsilon, gamma, b=b1,\n tol=tol_ot, max_iter=max_iter_ot,\n threshold=ot_threshold)\n\n log[\"log_sinkhorn1\"].append(log_ot1)\n thetabar1 = q1\n log[\"fot1\"].append(fot1)\n obj += alpha * fot1\n if not positive and (theta2 > ot_threshold).any(0).all():\n fot2, log_ot2, marginals2, b2, q2 = \\\n update_ot_2(theta2, M, epsilon, gamma,\n b=b2, tol=tol_ot, max_iter=max_iter_ot)\n\n if fot2 is None or not theta2.max(0).all():\n warnings.warn(\"Numerical errors. Moving in \"\n \"log-domain.\")\n b2 = xp.log(b2 + 1e-100, out=b2)\n stable = True\n update_ot_2 = set_ot_func(True, ot_img)\n fot2, log_ot2, marginals2, b2, q2 = \\\n update_ot_2(theta2, M, epsilon, gamma,\n b=b2, tol=tol_ot,\n max_iter=max_iter_ot)\n\n log[\"log_sinkhorn2\"].append(log_ot2)\n thetabar2 = q2\n log[\"fot2\"].append(fot2)\n obj += alpha * fot2\n\n log['loss'].append(obj)\n log['dloss'].append(dx)\n\n if dx < tol:\n break\n if i == max_iter - 1:\n warnings.warn('Objective did not converge.' +\n ' You might want' +\n ' to increase the number of iterations.' +\n ' Fitting data with very small alpha and' +\n ' beta may cause precision problems.',\n ConvergenceWarning)\n log['stable'] = stable\n\n if positive:\n theta2 *= 0.\n thetabar2 = xp.zeros_like(thetabar1)\n try:\n thetabar2 = thetabar2.get()\n except AttributeError:\n pass\n return (theta1, theta2, thetabar1, thetabar2, log, sigmas, b1, b2, R)","def example():\n Optimizer = BFGS(f, g)\n startPoint = 100 * numpy.ones(2);\n res = Optimizer.optimize(startPoint,\n epsilon=1e-5,\n maxIterations=10)\n print res\n pass","def run_qae_optimization(training_states, n_repetitions, exact=no_noise, noisy=gate_error):\n result_list = []\n def proxy(params, training_states, n_repetitions, exact=no_noise, noisy=gate_error):\n \"\"\"Embedded function version\n \"\"\"\n input_list = fix_list(params, all_param_array=all_param, var_param_array=var_param, fixed_vals_array=fixed_vals)\n fidelities = []\n for training_state in training_states:\n fid = cusp_stage2.compute_stage2_cost_function(*input_list, alpha=training_state, n_repetitions=n_repetitions,\n exact=exact, noisy=noisy)\n fidelities.append(fid)\n avg_fid = np.mean(fidelities)\n result_list.append(1-avg_fid)\n print(1-avg_fid)\n return 1. - avg_fid\n\n \n # Initialize parameters\n half_turn_min = 0\n half_turn_max = 2\n init_params = np.random.uniform(low=half_turn_min, high=half_turn_max,\n size=num_param)\n\n # Optimization using Nelder-Mead.\n h2_qae_wrap = lambda params: proxy(params, training_states=training_states,\n n_repetitions=n_repetitions, exact=exact, noisy=noisy)\n \n if noisy:\n maxiter = 60\n else:\n maxiter = None\n \n res = minimize(h2_qae_wrap, init_params, args=(),\n method='Nelder-Mead', tol=None, \n options={'disp': False, 'maxiter': maxiter, 'xatol': 0.001,\n 'return_all': False, 'fatol': 0.001})\n np.savetxt('stage2_data.csv',result_list, delimiter=',')\n return res.x","def step(self, closure=None):\n orig_loss,err,pred = closure()\n loss = orig_loss\n\n group = self.param_groups[0]\n lr = group['lr']\n decay_lr = group['decay_lr']\n max_iter = group['max_iter']\n reg = group['reg']\n backtrack = group['backtrack']\n bt_alpha = group['bt_alpha']\n bt_beta = group['bt_beta']\n sketch_size = group['sketch_size']\n tolerance = group['tolerance']\n\n #import pdb; pdb.set_trace()\n n = err.shape[0] #batch size\n #If sketching the jacobian, randomly select [sketch_size] samples\n \n if sketch_size is not None:\n idx = torch.randperm(n)[:sketch_size]\n else:\n idx = torch.arange(n) #Don't sketch, use all samples\n \n w0 = nn.utils.parameters_to_vector(self._params) #weight parameters in vector form\n \n #Compute Gauss-Newton vector product \n grad, ggnvp = _make_ggnvp(err,self._params,w0,n,reg,idx) #return gradient in vector form + ggnvp function\n #Solve for the Conjugate Gradient Direction\n dw, cost_log = _conjugate_gradient(ggnvp, grad, max_iter, tolerance)\n\n #Perform backtracking line search\n val = loss + 0.5 * reg * torch.norm(w0)**2\n fprime = -1*dw @ grad\n \n self.grad_update += 1\n if backtrack > 0:\n t = lr\n\n #TODO: If using backtracking, get new loss with (w0 - t*dw) as network parameters\n bts = 0\n alpha = bt_alpha\n beta = bt_beta \n while (loss + 0.5 * reg * torch.norm(w0 - t*dw)**2 > val + alpha * t * fprime):\n t = beta * t\n bts += 1\n if bts > backtrack:\n print('Maximum backtracking reached, accuracy not guaranteed')\n break\n elif decay_lr: #decay lr\n t = lr/np.maximum(1, self.grad_update-10)\n else: #use lr step-size\n t = lr\n\n print('step size: {}'.format(t))\n\n #Update the model parameters\n self._add_grad(-t, dw)\n \n return val, pred","def run(self, n_trials=10):\n # Create study object\n if self.study is None:\n self.study = optuna.create_study(\n direction=\"minimize\",\n sampler=optuna.samplers.RandomSampler(seed=123)\n )\n # Run trials\n self.study.optimize(\n lambda x: self.objective(x),\n n_trials=n_trials,\n n_jobs=-1\n )","def _optimize(self):\n # Retrieve all trainable variables\n train_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n\n # Compute the gradient (return a pair of variable and their respective gradient)\n grads = self.optimizer.compute_gradients(loss=self.loss, var_list=train_variables)\n self.train_dis = self.optimizer.apply_gradients(grads, global_step=self.global_step)","def optimize(self,s,max_steps,td_n):\r\n \r\n s1, d1, a1, r1, s2, done = self.ram.sample(self.batch_size)\r\n s1 = torch.from_numpy(s1).float()\r\n #print(s1.shape)\r\n d1 = torch.from_numpy(d1).float()\r\n d1 = d1.unsqueeze(1)\r\n d1.requires_grad = True\r\n d1_copy = d1.detach().cpu().numpy()\r\n self.mse_logic.append(d1_copy[-1][-1])\r\n a1 = torch.from_numpy(a1).float()\r\n #print(a1.shape)\r\n r1 = torch.from_numpy(r1).float()\r\n r1 = torch.squeeze(r1)\r\n #print(r1.size())\r\n s2 = torch.from_numpy(s2).float()\r\n done = torch.from_numpy(done).float()\r\n self.t = s\r\n self.T = max_steps\r\n self.td_n = td_n\r\n self.td_tau = self.t-self.td_n+1\r\n if self.td_tau >= 0:\r\n for i in range(self.td_tau+1, min(self.td_tau+self.td_n, self.T)):\r\n self.G = self.gamma**(i-self.td_tau-1)*(r1)\r\n if self.td_tau+self.td_n < self.T:\r\n #-----------optimize critic -----------------------------------\r\n a2 = self.target_actor.forward(s2).detach()\r\n noise = a1.data.normal_(0,0.2)\r\n noise = noise.clamp(-0.5,0.5)\r\n a2 = (a2+noise).clamp(-1,1)\r\n next_val = torch.squeeze(self.target_critic.forward(s2,a2).detach())\r\n y_expected = self.G + self.gamma**(self.td_n)*next_val*(1-done)\r\n y_predicted = torch.squeeze(self.critic.forward(s1, a1))\r\n # compute critic loss, and update the critic\r\n loss_critic = self.l_loss(y_predicted, y_expected.detach()).unsqueeze(0)\r\n self.critic_optimizer.zero_grad()\r\n loss_critic.backward()\r\n self.critic_optimizer.step()\r\n \r\n #-----------optimize actor --------------------------------------\r\n pred_a1 = self.actor.forward(s1)\r\n pred_a1_copy = pred_a1.detach().numpy()\r\n self.actor_logic.append(pred_a1_copy[-1][-1])\r\n loss_actor = -self.critic.forward(s1, pred_a1).mean()\r\n #entropy = torch.mean(pred_a1*torch.log(pred_a1))\r\n loss_policy = loss_actor\r\n self.loss_l1_list.append(loss_policy.item())\r\n mse_policy = self.target_critic(s1,d1).mean()\r\n loss_mse = self.mse(loss_actor, mse_policy)\r\n self.loss_mse_list.append(loss_mse.item())\r\n loss = sum([(1-self.lambda_mse)*loss_policy, self.lambda_mse*loss_mse])\r\n self.loss_final_list.append(loss.item())\r\n self.actor_optimizer.zero_grad()\r\n loss.backward()\r\n self.actor_optimizer.step()\r\n \r\n soft_update(self.target_actor, self.actor, self.tau)\r\n soft_update(self.target_critic, self.critic, self.tau)\r\n \r\n #self.actor.state_dict(self.target_actor.state_dict())\r\n #self.critic.state_dict(self.target_critic.state_dict())\r","def least_squares_GD(y, tx, initial_w, max_iters, gamma):\n # Define parameters to store w and loss\n w = initial_w\n for n_iter in range(max_iters):\n # compute gradient\n grad = compute_gradient(y, tx, w)\n # gradient w by descent update\n if n_iter % (max_iters//10) == 0:\n print(compute_cost(y, tx, w))\n w -= gamma * grad\n\n return w, compute_cost(y, tx, w)","def test_gradient_step(var_f, len_f, var_y, N):\n\n x, y = build_data(N)\n\n gp_model = initialise_gp_model(var_f, len_f, var_y, x, y)\n markovgp_model = initialise_markovgp_model(var_f, len_f, var_y, x, y)\n\n gv = objax.GradValues(gp_model.energy, gp_model.vars())\n gv_markov = objax.GradValues(markovgp_model.energy, markovgp_model.vars())\n\n lr_adam = 0.1\n lr_newton = 1.\n opt = objax.optimizer.Adam(gp_model.vars())\n opt_markov = objax.optimizer.Adam(markovgp_model.vars())\n\n gp_model.update_posterior()\n gp_grads, gp_value = gv()\n gp_loss_ = gp_value[0]\n opt(lr_adam, gp_grads)\n gp_hypers = np.array([gp_model.kernel.lengthscale, gp_model.kernel.variance, gp_model.likelihood.variance])\n print(gp_hypers)\n print(gp_grads)\n\n markovgp_model.update_posterior()\n markovgp_grads, markovgp_value = gv_markov()\n markovgp_loss_ = markovgp_value[0]\n opt_markov(lr_adam, markovgp_grads)\n markovgp_hypers = np.array([markovgp_model.kernel.lengthscale, markovgp_model.kernel.variance,\n markovgp_model.likelihood.variance])\n print(markovgp_hypers)\n print(markovgp_grads)\n\n np.testing.assert_allclose(gp_grads[0], markovgp_grads[0], rtol=1e-4)\n np.testing.assert_allclose(gp_grads[1], markovgp_grads[1], rtol=1e-4)\n np.testing.assert_allclose(gp_grads[2], markovgp_grads[2], rtol=1e-4)","def optimize(self):\n\n self.logger.info(\"Solving with Dynamic Slope Scaling Procedure in Julia :\")\n optimization_start = time.time()\n\n # 1. Preprocess for old network graph\n if self.old_network_graph is not None:\n\n # DSSP on old network\n old_network_obj = sum(list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values()))-1e-5\n try:\n self.check_infeasibility(self.old_network_graph, old_network_obj)\n except DHCOptimizerException as e:\n e.data = \"Invalid existing network: \" + e.data\n raise e\n\n flows, obj_val = self.optimize_with_dssp_julia(self.old_network_graph, old_network_obj, set())\n self.logger.info(\"Optimization phase time: %.2fs\" % (time.time() - optimization_start))\n solution_old_graph = self.build_solution_graph(self.old_network_graph, flows)\n\n if self.modify_old_network:\n\n # Add max capacity on old edges\n self.old_capacity = deepcopy(flows)\n old_buildings = list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values())\n for key in flows:\n if (key[1],key[0],0) not in self.old_capacity and key[1] not in old_buildings:\n self.old_capacity[(key[1],key[0],0)] = self.old_capacity[key]\n\n # Add Imaginary edges\n for edge in self.old_capacity:\n if self.optimization_graph.has_edge(*edge):\n\n # add nodes\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[0]):\n self.optimization_graph.add_node(config.IM_PREFIX+edge[0])\n self.optimization_graph.nodes[config.IM_PREFIX+edge[0]][config.GPD_GEO_KEY] = \\\n self.optimization_graph.nodes[edge[0]][config.GPD_GEO_KEY]\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[1]):\n self.optimization_graph.add_node(config.IM_PREFIX+edge[1])\n self.optimization_graph.nodes[config.IM_PREFIX+edge[1]][config.GPD_GEO_KEY] = \\\n self.optimization_graph.nodes[edge[1]][config.GPD_GEO_KEY]\n # add edges\n if not self.optimization_graph.has_edge(edge[0],config.IM_PREFIX+edge[0]):\n self.optimization_graph.add_edge(edge[0],config.IM_PREFIX+edge[0])\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1]):\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1])\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[1],edge[1]):\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[1],edge[1])\n\n # put cost\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY] = \\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY]\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\n self.optimization_graph.edges[(edge[0],config.IM_PREFIX+edge[0],0)][config.EDGE_COST_KEY] = 1e-5\n self.optimization_graph.edges[(config.IM_PREFIX+edge[1],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\n\n else:\n # if we don't modify the old network, we have to change the capacity of the supplies\n already_consummed = {}\n for edge in solution_old_graph.edges():\n if solution_old_graph.nodes[edge[0]].get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\n already_consummed[edge[0]] = already_consummed.get(edge[0], 0) + \\\n solution_old_graph.edges[edge][config.SOLUTION_POWER_FLOW_KEY]\n for source in already_consummed:\n if already_consummed[source] <= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]:\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] -= already_consummed[source]\n self.network_objective -= already_consummed[source]\n else:\n self.network_objective -= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] = 0\n\n # Remove edges from old network\n edges_to_remove = set()\n for e in self.optimization_graph.edges():\n if self.old_network_graph.has_edge(*e) or self.old_network_graph.has_edge(e[1],e[0]):\n edges_to_remove.add(e)\n self.optimization_graph.remove_edges_from(edges_to_remove)\n\n # Remove isolated buildings of optimization graph\n isolated_to_remove = set()\n for e in self.old_network_graph.edges():\n if e[0] in self.old_network_graph.nodes() and \\\n self.optimization_graph.nodes[e[1]].get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\n isolated_to_remove.add(e)\n self.optimization_graph.remove_edges_from(isolated_to_remove)\n\n # Remove buildings from old network\n for n, data in self.old_network_graph.nodes(data=True):\n if data.get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\n self.optimization_graph.remove_node(n)\n\n # Re-link sources\n sources = set()\n for n, data in self.optimization_graph.nodes(data=True):\n if data.get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\n sources.add(n)\n source_graph = self.optimization_graph.subgraph(sources).copy()\n self.optimization_graph.remove_nodes_from(sources)\n gnx.remove_isolates(self.optimization_graph)\n node_filter = lambda n: self.optimization_graph.nodes.get(n,{}).get(config.NODE_TYPE_KEY) != config.BUILDING_NODE_TYPE\n gnx.spatial_points_merge(self.optimization_graph, source_graph.nodes_to_gdf(), node_filter=node_filter, inplace=True)\n\n # fill missing information\n gnx.fill_edges_missing_geometry_attributes(self.optimization_graph)\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_LENGTH_KEY, only_missing=True)\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_COST_KEY, only_missing=True)\n for e in self.optimization_graph.edges(keys=True):\n self.optimization_graph.edges[e][config.LEASTCOST_COEF_KEY] = \\\n self.optimization_graph.edges[e].get(config.LEASTCOST_COEF_KEY,0)\n\n\n\n # 2. Process the DSSP on optimization graph\n self.check_is_ready()\n self.check_infeasibility(self.optimization_graph, self.network_objective)\n\n if self.old_network_graph is not None and self.modify_old_network:\n old_buildings = set(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).keys())\n else:\n old_buildings = set()\n flows, obj_val = self.optimize_with_dssp_julia(self.optimization_graph, self.network_objective, old_buildings,postprocess= (not self.modify_old_network))\n self.logger.info(\"Optimization phase time: %.2fs\" % (time.time() - optimization_start))\n self.solution_graph = self.build_solution_graph(self.optimization_graph, flows, self.connected)\n\n # 3. Postprocess for old network graph\n if self.old_network_graph is not None:\n \n if self.modify_old_network:\n # Put the right supply capacity and cost\n for edge in self.old_capacity:\n if self.solution_graph.has_edge(edge[0],edge[1]):\n self.solution_graph.edges[(edge[0],edge[1])][config.EDGE_COST_KEY] = \\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY]\n \n # Remove imaginary edges\n imaginary_nodes_to_remove = set()\n nodes_to_relabel = {}\n for edge in self.solution_graph.edges():\n if str(edge[0]).startswith(config.IM_PREFIX) and str(edge[1]).startswith(config.IM_PREFIX):\n real_edge = edge[0][len(config.IM_PREFIX):],edge[1][len(config.IM_PREFIX):]\n self.old_capacity[(real_edge[0], real_edge[1], 0)] = pd.np.inf\n self.old_capacity[(real_edge[1], real_edge[0], 0)] = pd.np.inf\n if not self.solution_graph.has_edge(*real_edge):\n for i in range(2):\n nodes_to_relabel[edge[i]] = real_edge[i]\n else:\n self.solution_graph.edges[real_edge[0],real_edge[1]][config.SOLUTION_POWER_FLOW_KEY] += \\\n self.solution_graph.edges[edge].get(config.SOLUTION_POWER_FLOW_KEY,0)\n imaginary_nodes_to_remove.add(edge[0])\n imaginary_nodes_to_remove.add(edge[1])\n elif str(edge[0]).startswith(config.IM_PREFIX):\n imaginary_nodes_to_remove.add(edge[0])\n elif str(edge[1]).startswith(config.IM_PREFIX):\n imaginary_nodes_to_remove.add(edge[1])\n\n nx.relabel_nodes(self.solution_graph, nodes_to_relabel, copy=False)\n self.solution_graph.remove_nodes_from(list(imaginary_nodes_to_remove))\n for node in nodes_to_relabel.values():\n if self.solution_graph.has_edge(node, node):\n self.solution_graph.remove_edge(node, node)\n\n else:\n for source in nx.get_node_attributes(self.solution_graph, config.SUPPLY_POWER_CAPACITY_KEY):\n self.solution_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\n\n return flows, obj_val","def optimize(w, b, x, y, num_iterations, learning_rate, print_cost=False):\n\n costs = []\n\n for i in range(num_iterations):\n\n # Cost and gradient calculation\n grads, cost = propagate(w, b, x, y)\n\n # Retrieve derivatives from grads\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n\n # Update rule\n w = w - (dw * learning_rate)\n b = b - (db * learning_rate)\n\n # Record the costs\n if i % 100 == 0:\n costs.append(cost)\n\n # Print the cost every 100 training iterations\n if print_cost and i % 100 == 0:\n print(\"Cost after iteration %i: %f\" % (i, cost))\n\n params = {\"w\": w,\n \"b\": b}\n\n grads = {\"dw\": dw,\n \"db\": db}\n\n return params, grads, costs","def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\n costs = []\n for i in range(num_iterations):\n # Cost and gradient calculation \n grads, cost = propagate(w, b, X, Y)\n # Retrieve derivatives from grads\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n # update rule (≈ 2 lines of code)\n w = w-learning_rate*dw\n b = b-learning_rate*db\n # Record the costs\n if i % 100 == 0:\n costs.append(cost)\n # Print the cost every 100 training examples\n if print_cost and i % 100 == 0:\n print (\"Cost after iteration %i: %f\" %(i, cost))\n params = {\"w\": w,\n \"b\": b}\n grads = {\"dw\": dw,\n \"db\": db}\n return params, grads, costs","def sgd_optimization(dataset, learning_rate, n_epochs, batch_size):\n datasets = load_data(dataset)\n train_set_x, train_set_y = datasets[0]\n valid_set_x, valid_set_y = datasets[1]\n test_set_x, test_set_y = datasets[2]\n\n #number of minibatches\n n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size\n n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] / batch_size\n n_test_batches = test_set_x.get_value(borrow=True).shape[0] / batch_size\n\n #build the model\n print \"... building the model\"\n\n index = T.lscalar()\n x = T.matrix('x') #data for the rasterized images\n y = T.ivector('y') # labels (int)\n\n # logistic regression Class\n classifierLR = LogisticRegression(input=x, n_in=28*28, n_out=10)\n cost = classifierLR.negative_log_likelihood(y)\n\n # test model (no updates)\n test_model = theano.function(\n inputs=[index],\n outputs=classifierLR.errors(y),\n givens={\n x: test_set_x[index * batch_size: (index + 1) * batch_size],\n y: test_set_y[index * batch_size: (index + 1) * batch_size]\n }\n )\n\n #validate model (no updates)\n validate_model = theano.function(\n inputs=[index],\n outputs=classifierLR.errors(y),\n givens={\n x: valid_set_x[index * batch_size: (index + 1) * batch_size],\n y: valid_set_y[index * batch_size: (index + 1) * batch_size]\n }\n )\n\n #compute the gradient of cost wrt W, b\n g_W = T.grad(cost=cost, wrt=classifierLR.W)\n g_b = T.grad(cost=cost, wrt=classifierLR.b)\n\n #updating expression\n updates = [(classifierLR.W, classifierLR.W - learning_rate * g_W),\n (classifierLR.b, classifierLR.b - learning_rate * g_b)]\n\n # Train model (theano function); updates\n train_model = theano.function(\n inputs=[index],\n outputs=cost,\n updates=updates,\n givens={\n x: train_set_x[index * batch_size: (index + 1) * batch_size],\n y: train_set_y[index * batch_size: (index + 1) * batch_size]\n\n }\n )\n\n # Training model (early stopping with validation examples)\n print \"... training the model\"\n patience = 5000\n patience_inc = 2 # wait this much\n improved_threshold = 0.995 # relative improvement (significant)\n validation_frequency = min(n_train_batches, patience / 2)\n best_validation_loss = numpy.inf\n test_score = 0.\n start_time = timeit.default_timer()\n\n done_looping = False\n epoch = 0\n while (epoch < n_epochs) and (not done_looping):\n epoch += 1\n for minibatch_index in xrange(n_train_batches):\n minibatch_avg_cost = train_model(minibatch_index)\n iter = (epoch - 1) * n_train_batches + minibatch_index\n\n if (iter + 1) % validation_frequency == 0:\n # compute loss on validation set\n validation_losses = [validate_model(i) for i in xrange(n_valid_batches)]\n this_validation_loss = numpy.mean(validation_losses)\n\n print(\n \"Epoch: %i, minibatch: %i/%i, validation_error: %f %%\" %\n (\n epoch,\n minibatch_index + 1,\n n_train_batches,\n this_validation_loss * 100.\n )\n )\n\n if this_validation_loss < best_validation_loss:\n #improve patience if good improvement\n if this_validation_loss < best_validation_loss * improved_threshold:\n patience = max(patience, iter * patience_inc)\n\n best_validation_loss = this_validation_loss\n\n #testing on test_set\n test_losses = [test_model(i) for i in xrange(n_test_batches)]\n test_score = numpy.mean(test_losses)\n\n print(\n (\n \"Epoch : %i, minibatch %i/%i,\"\n \" test error of best model %f %%\"\n ) % (\n epoch,\n minibatch_index,\n n_train_batches,\n test_score * 100.\n )\n )\n\n #save the best model\n print \"New best model found; saving ...\"\n with open('best_model.pkl', \"w\") as f:\n cPickle.dump(classifierLR, f)\n\n if patience <= iter:\n done_looping = True\n break\n\n\n end_time = timeit.default_timer()\n print(\n (\n \"Optimization Complete: best validation score : %f %%,\"\n \" test performance : %f %%\"\n )\n % (best_validation_loss * 100., test_score * 100.)\n )\n print \"The code run for %d epochs, with %f epochs/sec\" %(epoch, 1. * epoch / (end_time - start_time))\n print >> sys.stderr, (\"The code for file \" + os.path.split(__file__)[1] + \" ran for %.1fs\" % ((end_time - start_time)))","def _optimize(optimizer, regularization_losses, scope, **kwargs):\n sum_loss = _gather_loss(regularization_losses, scope)\n grad = None\n if sum_loss is not None:\n grad = optimizer.compute_gradients(sum_loss, **kwargs)\n return sum_loss, grad","def run(self):\n\n # Initializing required variables for the algorithm\n start = time.time()\n i = 0\n w = self.w\n k = 99.99\n\n #Running the algorithm till tolerance is reached\n while k > self.tolerance: \n\n i = i + 1\n\n if self.verbose:\n print(\"Iteration \" + str(i),end=\"\\r\")\n\n # Following is a gradient descent algorithm\n # You can find the update step at the following\n # link, https://raw.githubusercontent.com/mnk400/linearRegression/master/img/EUC.png\n t_0 = w.T.dot(w)\n t_1 = self.x.T.dot(self.x).dot(w)\n gradient = (2/t_0) * (t_1) - (2/t_0**2) * np.transpose(w).dot(t_1) * (w)\n w_new = w - (1/self.DATAPOINTS) * 0.3 * gradient\n w_new[-1] = -1\n l = len(self.x[0]) - 1 \n y_plt = np.dot(self.x[:,0:l],w_new[:-1]) \n\n #tolerance is checked against the root mean square of change in weights\n k = np.dot(np.transpose(w - w_new),(w - w_new))\n\n #Updating the weights \n w = w_new\n\n if self.verbose:\n print(\"Tolerance Reached\")\n timetaken = round(time.time() - start, 3)\n print(\"Ran for \" + str(timetaken) + \" seconds\" + \" in \" + str(i) + \" iterations.\")\n\n return w_new, y_plt","def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\n\n costs = []\n\n for i in range(num_iterations):\n\n grads, cost = propagate(w, b, X, Y)\n\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n\n w = w - learning_rate * dw\n b = b - learning_rate * db\n\n if i % 100 == 0:\n costs.append(cost)\n\n # Print the cost every 100 training iterations\n if print_cost and i % 100 == 0:\n print (\"Cost after iteration %i: %f\" %(i, cost))\n\n params = {\"w\": w,\n \"b\": b}\n\n grads = {\"dw\": dw,\n \"db\": db}\n\n return params, grads, costs","def optimize(self, iterations=1000):\r\n prev = None\r\n finalx = None\r\n finaly = None\r\n while iterations:\r\n maxei, eis = self.acquisition()\r\n new_y = self.f(maxei)\r\n if maxei == prev:\r\n break\r\n self.gp.update(maxei, new_y)\r\n pycodehack = finaly is None or self.minimize and finaly > new_y\r\n if ((pycodehack or not self.minimize and finaly < new_y)):\r\n finaly = new_y\r\n finalx = maxei\r\n prev = maxei\r\n iterations -= 1\r\n return finalx, finaly","def least_squares_GD(y, tx, initial_w, max_iters, gamma, debug = False):\n losses, ws = gradient_descent(y, tx, initial_w, max_iters, gamma, loss_f = model_linear.compute_loss, grad_f = model_linear.compute_gradient, debug = debug)\n return get_last_ans(ws, losses)","def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost=False):\n costs = []\n\n for i in range(num_iterations):\n\n grads, cost = propagate(w, b, X, Y)\n\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n\n w = w - learning_rate * dw\n b = b - learning_rate * db\n\n # Record the costs\n if i % 100 == 0:\n costs.append(cost)\n\n # Print the cost every 100 training examples\n if print_cost and i % 100 == 0:\n print(\"Cost after iteration %i: %f\" % (i, cost))\n\n params = {\"w\": w,\n \"b\": b}\n\n grads = {\"dw\": dw,\n \"db\": db}\n\n return params, grads, costs","def test_grad_computations(self, samples, training_points):\n \n self.add_p_tilda(training = False)\n \n do_updates = OrderedDict()\n \n self.b.set_value(self.b_init)\n \n self.W.set_value(self.W_init)\n \n gradW = theano.shared(np.zeros([self.num_vars,self.num_vars]))\n \n gradb = theano.shared(np.zeros([self.num_vars]))\n \n [gradW, gradb], updates =\\\n theano.scan(lambda i, gradW, gradb: [gradW+ \\\n (1.0-self.batch_size*self.p_tilda[i])\\\n *self.xn_xn_prod(self.x[i,:]),\n gradb+ \\\n (1.0-self.batch_size*self.p_tilda[i])\\\n *self.x[i,:]],\n outputs_info =[gradW, gradb],\n sequences =[T.arange(self.batch_size)])\n \n gradW = gradW[-1]\n \n gradb = gradb[-1]\n \n do_updates.update(updates)\n \n [gradW, gradb], updates = \\\n theano.scan(lambda i, gradW, gradb: [gradW - \\\n self.batch_size*self.p_tilda[self.batch_size+i]*\\\n self.xn_xn_prod(self.x_tilda[i,:]),\n gradb-self.batch_size*self.p_tilda[self.batch_size+i]*\\\n self.x_tilda[i,:]],\n outputs_info =[gradW, gradb],\n sequences =[T.arange(self.num_samples)])\n \n gradW = gradW[-1] /self.batch_size\n \n gradb = gradb[-1] /self.batch_size\n \n gradW = gradW - T.diag(T.diag(gradW)) # no recurrent connections\n \n do_updates.update(updates)\n \n ## ML objective log likelihood (ascend gradient)\n ## the first, more efficient implementation uses the cost\n ## objective which is negative of the log likelihood.\n \n do_updates.update([(self.W, self.W + self.learning_rate*gradW)])\n \n do_updates.update([(self.b, self.b + self.learning_rate*gradb)])\n \n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\n \n var_list = [self.x_tilda, self.minibatch_set, self.learning_rate]\n \n test_grads = theano.function(inputs = var_list,\n outputs= [],\n updates= do_updates,\n givens = input_dict,\n on_unused_input='warn')\n \n test_grads(samples, training_points)","def maximize(self, budget, optimizer):\n\n\t\tpass","def perform_bayesian_optimization(self):\n bounds = {'hunits': (self.hunits_lower, self.hunits_upper),\n 'embedding_dim': (self.embedding_dim_lower, self.embedding_dim_upper)}\n optimizer = BayesianOptimization(f=self.lstm_score, pbounds=bounds, random_state=1)\n optimizer.maximize(init_points=2, n_iter=self.iterations)\n print(optimizer.max)\n print(optimizer.res)","def run_step_blackbox_optimizer(config,\n current_input,\n blackbox_optimizer,\n proposed_perturbations,\n finished_dnas,\n results,\n logging_data=None):\n core_hyperparameters = blackbox_optimizer.get_hyperparameters()\n function_values = [0.0] * len(proposed_perturbations)\n rewards_for_controller = []\n perturbations = proposed_perturbations\n evaluation_stats = []\n current_value_exact = 0.0\n current_value_exact_counter = 0\n\n for i in range(len(results)):\n rewards_for_controller.append(results[i]['function_value'])\n tag = results[i]['tag']\n index = 0\n if tag > 0:\n if config.est_type == 'antithetic':\n index = (tag - 1) * 2\n function_values[index] += results[i]['function_value']\n else:\n index = tag - 1\n function_values[index] += results[i]['function_value']\n if tag < 0:\n index = (-tag - 1) * 2 + 1\n function_values[index] += results[i]['function_value']\n if tag == 0:\n current_value_exact += results[i]['function_value']\n current_value_exact_counter += 1\n current_value_exact /= float(current_value_exact_counter)\n\n for result in results:\n evaluation_stat = list(result['evaluation_stat'])\n evaluation_stats.append(evaluation_stat)\n\n function_values_reshaped = np.array(function_values)\n perturbations_reshaped = np.array(perturbations)\n\n logging.info('LIST OF FUNCTION VALUES')\n logging.info(function_values_reshaped)\n\n logging.info('MAX VALUE SEEN CURRENTLY')\n logging.info(np.max(function_values_reshaped))\n\n logging.info('MEAN OF VALUES')\n logging.info(np.mean(function_values_reshaped))\n\n if logging_data is not None:\n iteration = logging_data['iteration']\n best_value = logging_data['best_value']\n iteration = logging_data['iteration']\n best_input = logging_data['best_input']\n best_core_hyperparameters = logging_data['best_core_hyperparameters']\n optimizer_state = blackbox_optimizer.get_state()\n\n if current_value_exact > best_value[0]:\n best_value[0] = current_value_exact\n best_input = current_input\n best_core_hyperparameters = core_hyperparameters\n\n # Writing logs.\n if iteration % config.log_frequency == 0:\n util.log_row(config.params_file, current_input)\n util.log_row(config.best_params_file, best_input)\n util.log_row(config.best_core_hyperparameters_file,\n best_core_hyperparameters)\n util.log_row(config.best_value_file, best_value)\n util.log_row(config.optimizer_internal_state_file, optimizer_state)\n util.log_row(config.current_values_list_file, [current_value_exact])\n util.log_row(config.best_values_list_file, [best_value[0]])\n util.log_row(config.fvalues_file, function_values_reshaped)\n util.log_row(config.iteration_file, [iteration])\n\n print('Current exact value estimate:')\n print(current_value_exact)\n sys.stdout.flush()\n\n new_current_input = blackbox_optimizer.run_step(perturbations_reshaped,\n function_values_reshaped,\n current_input,\n current_value_exact)\n config.controller.collect_rewards_and_train(rewards_for_controller,\n finished_dnas)\n\n evaluation_stats_reduced = [sum(x) for x in zip(*evaluation_stats)]\n blackbox_optimizer.update_state(evaluation_stats_reduced)\n\n return [True, new_current_input]","def train(network_def, target_params, optimizer, states, actions, next_states, rewards,\n terminals, loss_weights, cumulative_gamma, target_opt, mse_inf,tau,alpha,clip_value_min, rng):\n online_params = optimizer.target\n def loss_fn(params, rng_input, target, loss_multipliers):\n def q_online(state):\n return network_def.apply(params, state, rng=rng_input)\n\n q_values = jax.vmap(q_online)(states).q_values\n q_values = jnp.squeeze(q_values)\n replay_chosen_q = jax.vmap(lambda x, y: x[y])(q_values, actions)\n \n if mse_inf:\n loss = jax.vmap(mse_loss)(target, replay_chosen_q)\n else:\n loss = jax.vmap(dqn_agent.huber_loss)(target, replay_chosen_q)\n\n mean_loss = jnp.mean(loss_multipliers * loss)\n return mean_loss, loss\n\n rng, rng2, rng3, rng4 = jax.random.split(rng, 4)\n\n def q_target(state):\n return network_def.apply(target_params, state, rng=rng2)\n\n def q_target_online(state):\n return network_def.apply(online_params, state, rng=rng4)\n\n if target_opt == 0:\n target = dqn_agent.target_q(q_target, next_states, rewards, terminals, cumulative_gamma) \n elif target_opt == 1:\n #Double DQN\n target = target_DDQN(q_target_online, q_target, next_states, rewards, terminals, cumulative_gamma)\n\n elif target_opt == 2:\n #Munchausen\n target = target_m_dqn(q_target_online, q_target, states,next_states,actions,rewards,terminals,\n cumulative_gamma,tau,alpha,clip_value_min)\n else:\n print('error')\n\n grad_fn = jax.value_and_grad(loss_fn, has_aux=True)\n (mean_loss, loss), grad = grad_fn(online_params, rng3, target, loss_weights)\n optimizer = optimizer.apply_gradient(grad)\n return optimizer, loss, mean_loss","def sgd_optimize(self, train_set, test_set, n_epochs, learning_rate, batch_size):\n\n train_set_x, train_set_y, train_set_c = train_set\n assert train_set_x.shape == (60000, 784)\n assert train_set_y.shape == (60000,)\n assert train_set_c.shape == (60000, 10)\n\n test_set_x, test_set_y, test_set_c = test_set\n assert test_set_x.shape == (10000, 784)\n assert test_set_y.shape == (10000,)\n assert test_set_c.shape == (10000, 10)\n\n from toolbox import make_shared_data\n\n train_set_x = make_shared_data(train_set_x)\n train_set_c = make_shared_data(train_set_c)\n train_set_y = T.cast(make_shared_data(train_set_y), 'int32')\n\n test_set_x = make_shared_data(test_set_x)\n test_set_c = make_shared_data(test_set_c)\n test_set_y = T.cast(make_shared_data(test_set_y), 'int32')\n\n print '... building the model'\n\n index = T.lscalar()\n\n cost = self.MSE\n\n gparams = [T.grad(cost, param) for param in self.params]\n\n train_model = theano.function(\n inputs=[index],\n outputs=cost,\n updates=[\n (param, param - learning_rate * gparam)\n for param, gparam in zip(self.params, gparams)\n ],\n givens={\n self.input: train_set_x[index * batch_size: (index + 1) * batch_size],\n self.cost_vector: train_set_c[index * batch_size: (index + 1) * batch_size]\n },\n name='train_model'\n )\n\n in_sample_result = theano.function(\n inputs=[],\n outputs=[self.error, self.future_cost],\n givens={\n self.input: train_set_x,\n self.y: train_set_y,\n self.cost_vector: train_set_c\n },\n name='in_sample_result'\n )\n\n out_sample_result = theano.function(\n inputs=[],\n outputs=[self.error, self.future_cost],\n givens={\n self.input: test_set_x,\n self.y: test_set_y,\n self.cost_vector: test_set_c\n },\n name='out_sample_result'\n )\n\n n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size\n\n print '... training the model'\n\n best_Cout = np.inf\n corresponding_Eout = np.inf\n for epoch in xrange(n_epochs):\n print 'epoch #%d' % (epoch + 1)\n for batch_index in xrange(n_train_batches):\n batch_cost = train_model(batch_index)\n Ein, Cin = in_sample_result()\n Eout, Cout = out_sample_result()\n if Cout < best_Cout:\n best_Cout = Cout\n corresponding_Eout = Eout\n print ' better performance achieved ... best_Cout = %f' % best_Cout\n\n print 'after training %d epochs, best_Cout = %f, and corresponding_Eout = %f' \\\n % (n_epochs, best_Cout, corresponding_Eout)","def get_GP_optimum(obj):\n\n # Define space\n space = Design_space(obj.domain, obj.constraints)\n bounds = space.get_bounds()\n\n # Get function to optimize + gradients\n # Also mask by everything that is allowed by the constraints\n # fun = lambda d: fun_dfun(obj, space, d)[0]\n # f_df = lambda d: fun_dfun(obj, space, d)\n # def fun(d):\n # return fun_dfun(obj, space, d)[0]\n # Specify Optimizer --- L-BFGS\n optimizer = OptLbfgs(space.get_bounds(), maxiter=1000)\n\n # Do the optimisation\n x, _ = optimizer.optimize(\n x0=obj.x_opt,\n f=lambda d: fun_dfun(obj, space, d)[0],\n f_df=lambda d: fun_dfun(obj, space, d))\n # TODO: MULTIPLE RE-STARTS FROM PREVIOUS BEST POINTS\n\n # Round values if space is discrete\n xtest = space.round_optimum(x)[0]\n\n if space.indicator_constraints(xtest):\n opt = xtest\n else:\n # Rounding mixed things up, so need to look at neighbours\n\n # Compute neighbours to optimum\n idx_comb = np.array(\n list(itertools.product([-1, 0, 1], repeat=len(bounds))))\n opt_combs = idx_comb + xtest\n\n # Evaluate\n GP_evals = list()\n combs = list()\n for idx, d in enumerate(opt_combs):\n\n cons_check = space.indicator_constraints(d)[0][0]\n bounds_check = indicator_boundaries(bounds, d)[0][0]\n\n if cons_check * bounds_check == 1:\n pred = obj.model.predict(d)[0][0][0]\n GP_evals.append(pred)\n combs.append(d)\n else:\n pass\n\n idx_opt = np.where(GP_evals == np.min(GP_evals))[0][0]\n opt = combs[idx_opt]\n\n return opt","def do_optimisation(self):\n\n print('--> Parameters for optimisation:')\n print('--> Using measurements : {}'.format(self.stoma_cfg.comparison_helper.optimisation_keys))\n print('')\n\n x0 = self.initial_guess()\n\n tol, eps = 1e-4, 0.001\n\n print('--> Using SLSQP with tol={} and eps={}'.format(tol, eps))\n\n soln = opt.minimize(fun=self.optimise_fn,\n x0=x0,\n method='SLSQP',\n tol=tol,\n options={'eps': eps})\n\n print('*' * 120)\n print('--> Optimisation procedure has finished...')\n print(soln)\n print('*' * 120)\n\n if soln.success:\n print('--> Optimisation succeeded. Result is...')\n self._set_material_parameters(soln.x)\n print('--> {}'.format(self.material_model))\n else:\n print('--> The optimisation failed!')\n\n print('*' * 120)\n\n return soln","def compute_optimalReward(task):\n\n\tT = 15.0\n\tweights = 0\n\tif task == TABLE_TASK or task == COFFEE_TASK:\n\t\tweights = 1\n\telif task == LAPTOP_TASK:\n\t\tweights = 10\n\n\t# initialize start/goal based on task \n\tif task == COFFEE_TASK or task == HUMAN_TASK:\n\t\tpick = pick_shelf\n\telse:\n\t\tpick = pick_basic\n\n\tif task == LAPTOP_TASK:\n\t\tplace = place_higher\n\telse:\n\t\tplace = place_lower\n\t\t\n\tstartRad = np.array(pick)*(math.pi/180.0)\n\tgoalRad = np.array(place)*(math.pi/180.0)\n\tstart = startRad\n\tgoal = goalRad\n\n\tplan = Planner(task)\t\n\tfilename = None\n\tif task == 1:\n\t\tfilename = \"task1.csv\"\n\telif task == 2:\n\t\tfilename = \"task2.csv\"\n\telif task == 3:\n\t\tfilename = \"task3.csv\"\n\t\t\n\t# get optimal waypts from file\n\twaypts = get_opt_waypts(filename)\n\tr = plan.featurize(waypts)\n\tRvel = r[0]\n\tRfeat = np.sum(r[1])\n\n\tplan.kill_planner()\n\treturn (Rvel, Rfeat)","def objective(args: Namespace, trial: optuna.trial._trial.Trial) -> float:\n # Paramters (to tune)\n args.embedding_dim = trial.suggest_int(\"embedding_dim\", 128, 512)\n args.num_filters = trial.suggest_int(\"num_filters\", 128, 512)\n args.hidden_dim = trial.suggest_int(\"hidden_dim\", 128, 512)\n args.dropout_p = trial.suggest_uniform(\"dropout_p\", 0.3, 0.8)\n args.lr = trial.suggest_loguniform(\"lr\", 5e-5, 5e-4)\n\n # Train (can move some of these outside for efficiency)\n logger.info(f\"\\nTrial {trial.number}:\")\n logger.info(json.dumps(trial.params, indent=2))\n artifacts = run(args=args, trial=trial)\n\n # Set additional attributes\n args = artifacts[\"args\"]\n performance = artifacts[\"performance\"]\n logger.info(json.dumps(performance[\"overall\"], indent=2))\n trial.set_user_attr(\"threshold\", args.threshold)\n trial.set_user_attr(\"precision\", performance[\"overall\"][\"precision\"])\n trial.set_user_attr(\"recall\", performance[\"overall\"][\"recall\"])\n trial.set_user_attr(\"f1\", performance[\"overall\"][\"f1\"])\n\n return performance[\"overall\"][\"f1\"]","def _optfn(self, x):\n\n logger.debug(\" optfn(theta=%s)\", str(x))\n\n wmx = max(self.weights) * self.weighttrunc\n\n ip = []\n for i,w in enumerate(self.weights):\n if w < wmx:\n continue\n ip.append((i,w,x))\n\n if self.pool is None:\n itr = map(self.worker.loglik_grad, ip)\n else:\n itr = self.pool.imap_unordered(_pool_loglik_grad, ip, 10)\n\n if self._prior_shape is None:\n ll = 0.\n grad = np.zeros(len(x))\n else:\n ll = sum(sp.special.xlogy(self._prior_shape-1,x)-(x/self._prior_scale))\n grad = (self._prior_shape - 1)/x - 1/self._prior_scale\n\n for l,g in itr:\n ll += l\n grad += g\n\n logger.debug(\" optfn=%g\", ll)\n\n return -ll, -grad","def compute_optimal_policy(self):\n\n self.theta_history.append(self.theta)\n\n since = time()\n for it in range(self.n_itr):\n print(\"lr: {} | Iteration N: {} \\r\".format(self.lr, it), end=\"\")\n\n self.policy = GaussianPolicy(self.theta, self.sigma)\n\n # Simulate N trajectories\n paths = collect_episodes(\n self.sim, policy=self.policy, horizon=self.T, n_episodes=self.n_episodes)\n\n avg_return = self._compute_performance(paths=paths)\n self.avg_returns.append(avg_return)\n\n # Gradient update\n self.theta += self.update_rule(self.policy.grad_J(\n paths, self.discounts, n_ep=self.n_episodes, T=self.T), lr=self.lr)\n\n # History update\n self.theta_history.append(self.theta)\n\n # print(\"\\nTook {}s\".format(round(time() - since, 2)))\n print(\"lr: {} | Iteration N: {} | Took: {}s\".format(self.lr, self.n_itr, round(time() - since, 2)))","def objective(trial):\n %time\n env = gym.make('Delivery-v0')\n alpha = trial.suggest_discrete_uniform('alpha', 0.3,0.9,0.3)\n gamma = trial.suggest_discrete_uniform('gamma', 0.6, 1,0.1)\n epsilon = trial.suggest_discrete_uniform('epsilon', 0.01, 0.11, 0.04)\n episodes = 1000000\n \n # For plotting metrics\n all_epochs = []\n all_penalties = []\n rewards = []\n \n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \n \n for i in range(1, episodes+1):\n state = env.reset()\n episode_rewards = []\n\n epochs, penalties, reward, = 0, 0, 0\n done = False\n\n while not done:\n if random.uniform(0, 1) < epsilon:\n action = env.action_space.sample() # Explore action space randomly\n else:\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\n\n next_state, reward, done, info = env.step(action) \n\n old_value = q_table[state, action]\n next_max = np.max(q_table[next_state])\n\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\n q_table[state, action] = new_value\n\n if reward == -10:\n penalties += 1\n \n\n state = next_state\n episode_rewards.append(reward)\n epochs += 1\n \n if done == True:\n break \n if epochs == 1000:\n break \n rewards.append(np.sum(episode_rewards))\n \n last_reward = np.mean(rewards)\n # trial.report(-1 * last_reward)\n\n return -1 * last_reward","def _optimize(self, objective):\n # Initial value\n initial = self.get_initial()[0]\n\n if self.vector_to_matrix_transform is not None:\n initial = self.vector_to_matrix_transform(initial)\n\n if self.solver_type is 'NelderMead' or self.solver_type is 'ParticleSwarm':\n initial = None\n\n # Create tensorflow variable\n if self.matrix_manifold_dimension is None:\n x_tf = tf.Variable(tf.zeros(self.dimension, dtype=tf.float64))\n else:\n x_tf = tf.Variable(tf.zeros([self.matrix_manifold_dimension, self.matrix_manifold_dimension], dtype=tf.float64))\n\n # Cost function for pymanopt\n def objective_fct(x):\n if self.matrix_to_vector_transform_tf is not None:\n # Reshape x from matrix to vector form to compute the objective function (tensorflow format)\n x = self.matrix_to_vector_transform_tf(x, self.matrix_manifold_dimension)\n return objective(x)[0]\n\n # Transform the cost function to tensorflow function\n cost = tf.py_function(objective_fct, [x_tf], tf.float64)\n\n # Gradient function for pymanopt\n def objective_grad(x):\n if self.matrix_to_vector_transform is not None:\n # Reshape x from matrix to vector form to compute the gradient\n x = self.matrix_to_vector_transform(x)\n\n # Compute the gradient\n grad = np.array(objective(x)[1])[0]\n\n if self.vector_to_matrix_transform is not None:\n # Reshape the gradient in matrix form for the optimization on the manifold\n grad = self.vector_to_matrix_transform(grad)\n return grad\n\n # Define pymanopt problem\n problem = pyman.Problem(manifold=self.manifold, cost=cost, egrad=objective_grad, arg=x_tf, verbosity=2)\n\n # Optimize the parameters of the problem\n opt_x, opt_log = self.solver.solve(problem, x=initial)\n\n if self.matrix_to_vector_transform is not None:\n # Reshape the optimum from matrix to vector form\n opt_x = self.matrix_to_vector_transform(opt_x)\n\n # Format the result to fit with GPflowOpt\n result = sc_opt.OptimizeResult(x=opt_x, fun=opt_log['final_values']['f(x)'], nit=opt_log['final_values']['iterations'], message=opt_log['stoppingreason'], success=True)\n\n return result","def optimize(self):\n optimizer = tf.train.RMSPropOptimizer(self.config.learning_rate)\n return optimizer.minimize(self.cost)","def cross_validation(lambd_values = [0.1], maxfun_values = [200]):\n \n n_lambd, n_maxfun = len(lambd_values), len(maxfun_values)\n \n # Creation of the DataFrame where the results are to be stored\n df_results = pd.DataFrame(index = range(n_lambd * n_maxfun))\n df_results['Maxfun'], df_results['Lambd'] = list(maxfun_values) * n_lambd, list(lambd_values) * n_maxfun\n df_results['Hidden layers'] = num_of_hidden_layers\n nodes_avg = np.mean(layers[1:-1])\n df_results['Nodes per hidden layer (avg)'] = nodes_avg\n accuracy_col = []\n \n for lambd in lambd_values:\n \n for maxfun in maxfun_values:\n \n start = time() # start of the timer\n \n res = opt.fmin_l_bfgs_b(costFunction, nn_weights, fprime = backwards, args = (layers, images_validation, labels_training, num_labels, lambd), maxfun = maxfun, factr = 1., disp = True)\n Theta = roll_params(res[0], layers)\n \n # input('\\nProgram paused. Press enter to continue!!!')\n \n # print(\"\\nTesting Neural Network... \\n\")\n \n pred = predict(Theta, images_test)\n end = time() # end of the timer\n accuracy = np.mean(labels_test == pred) * 100\n print('\\nLambda =', lambd)\n print('Maxfun =', maxfun)\n time_complexity = end - start\n print('Time:', time_complexity, 'seconds')\n print('Accuracy =', accuracy, '%')\n \n # Modification of the 'Accuracy' column\n accuracy_col.append(accuracy)\n \n # Accuracy values stored into the dataframe\n df_results['Accuracy'] = accuracy_col\n \n return df_results","def solve(self):\n max_iter = 1000\n iter_count = 0\n yhat = self.predict()\n loss = self.cross_entropy(yhat)\n gradloss = self.cross_entropy_gradient(yhat)\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\n alpha = 1.0\n slope = la.norm(gradloss)**2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n while loss_new < loss + 1e-4 * alpha * slope:\n alpha = alpha / 2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n self.beta = beta_new\n loss = loss_new\n gradloss = self.cross_entropy_gradient(yhat)\n iter_count += 1","def hyperparameter_tunning(self, pipeline, max_evals):\n space = self.create_space(pipeline)\n\n trials = Trials()\n best = fmin(\n self.objective,\n space,\n algo=tpe.suggest,\n max_evals=max_evals,\n catch_eval_exceptions=True,\n trials=trials)\n\n best = hyperopt.space_eval(space, best)\n return best","def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\n K=10):\n\n # Sampling of indices is done for you. Do not modify this if you\n # wish to match the autograder and receive points!\n indices = [target]\n indices.extend(getNegativeSamples(target, dataset, K))\n\n ### YOUR CODE HERE\n #The cost now is maximize the predicted and target pair,\n #minimizing the predicted and the sampled pairs\n cost = 0\n gradPred = np.zeros(predicted.shape[0])\n grad = np.zeros(outputVectors.shape)\n\n for indice in indices:\n target_vector = outputVectors[indice]\n vector_product = np.dot(target_vector,predicted)\n if indice != target:\n cost += -np.log(sigmoid(-vector_product))\n gradPred += sigmoid(vector_product)*target_vector\n # use += in case of repeatance\n grad[indice,:] += sigmoid(vector_product)*predicted\n else:\n cost += -np.log(sigmoid(vector_product))\n gradPred += (sigmoid(vector_product) - 1)*target_vector\n grad[indice,:] += (sigmoid(vector_product)-1)*predicted\n ### END YOUR CODE\n #print indices\n\n return cost, gradPred, grad","def optimize_model(optimizer, policy_net, target_net, memory_batch):\n state_batch, action_batch, reward_batch, next_state_batch, done_batch = memory_batch\n state_batch =state_batch.to(device, torch.float32)\n action_batch = action_batch.to(device, torch.int64).view(-1,1)\n reward_batch = reward_batch.to(device, torch.float32)\n next_state_batch = next_state_batch.to(device, torch.float32)\n done_batch = done_batch.to(device, torch.float32)\n\n # Compute Q(s_t, a) - the model computes Q(s_t), then we select the\n # columns of actions taken\n state_action_values = policy_net(state_batch).gather(1, action_batch)\n\n # Compute V(s_{t+1}) for all next states.\n with torch.no_grad():\n next_state_action_values = target_net(next_state_batch)\n next_state_values = next_state_action_values.max(1)[0]\n next_state_values = next_state_values * (1 - done_batch) # no reward if this episode is done.\n # Compute the expected Q values\n expected_state_action_values = (next_state_values * gamma) + reward_batch\n expected_state_action_values = expected_state_action_values.unsqueeze(1)\n\n # Compute Huber loss\n assert expected_state_action_values.requires_grad == False\n assert state_action_values.requires_grad == True\n loss = F.smooth_l1_loss(state_action_values, expected_state_action_values)\n\n # Optimize the model\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n return loss","def train(self, iterations: int):\n\n s = \"{:3d} reward {:6.2f}/{:6.2f}/{:6.2f} len {:6.2f} epsilon {:1.3f} {}\"\n s_check = \"{:3d} reward {:6.2f}/{:6.2f}/{:6.2f} len {:6.2f} epsilon {:1.3f} saved {} \"\n total_steps = 0\n iter_metrics = []\n for n in range(iterations):\n r_min, r_mean, r_max, iter_steps = self.train_iter()\n iter_metrics.append((r_min, r_mean, r_max))\n total_steps += iter_steps\n\n if n == int(iterations / 2):\n self.steps_to_update_target_model = int(self.steps_to_update_target_model / 2)\n\n # checkpointing & logging\n s_print = s\n file_name = \"\"\n if n % self.checkpoint_freq == 0:\n file_name = f'my_dqn_{n}.pth'\n torch.save(self.target_dqn.state_dict(), os.path.join(self.checkpoint_path, file_name))\n s_print = s_check\n\n if self.verbose:\n print(s_print.format(\n n + 1,\n r_min,\n r_mean,\n r_max,\n total_steps,\n self.e_greedy,\n file_name\n ))\n iter_min = np.mean([x[0] for x in iter_metrics])\n iter_mean = np.mean([x[1] for x in iter_metrics])\n iter_max = np.mean([x[2] for x in iter_metrics])\n return iter_min, iter_mean, iter_max","def GradientDescent(x, y, theta, alpha, tolerate, maxiterate, epsilon):\n i = 0 # set the iteration counting index\n tolerate_rule = 1 # set the initial tolerate rate\n n = x.shape[0]\n current_theta = theta\n scost_vector = np.empty([0, 1])\n lcost_vector = np.empty([0, 1])\n hcost_vector = np.empty([0, 1])\n\n # iterate\n while tolerate_rule >= tolerate and i <= maxiterate:\n sl = np.array(SquareLoss(x, y, current_theta)).reshape([1, 1])\n scost_vector = np.append(scost_vector, sl, axis=0) # store cost\n abs = np.array(AbsoluteLoss(x, y, current_theta)).reshape([1, 1])\n lcost_vector = np.append(lcost_vector, abs, axis=0) # store cost\n hbs = np.array(HuberLoss(x, y, current_theta, epsilon)).reshape([1, 1])\n hcost_vector = np.append(hcost_vector, hbs, axis=0) # store cost\n fx = x @ current_theta\n update_theta = current_theta - alpha * (1/n) * x.transpose() @ (fx - y)\n tolerate_rule = np.minimum(np.abs(update_theta - current_theta))\n i += 1\n current_theta = update_theta\n\n cost_matrix = np.asmatrix(np.stack((scost_vector, lcost_vector,\n hcost_vector),\n axis=-1))\n cost_dataframe = pd.DataFrame(cost_matrix, columns=['AbsoluteLoss',\n 'SquareLoss',\n 'HuberLoss'])\n return(current_theta, cost_dataframe)","def adaptive_step(self):\n\n s = self\n \n # adaptive line search parameters\n down_adjustment_frequency = 1\n up_adjustment_frequency = 50\n alpha=0.3 # acceptable fraction of predicted decrease\n beta=0.8 # how much to shrink when violation\n gamma=1.05 # how much to grow when too conservative\n report_frequency = 1\n \n\n s.model.advance_batch()\n s.update_stats() # update cov matrices and svds\n\n s.grad.update() # gradient (ptodo, already updated in stats)\n s.grad2.update() # gradient from synth labels (don't need?)\n s.grad_new.update() # corrected gradient\n\n # TODO: decide on s vs s.\n s.run(s.param_save_op) # TODO: insert lr somewhere\n lr0, loss0 = s.run(s.lr, s.model.loss)\n\n s.run(s.param_update_op)\n loss1 = s.run(s.model.loss)\n \n target_slope = -s.run(s.grad_dot_grad_new_op)\n target_delta = lr0*target_slope\n actual_delta = loss1 - loss0\n actual_slope = actual_delta/lr0\n slope_ratio = actual_slope/target_slope # between 0 and 1.01\n \n s.record('loss', loss0)\n s.record('step_length', lr0)\n s.record('grad_norm', s.run(s.grad_norm_op))\n s.record('grad_new_norm', s.run(s.grad_new_norm_op))\n s.record('target_delta', target_delta)\n\n if step_rejection and actual_delta > 0:\n print('Observed increase in loss %.2f, rejecting step'%(actual_delta,))\n s.run(s.param_restore_op)\n\n if s.step_counter % report_frequency == 0:\n print('NStep %d loss %.2f, target decrease %.3f, actual decrease, %.3f ratio %.2f'%(self.step_counter, loss0, target_delta, actual_delta, slope_ratio))\n\n if (adaptive_step and s.step_counter % down_adjustment_frequency == 0 and\n slope_ratio < alpha and abs(target_delta)>eps):\n print('%.2f %.2f %.2f'%(loss0, loss1, slope_ratio))\n print('Slope optimality %.2f, shrinking learning rate to %.2f'%(slope_ratio, lr0*beta,))\n s.lr.set(lr0*beta)\n elif (adaptive_step and s.step_counter % up_adjustment_frequency == 0 and\n slope_ratio>0.90):\n print('%.2f %.2f %.2f'%(loss0, loss1, slope_ratio))\n print('Growing learning rate to %.2f'%(lr0*gamma))\n s.lr.set(lr0*gamma)\n \n s.step_counter+=1","def add_grad_updates(self):\n \n gradients = T.grad(self.cost, self.theta)\n \n for target_param, grad in zip(self.theta, gradients):\n \n if target_param.name ==\"W\" and self.num_hidden ==0\\\n and self.zero_diag:\n \n grad = grad - T.diag(T.diag(grad)) # no x i - xi connections\n # for all i = 1, ..., D\n ##############################################################\n if target_param.name ==\"b\" and self.learn_biases == False:\n print(\"Will not learn bias terms\")\n pass\n \n elif target_param.name ==\"bhid\" and self.learn_biases == False:\n print(\"Will not learn bias terms\")\n pass\n \n else:\n \n if self.use_momentum:\n \n # alternative definition (mostly seen):\n #g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\n #T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\n #self.updates[target_param] = target_param + g_tilda\n \n g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\n (1-self.momentum)*grad\n \n self.updates[target_param] = target_param +\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*g_tilda\n \n # store g_tilda for next iteration:\n self.updates[self.grad_vec[target_param.name]] = g_tilda\n \n else:\n \n self.updates[target_param] = target_param -\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\n \n if (\"PCD\" in self.algorithm) and self.num_hidden > 0:\n \n self.updates[self.persistent_gibbs] = self.hid_samples","def optimize(self): \n if self.model == 'ARD':\n estimate = minimize(\n fun=optim_func,\n x0=np.array([self.alpha, self.beta]),\n args=(self,),\n method='L-BFGS-B',\n bounds=((0, 50), (0, 50)),\n )\n # logger.info(estimate)\n\n # organize into a dict\n result = {\n \"alpha\": estimate.x[0],\n \"beta\": estimate.x[1],\n \"Lik\": estimate.fun,\n \"negLogLik\": -np.log(-estimate.fun),\n \"convergence\": estimate.success,\n }\n logger.debug(result)\n\n elif self.model == 'ER':\n estimate = minimize(\n fun=optim_func,\n x0=np.array([self.alpha]),\n args=(self,),\n method='L-BFGS-B',\n bounds=[(0, 50)],\n )\n\n result = {\n \"alpha\": estimate.x[0],\n \"Lik\": estimate.fun, \n \"negLogLik\": -np.log(-estimate.fun),\n \"convergence\": estimate.success,\n }\n logger.debug(result)\n\n else:\n raise Exception('model must be specified as either ARD or ER')\n\n # get scaled likelihood values\n self.log_lik = result[\"negLogLik\"]\n self.tree = self.tree.set_node_values(\n 'likelihood',\n values={\n node.idx: np.array(node.likelihood) / sum(node.likelihood)\n for node in self.tree.idx_dict.values()\n }\n )","def least_squares_SGD(y, tx, initial_w, max_iters, gamma, debug = False):\n losses, ws = stochastic_gradient_descent(y, tx, initial_w, 1, max_iters, gamma, loss_f = model_linear.compute_loss, grad_f = model_linear.compute_gradient, debug = debug)\n return get_last_ans(ws, losses)","def Optimise(LogLikelihood,par,func_args,fixed=None,type='max',method='NM',maxiter=10000, maxfun=10000, verbose=True):\n \n if fixed==None:\n var_par = np.copy(par)\n #otherwise construct the parameter vector from var_par and fixed_par_val\n else:\n par = np.array(par)\n fixed = np.array(fixed) #ensure fixed is a np array\n #assign parameters to normal param vector\n fixed_par = par[np.where(fixed==True)]\n var_par = par[np.where(fixed!=True)]\n \n #set the algorithm to use - CG and P not working (at least not well)\n add_kwords = {'verbose':verbose}\n if method == 'NM':\n Algorithm = NelderMead\n add_kwords = {'maxiter':maxiter, 'maxfun':maxfun,'verbose':verbose}\n elif method == 'CG':\n print \"warning: CG method didn't work properly during testing\"\n Algorithm = ConjugateGradient\n elif method == 'P':\n print \"warning: Powell algorithm didn't work properly during testing\"\n Algorithm = Powell\n else:\n print \"error: optimisation function not found\"\n return par\n \n #set the optimisation function to pos or neg for the fmin funcitons\n if type == 'max': OptFunc = NegFixedPar_func\n elif type == 'min': OptFunc = FixedPar_func\n else:\n print \"error: %s not a valid option\" % type\n return par\n \n #call the optimser with the appropriate function\n fitted_par = Algorithm(OptFunc, var_par, (LogLikelihood,func_args,fixed,fixed_par), \\\n **add_kwords)\n \n #now return the params in the correct order...\n if fixed==None:\n return_par = fitted_par\n else:\n return_par = np.copy(par) \n return_par[np.where(fixed!=True)] = fitted_par\n \n return return_par","def target_fit_test(fitnesses, smoothing=3):\n global obj_func, pop_size\n\n results_pso = []\n results_de = []\n for fitness in fitnesses:\n print \"Fitness: \", fitness\n\n result_pso = 0\n result_de = 0\n\n stopping_criterion = problem.StoppingCriterion('target_fitness', fitness)\n\n for i in xrange(smoothing):\n result_pso += solver.minimize(obj_func, method='pso',\n stopping_criterion=stopping_criterion,\n population_size=pop_size, params=pso_params)\n\n result_de += solver.minimize(obj_func, method='de',\n stopping_criterion=stopping_criterion,\n population_size=pop_size)\n\n print \"Calculated de\"\n\n result_pso /= float(smoothing)\n result_de /= float(smoothing)\n\n results_pso.append(result_pso)\n results_de.append(result_de)\n\n plt.plot(fitnesses, results_pso, 'bo-', label='pso')\n plt.plot(fitnesses, results_de, 'r^-', label='de')\n plt.gca().invert_xaxis()\n plt.legend()\n plt.title('Comparison of pso and de methods using a target fitness')\n plt.xlabel('Target fitness')\n plt.ylabel('Iterations required to acheive that fitness')\n plt.show()","def get_winners(self):\n\n if self.optimal is not None:\n return self.optimal\n clean_proposals = self.cleaner.create_scenarios(self.proposals)\n self.optimal = self.optimizer.optimize(clean_proposals)\n return self.optimal","def gradient_step(self):\n n = 3 #Granularity of line search\n grad = self.gradient()\n #grad = grad/np.linalg.norm(grad, 2)\n W = project(self.W[-1] + grad)\n A = np.linspace(0., 1., n+2)[1:-1]\n Objective = map(self, [(1. - a)*self.W[-1] + a*W for a in A])\n a = A[np.argmax(Objective)]\n W = (1. - a)*self.W[-1] + a*W\n obj = np.max(Objective)\n self.objective.append(obj)\n self.W.append(W)\n self.iterations += 1","def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\n\n ### YOUR CODE HERE\n y_hat = softmax(np.dot(outputVectors,predicted))\n y = np.zeros(outputVectors.shape[0])\n y[target] = 1.0\n\n cost = -np.log(y_hat[target])\n gradPred = np.dot(outputVectors.T,y_hat - y)\n grad = np.outer(y_hat - y,predicted)\n ### END YOUR CODE\n\n return cost, gradPred, grad","def optimize(opt, target, n_agents, n_variables, n_iterations, lb, ub, hyperparams):\n\n # Creating the SearchSpace\n space = SearchSpace(n_agents=n_agents, n_variables=n_variables,\n n_iterations=n_iterations, lower_bound=lb, upper_bound=ub)\n\n # Creating the Function\n function = Function(pointer=target)\n\n # Creating Optimizer\n if opt.__name__ is not 'BH':\n optimizer = opt(hyperparams=hyperparams)\n else:\n optimizer = opt()\n\n # Creating the optimization task\n task = Opytimizer(space=space, optimizer=optimizer, function=function)\n\n return task.start(store_best_only=True)","def fit_GD(self, X, y, eta=None,\n eps=0, tmax=10000, verbose=False) :\n if self.lambda_ != 0 :\n raise Exception(\"GD with regularization not implemented\")\n\n if verbose :\n plt.subplot(1, 2, 2)\n plt.xlabel('iteration')\n plt.ylabel(r'$J(\\theta)$')\n plt.ion()\n plt.show()\n\n X = self.generate_polynomial_features(X) # map features\n n,d = X.shape\n eta_input = eta\n self.coef_ = np.zeros(d) # coefficients\n err_list = np.zeros((tmax,1)) # errors per iteration, the value of error on each iteration\n\n\n\n # GD loop\n for t in xrange(tmax) :\n ### ========== TODO : START ========== ###\n # part f: update step size\n # change the default eta in the function signature to 'eta=None'\n # and update the line below to your learning rate function\n #print (\"this eta line was exectued\")\n eta = 1/float(1+t)\n #print eta\n #eta = eta_input\n #print (\"eta value is %f, and t = %d\") % (eta,t)\n\n\n\n\n ### ========== TODO : END ========== ###\n\n ### ========== TODO : START ========== ###\n # part d: update theta (self.coef_) using one step of GD\n # hint: you can write simultaneously update all theta using vector math\n\n # track error\n # hint: you cannot use self.predict(...) to make the predictions\n # IMPORTANT: The reason you can not use predict or cost is because they operat\n # delta_J = X_T*X*Theta - X_T*y\n\n #updated\n y_pred_vector = np.dot(X, self.coef_)\n delta_J = np.dot(X.transpose(),np.dot(X,self.coef_)) - np.dot(X.transpose(),y)\n\n\n #cost = np.dot((y - y_pred_vector).transpose(), (y - y_pred_vector)) # write in the matrix form\n\n #updated\n #self.coef_ = self.coef_ - eta*delta_J\n #update the coeffient here\n #for x in X, y in y: #returns row\n for index, x in enumerate(X):\n #get prediction\n #w.T*X\n y_true = y[index]\n pred = np.dot(x, self.coef_)\n #make sure that the values are compatible\n self.coef_ = self.coef_ - 2*eta *(pred - y_true)*x\n\n\n y_pred = np.dot(X, self.coef_) # change this line\n err_list[t] = np.sum(np.power(y - y_pred, 2)) / float(n)\n ### ========== TODO : END ========== ###\n\n # stop?\n if t > 0 and abs(err_list[t] - err_list[t-1]) <= eps :\n break\n\n # debugging\n if verbose :\n x = np.reshape(X[:,1], (n,1))\n cost = self.cost(x,y)\n plt.subplot(1, 2, 1)\n plt.cla()\n plot_data(x, y)\n self.plot_regression()\n plt.subplot(1, 2, 2)\n plt.plot([t+1], [cost], 'bo')\n plt.suptitle('iteration: %d, cost: %f' % (t+1, cost))\n plt.draw()\n plt.pause(0.05) # pause for 0.05 sec\n\n print 'number of iterations: %d' % (t+1)\n\n return self, t","def optimize(self, maxiter):\n for iteration in range(maxiter):\n self.sortParticles()\n self.phi = int(phiMin + iteration *((phiMax - phiMin) / float(maxiter)))\n self.cluster()\n #self.ConnectClusters()\n for i in range(self.n_particles):\n x = self.particles_pos[i]\n v = self.velocities[i]\n p_best = self.p_best[i]\n self.velocities[i] = self.update_velocity(x, v, p_best , self.g_best , self.getLbestOfCluster(self.getClusterOfParticle(i)) , i)\n self.particles_pos[i] = self.update_position(x, v)\n # Update the best position for particle i\n if self.func(self.particles_pos[i]) < self.func(p_best):\n self.p_best[i] = self.particles_pos[i]\n # Update the best position overall\n if self.func(self.particles_pos[i]) < self.func(self.g_best):\n \n self.g_best = self.particles_pos[i]\n return self.g_best, self.func(self.g_best)","def optimize(self):\n\t\ts1,a1,r1,s2 = self.ram.agg_sample(self.batch_size)\n\n\t\ts1 = Variable(torch.from_numpy(s1))\n\t\ta1 = Variable(torch.from_numpy(a1))\n\t\tr1 = Variable(torch.from_numpy(r1))\n\t\ts2 = Variable(torch.from_numpy(s2))\n\n\t\tfor i in range(self.critic_step):\n\t\t\t# ---------------------- optimize critic ----------------------\n\t\t\t# Use target actor exploitation policy here for loss evaluation\n\t\t\t\n\t\t\t# a2 = self.target_actor.forward(s2).detach()\n\t\t\t# next_val = torch.squeeze(self.target_critic.forward(s2, a2).detach())\n\t\t\t\n\t\t\t# y_exp = r + gamma*Q'( s2, pi'(s2))\n\t\t\ty_expected = r1 #+ GAMMA*next_val\n\t\t\t# y_pred = Q( s1, a1)\n\t\t\ty_predicted = torch.squeeze(self.critic.forward(s1, a1))\n\t\t\t# compute critic loss, and update the critic\n\t\t\t#print(y_predicted,y_expected,\"hi\")\n\t\t\tloss_critic = F.smooth_l1_loss(y_predicted, y_expected.squeeze())\n\t\t\tself.critic_optimizer.zero_grad()\n\t\t\tloss_critic.backward()\n\t\t\tself.critic_optimizer.step()\n\n\t\t# ---------------------- optimize actor ----------------------\n\t\tpred_a1 = self.actor.forward(s1)\n\t\tloss_actor = -1*torch.sum(self.critic.forward(s1, pred_a1))\n\t\tself.actor_optimizer.zero_grad()\n\t\tloss_actor.backward()\n\t\tself.actor_optimizer.step()\n\n\t\tutils.soft_update(self.target_actor, self.actor, TAU)\n\t\tutils.soft_update(self.target_critic, self.critic, TAU)\n\n\t\t# if self.iter % 100 == 0:\n\t\tif self.batch_size > 1:\n\t\t\ty_1 = y_predicted.data.numpy()[0]\n\t\t\tr_1 = r1.data.numpy()[0]\n\t\telse:\n\t\t\ty_1 = y_predicted.data.numpy()\n\t\t\tr_1 = r1.data.numpy()\n\t\tprint ('Iteration :- ', self.iter, ' Loss_actor :- ', loss_actor.data.numpy(),\\\n\t\t\t' Loss_critic :- ', loss_critic.data.numpy(), ' Critic Pred Reward :- ', y_1, ' Actual Reward :- ', r_1)\n\t\tself.iter += 1","def fast_grad(beta_init, theta_init, lambdat, t_init, maxiter, X, y):\n beta = beta_init\n theta = theta_init\n grad = compute_grad(theta, lambdat=lambdat, X=X, y=y)\n beta_vals = beta\n iter = 0\n obj_vals = []\n while iter < maxiter:\n t = backtracking(theta, lambdat=lambdat, t=t_init, X=X, y=y)\n beta_new = theta - t*grad\n theta = beta_new + iter/(iter+3)*(beta_new-beta)\n beta_vals = np.vstack((beta_vals, beta_new))\n obj_vals.append(objective(beta_new,lambdat,X=X,y=y))\n grad = compute_grad(theta, lambdat=lambdat, X=X, y=y)\n beta = beta_new\n iter += 1\n return beta_vals, obj_vals","def AdaGrad(score_list, closure, batch_size, D, labels,\n max_epoch=100, init_step_size=None, linesearch_option=0, \n adaptive_termination=0, threshold_at=0.5,\n c=0.5, beta=0.7,\n x0=None, verbose=True, D_test=None, labels_test=None):\n n = D.shape[0]\n d = D.shape[1]\n \n m = int(n/batch_size)\n\n if x0 is None:\n x = np.zeros(d)\n x0 = np.zeros(d)\n elif isinstance(x0, np.ndarray) and x0.shape == (d,):\n x = x0.copy()\n else:\n raise ValueError('x0 must be a numpy array of size (d, )')\n\n num_grad_evals = 0\n Gk2 = 0\n \n if linesearch_option in [0]:\n step_size = init_step_size\n if linesearch_option in [1]:\n step_size = init_step_size / 2**(batch_size/n) \n \n condition_checked = False\n \n if adaptive_termination == 1:\n Gk2_list = np.zeros(max_epoch * m)\n iteration_counter = 0\n warmup_time = int(n / (batch_size))\n ratio_max = 0\n print(threshold_at, warmup_time)\n\n \n\n for k in range(max_epoch): \n # if num_grad_evals >= 2 * n * max_epoch:\n # # exceeds the number of standard SVRG gradient evaluations (only for batch-size = 1)\n # print('End of budget for gradient evaluations')\n # break\n t_start = time.time()\n\n\n\n loss, full_grad = closure(x, D, labels)\n \n if verbose:\n output = 'Epoch.: %d, Grad. norm: %.2e' % \\\n (k, np.linalg.norm(full_grad))\n output += ', Func. value: %e' % loss\n output += ', Step size: %e' % step_size\n output += ', Num gradient evaluations/n: %f' % (num_grad_evals / n) \n print(output) \n\n \n\n score_dict = {\"epoch\": k}\n score_dict[\"optimizer\"] = 0\n score_dict[\"n_grad_evals\"] = num_grad_evals\n score_dict[\"n_grad_evals_normalized\"] = num_grad_evals / n\n score_dict[\"train_loss\"] = loss\n score_dict[\"grad_norm\"] = np.linalg.norm(full_grad)\n score_dict[\"train_accuracy\"] = accuracy(x, D, labels)\n score_dict[\"train_loss_log\"] = np.log(loss)\n score_dict[\"grad_norm_log\"] = np.log(score_dict[\"grad_norm\"])\n # score_dict[\"train_accuracy_log\"] = np.log(score_dict[\"train_accuracy\"])\n if D_test is not None:\n test_loss = closure(x, D_test, labels_test, backwards=False)\n score_dict[\"test_loss\"] = test_loss\n score_dict[\"test_accuracy\"] = accuracy(x, D_test, labels_test)\n score_dict[\"test_loss_log\"] = np.log(test_loss)\n # score_dict[\"test_accuracy_log\"] = np.log(score_dict[\"test_accuracy\"])\n\n score_list += [score_dict]\n \n if np.linalg.norm(full_grad) <= 1e-10:\n break\n if np.linalg.norm(full_grad) >= 1e10:\n break\n if np.isnan(full_grad).any():\n break\n \n # Create Minibatches:\n minibatches = make_minibatches(n, m, batch_size)\n for i in range(m):\n # get the minibatch for this iteration\n indices = minibatches[i]\n Di, labels_i = D[indices, :], labels[indices]\n\n # compute the loss, gradients\n loss, x_grad = closure(x, Di, labels_i) \n gk = x_grad\n num_grad_evals = num_grad_evals + batch_size\n \n Gk2 = Gk2 + (np.linalg.norm(gk) ** 2)\n \n if linesearch_option == 0:\n step_size = init_step_size\n\n \n elif linesearch_option == 1:\n step_size, armijo_iter = armijo_ls(closure, Di, labels_i, x, loss,\n x_grad, x_grad, 2**(batch_size/n) * step_size, c=c, beta=beta,\n precond = 1)\n num_grad_evals += batch_size * armijo_iter\n \n if \"armijo_iter\" in score_list[len(score_list) - 1].keys(): \n score_list[len(score_list) - 1][\"armijo_iter\"] += armijo_iter\n else:\n score_list[len(score_list) - 1][\"armijo_iter\"] = armijo_iter\n \n if adaptive_termination == 1: \n if iteration_counter >= warmup_time:\n Gk2_list[iteration_counter] = Gk2\n if iteration_counter % 2 == 0: \n if iteration_counter/2 >= warmup_time:\n Gk2_last = Gk2_list[int(iteration_counter/2)] \n ratio = (Gk2 - Gk2_last) / Gk2_last\n #print(ratio)\n if ratio > ratio_max:\n ratio_max = ratio\n if ratio > threshold_at:\n x -= (step_size / np.sqrt(Gk2)) * gk\n print('Breaking out of inner loop at iteration', iteration_counter)\n condition_checked = True\n break\n iteration_counter += 1\n \n \n \n x -= (step_size / np.sqrt(Gk2)) * gk\n \n \n\n \n \n t_end = time.time()\n time_epoch = t_end - t_start\n score_list[len(score_list) - 1][\"time\"] = time_epoch \n if condition_checked:\n break\n \n return score_list, x, num_grad_evals, k","def optimize_agent(self, itr, samples=None, sampler_itr=None, offline_samples=None):\n itr = itr if sampler_itr is None else sampler_itr # Async uses sampler_itr.=\n if samples is not None:\n if self.save_data:\n self.data_writer.write(samples)\n samples_to_buffer = self.samples_to_buffer(samples)\n self.replay_buffer.append_samples(samples_to_buffer)\n opt_info = ModelOptInfo(*([] for _ in range(len(ModelOptInfo._fields))))\n if not self.offline and itr < self.min_itr_learn:\n return opt_info\n for _ in range(1 if self.offline else self.updates_per_optimize):\n start = time.time()\n samples_from_replay = self.sample_batch()\n\n end = time.time()\n sample_time = end - start\n\n forward_time = time.time()\n rl_loss, td_abs_errors, goal_loss,\\\n t0_spr_loss, model_spr_loss, \\\n diversity, inverse_model_loss, bc_loss, \\\n goal_abs_errors \\\n = self.loss(samples_from_replay, self.offline)\n forward_time = time.time() - forward_time\n\n total_loss = self.rl_weight * rl_loss\n total_loss += self.spr_weight * model_spr_loss\n total_loss += self.goal_weight * goal_loss\n total_loss += self.inverse_model_weight * inverse_model_loss\n total_loss += self.bc_weight * bc_loss\n\n self.optimizer.zero_grad()\n total_loss.backward()\n stem_params, model_params = self.model.split_stem_model_params()\n if self.clip_grad_norm > 0:\n grad_norm = torch.nn.utils.clip_grad_norm_(stem_params,\n self.clip_grad_norm)\n else:\n grad_norm = 0\n if self.clip_model_grad_norm > 0:\n model_grad_norm = torch.nn.utils.clip_grad_norm_(model_params,\n self.clip_model_grad_norm)\n else:\n model_grad_norm = 0\n\n cnn_weight_norm = find_weight_norm(self.model.conv.parameters())\n\n self.optimizer.step()\n\n if not self.offline and self.prioritized_replay:\n self.replay_buffer.update_batch_priorities(td_abs_errors)\n opt_info.loss.append(rl_loss.item())\n opt_info.gradNorm.append(torch.tensor(grad_norm).item()) # grad_norm is a float sometimes, so wrap in tensor\n opt_info.GoalLoss.append(goal_loss.item())\n opt_info.modelGradNorm.append(torch.tensor(model_grad_norm).item())\n opt_info.T0SPRLoss.append(t0_spr_loss.item())\n opt_info.InverseModelLoss.append(inverse_model_loss.item())\n opt_info.BCLoss.append(bc_loss.item())\n opt_info.CNNWeightNorm.append(cnn_weight_norm.item())\n opt_info.SampleTime.append(sample_time)\n opt_info.ForwardTime.append(forward_time)\n opt_info.Diversity.append(diversity.item())\n opt_info.ModelSPRLoss.append(model_spr_loss.item())\n opt_info.tdAbsErr.extend(td_abs_errors[::8].cpu().numpy()) # Downsample.\n opt_info.GoalError.extend(goal_abs_errors[::8].cpu().numpy()) # Downsample.\n self.update_counter += 1\n if self.update_counter % self.target_update_interval == 0:\n self.agent.update_target(self.target_update_tau)\n self.update_itr_hyperparams(itr)\n return opt_info","def fit(self, ymeas, mmeas=None, alg='optls'): # alg: {'optls','mine'}\n\n # [ X ]*dm = [ dy ]\n # [ a ] [ 0 ] <-- using built-in Ridge model does this\n #\n # [ X ]*dm = [ dy ]\n # [-a ] [ a*m ] <-- but I want this for iterated nonlin problem\n #\n # [ X ]*dm = [ dy ]\n # [-aL ] [ a*L*m ] <-- and more generally I want this (higher-order Tihk)\n #\n # which can be rewritten:\n # G * dm = D (and then loop that from m0 with m=m+dm...)\n\n # X is the Jacobian matrix of derivs of predicted data points wrt model\n # params m, as given by ypred,X=self.fwd_deriv_code(m)...\n\n\n if alg=='optls':\n # https://docs.scipy.org/doc/scipy/reference/optimize.html\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.least_squares.html\n def fun(m):\n mlen = m.size\n L = create_findiff_mtx(mlen,self.beta)\n ypred,J = self.fwd_deriv_code(m) # m: model params vector, J: derivs matrix\n resids = ymeas-ypred\n modelfunc = self.alpha * np.dot(L,m)\n modelfunc = modelfunc.reshape(len(modelfunc),1)\n f = np.squeeze(np.concatenate((resids,modelfunc),axis=0))\n return f\n\n def jac(m):\n mlen = m.size\n L = create_findiff_mtx(mlen,self.beta)\n ypred,J = self.fwd_deriv_code(m) # m: model params vector, J: derivs matrix\n Jreg = self.alpha * L\n Jout = np.concatenate((J,Jreg))\n return Jout\n\n if self.usefindiff:\n jacfn='2-point'\n else:\n jacfn=jac\n if self.verbose:\n verblevel=2\n else:\n verblevel=0\n res = least_squares(fun, np.squeeze(self.minit), jac=jacfn,\n bounds=(0., 3.5), diff_step=None, verbose=verblevel, max_nfev=self.max_nfev,\n method='trf', ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0)\n #ftol=1e-4, xtol=1e-1, gtol=1e-8, x_scale=1.0)\n #ftol=1e0, xtol=1e-01, gtol=1e-01, x_scale=1.0)\n #ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0)\n\n if mmeas is not None:\n testMSE = cplxMSE(res.x.reshape(len(res.x),1),mmeas)\n else:\n testMSE = npl.nan\n ypred,J = self.fwd_deriv_code(res.x.reshape(len(res.x),1))\n ypred=np.log10(ypred)\n residnorm = norm(ypred-ymeas)\n print('resid norm',residnorm)\n L = create_findiff_mtx(len(self.minit),self.beta)\n print('maxeig JJ',np.real(np.amax(np.linalg.eigvals(np.dot(J.T,J))))) # J'J has real eigvals but kept cplx type\n print('maxeig LL',np.amax(np.linalg.eigvals(np.dot(L.T,L))))\n if self.showplot:\n f, ax = plt.subplots(1, 2, figsize=(11,4))\n # plot the meas and pred data:\n # print('ypred',ypred)\n # print('ymeas',ymeas)\n ax[0].plot(ypred,'r.-')\n ax[0].plot(ymeas,'k.-')\n ax[0].grid()\n #ax[0].set_ylabel('cost')\n #ax[0].set_xlabel('iterations')\n ax[0].set_title('Measured (blk) and predicted (blu) data')\n # plot the init, true, and final model param vectors:\n ax[1].plot(self.minit,'g.-')\n ax[1].plot(res.x,'r.--')\n ax[1].plot(mmeas,'k.--')\n ax[1].grid()\n #ax[1].set_ylabel('model value')\n #ax[1].set_xlabel('indep var')\n ax[1].set_title('Model vectors (true=blk, init=grn, soln=red)')\n\n # return m,cost,misfit,modelnorm,norm(dm),testMSE\n return res.x,res.cost,np.nan,np.nan,np.nan,testMSE\n\n elif alg=='mine':\n cost = []\n m = self.minit\n mlen = len(m)\n if self.verbose:\n print('iter alpha cost norm(dd) norm(dm) dmtol')\n for i in range(self.max_nfev):\n ypred,X = self.fwd_deriv_code(m) # m: model params vector, X: derivs matrix\n if self.usefindiff:\n def tmpfwdcode(m):\n return np.squeeze(self.fwd_deriv_code(m)[0])\n X = jacfindiff(tmpfwdcode,m,dx=1.0e-6) # dx=1.0e-6 is problem dependent!\n L = create_findiff_mtx(mlen,self.beta)\n G = np.concatenate((X, -self.alpha*L),axis=0)\n D = np.concatenate((ymeas-ypred, self.alpha*np.dot(L,m)),axis=0)\n misfit = cplxMSE(ymeas, ypred)\n modelnorm = norm(np.dot(L,m))**2\n current_cost = misfit + pow(self.alpha,2)*modelnorm\n dm,res,rnk,sv = lstsq(G,D)\n m = m + dm\n cost.append(current_cost)\n if self.verbose:\n print('%3d %6.1g %10.3f %10.3f %10.2g %6.3g' %\n (i, self.alpha, current_cost, norm(ymeas-ypred), norm(dm), self.dmtol))\n if norm(dm) < self.dmtol:\n break\n self.G = G\n self.ypred = ypred\n if mmeas is not None:\n testMSE = cplxMSE(m,mmeas)\n else:\n testMSE = npl.nan\n print('maxeig JJ',np.real(np.amax(np.linalg.eigvals(np.dot(X.T,X))))) # X'X has real eigvals but kept cplx type\n print('maxeig LL',np.amax(np.linalg.eigvals(np.dot(L.T,L))))\n if self.showplot:\n f, ax = plt.subplots(1, 2, figsize=(11,4))\n # plot the cost (ie loss) per iterations:\n ax[0].semilogy(cost,'.-') # (last element of cost)\n ax[0].grid()\n ax[0].set_ylabel('cost')\n ax[0].set_xlabel('iterations')\n ax[0].set_title('Cost history (misfit^2 + alpha^2*modelnorm^2)')\n # plot the init, true, final, and evolution of model params:\n #print('m',np.squeeze(m.T))\n ax[1].plot(mmeas,'k')\n ax[1].plot(self.minit,'g')\n ax[1].plot(m,'r')\n ax[1].grid()\n #ax[1].set_ylabel('model value')\n ax[1].set_xlabel('indep var')\n ax[1].set_title('Model vectors')\n\n return m,cost[-1],misfit,modelnorm,norm(dm),testMSE"],"string":"[\n \"def optimize(\\n # trials,\\n random_state=SEED):\\n\\n space = {\\n 'max_depth': scope.int(hp.uniform('max_depth', 5, 15)),\\n 'subsample': hp.uniform('subsample', 0.03, 1),\\n 'learning_rate' : hp.loguniform('learning_rate', np.log(0.005), np.log(0.5)) - 0.0001,\\n 'colsample_bytree': hp.uniform('colsample_bytree', 0.3, 1),\\n 'reg_alpha': hp.loguniform('reg_alpha', np.log(0.005), np.log(5)) - 0.0001,\\n 'reg_lambda': hp.loguniform('reg_lambda', np.log(1), np.log(5)),\\n 'bagging_freq': hp.choice('bagging_freq', [0, 1]),\\n 'num_leaves': scope.int(hp.uniform('num_leaves', 10, 128)),\\n 'n_estimators': 1000,\\n 'boosting': 'gbdt',\\n 'objective': 'multiclass',\\n 'num_class': 12,\\n 'metric': 'None',\\n 'is_unbalance': 'true',\\n # 'min_data_per_group': 1000,\\n 'verbose': -1,\\n 'random_seed': 42,\\n \\n }\\n\\n # Use the fmin function from Hyperopt to find the best hyperparameters\\n best = fmin(score_model, space, algo=tpe.suggest,\\n # trials=trials,\\n max_evals=hyperopt_niters)\\n return best\",\n \"def optimize(maxiter: int = 1000,\\n tol = None,\\n save_steps: int = 1,\\n c0: float = 0.62,\\n c1: float = 0.1,\\n c2: float = 0.602,\\n c3: float = 0.101,\\n c4: float = 0):\\n _spsa_vars = [c0, c1, c2, c3, c4]\\n theta = self.vectorizer.vector\\n nb_params = len(theta)\\n use_exact_grads = 'grads' in self._method\\n \\n if save_steps:\\n theta_vec = [theta]\\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\\n \\n \\n pbar = tqdm(total=maxiter, disable=not self.progbar)\\n def callback(_):\\n pbar.clear()\\n pbar.update()\\n val = round(self.loss, 5)\\n pbar.set_description(str(val))\\n\\n if self.loss_target is not None:\\n if self.loss < self.loss_target:\\n # returning True doesn't terminate optimization\\n pbar.close()\\n raise KeyboardInterrupt\\n \\n for ii in range(maxiter):\\n \\n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\\n delta = 2 * randint(0, 2, size=nb_params) - 1\\n # plus and minus directions\\n \\n if use_exact_grads:\\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\\n else:\\n theta_plus = theta + c_spsa * delta\\n theta_minus = theta - c_spsa * delta\\n\\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\\n # derivative estimate\\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\\n # updated theta\\n theta = theta - a_spsa * g_spsa\\n \\n callback(ii)\\n \\n if tol is not None:\\n if (cost_plus + cost_minus)/2 < tol:\\n pbar.close()\\n break\\n \\n if save_steps:\\n theta_vec.append(theta)\\n cost_vec.append(cost_plus/2+cost_minus/2)\\n \\n \\n result_dict = {'hyper_parameters':_spsa_vars,\\n 'maxiter':maxiter,\\n 'theta_opt':theta,\\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\\n if save_steps:\\n result_dict['theta_history'] = theta_vec\\n result_dict['cost_history'] = cost_vec\\n self.result_dict = result_dict\\n pbar.close()\\n\\n return self.inject_res_vector_and_return_tn()\",\n \"def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\\n TrainingTarget, TestData, ValData):\\n # Gradient Descent Solution for Linear Regression\\n La = 2\\n # learningRate = 0.01\\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\\n\\n for i in range(0, 400):\\n\\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\\n Delta_E_D = -np.dot(\\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\\n TRAINING_PHI[i])\\n La_Delta_E_W = np.dot(La, W_Now)\\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\\n Delta_W = -np.dot(learningRate, Delta_E)\\n W_T_Next = W_Now + Delta_W\\n W_Now = W_T_Next\\n\\n #-----------------TrainingData Accuracy---------------------#\\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\\n\\n #-----------------ValidationData Accuracy---------------------#\\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\\n\\n #-----------------TestingData Accuracy---------------------#\\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\\n\\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])\",\n \"def optimize_library_descent(self, target, direction='max', steps=100,\\n multiprocessing=False, ret_info=False,\\n args=None):\\n # get the target function to call\\n target_function = getattr(self, target)\\n if args is not None:\\n target_function = functools.partial(target_function, **args)\\n\\n # initialize the optimizer\\n value = target_function()\\n value_best, state_best = value, self.sens_mat.copy()\\n \\n if ret_info:\\n # store extra information\\n start_time = time.time()\\n info = {'values': {}}\\n values_count = self.parameters['optimizer_values_count']\\n values_step = max(1, steps // values_count)\\n \\n if multiprocessing:\\n # run the calculations in multiple processes\\n pool_size = self.get_number_of_cores()\\n pool = mp.Pool(processes=pool_size)\\n if ret_info:\\n values_step = max(1, values_step // pool_size)\\n \\n # iterate for given number of steps\\n for step in range(int(steps) // pool_size):\\n joblist = []\\n init_arguments = self.init_arguments\\n for _ in range(pool_size):\\n # modify the current state and add it to the job list\\n i = random.randrange(self.sens_mat.size)\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n params = init_arguments['parameters'] \\n params['sensitivity_matrix'] = self.sens_mat\\n params['initialize_state']['sensitivity'] = 'exact'\\n \\n joblist.append((copy.deepcopy(init_arguments), target))\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n # run all the jobs\\n results = pool.map(_run_job, joblist)\\n \\n # find the best result \\n if direction == 'max':\\n res_best = np.argmax(results)\\n if results[res_best] > value_best:\\n value_best = results[res_best]\\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\\n # use the best state as a basis for the next iteration\\n self.sens_mat = state_best\\n \\n elif direction == 'min':\\n res_best = np.argmin(results)\\n if results[res_best] < value_best:\\n value_best = results[res_best]\\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\\n # use the best state as a basis for the next iteration\\n self.sens_mat = state_best\\n \\n else:\\n raise ValueError('Unsupported direction `%s`' % direction)\\n \\n if ret_info and step % values_step == 0:\\n info['values'][step * pool_size] = results[res_best]\\n \\n else:\\n # run the calculations in this process\\n for step in range(int(steps)):\\n # modify the current state\\n i = random.randrange(self.sens_mat.size)\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n # get the value of the new state\\n value = target_function()\\n \\n improved = ((direction == 'max' and value > value_best) or\\n (direction == 'min' and value < value_best))\\n if improved:\\n # save the state as the new best value\\n value_best, state_best = value, self.sens_mat.copy()\\n else:\\n # undo last change\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n if ret_info and step % values_step == 0:\\n info['values'][step] = value_best\\n\\n # sort the best state and store it in the current object\\n state_best = self.sort_sensitivity_matrix(state_best)\\n self.sens_mat = state_best.copy()\\n\\n if ret_info:\\n info['total_time'] = time.time() - start_time \\n info['states_considered'] = steps\\n info['performance'] = steps / info['total_time']\\n return value_best, state_best, info\\n else:\\n return value_best, state_best\",\n \"def _make_spsa_optimizer(self):\\n def optimize(maxiter: int = 1000,\\n tol = None,\\n save_steps: int = 1,\\n c0: float = 0.62,\\n c1: float = 0.1,\\n c2: float = 0.602,\\n c3: float = 0.101,\\n c4: float = 0):\\n \\\"\\\"\\\"\\n This method is heavily based on qiskits optimizers.spsa method, \\n adapted here to worth with on quibs tn's without exact gradients \\n\\n Parameters\\n ----------\\n maxiter: Maximum number of iterations to perform.\\n tol : None or float stops optim if tol is reached (default none - completes all steps)\\n save_steps: Save intermediate info every save_steps step. It has a min. value of 1.\\n last_avg: Averaged parameters over the last_avg iterations.\\n If last_avg = 1, only the last iteration is considered. It has a min. value of 1.\\n c0: The initial a. Step size to update parameters.\\n c1: The initial c. The step size used to approximate gradient.\\n c2: The alpha in the paper, and it is used to adjust a (c0) at each iteration.\\n c3: The gamma in the paper, and it is used to adjust c (c1) at each iteration.\\n c4: The parameter used to control a as well.\\n \\n Returns\\n -------\\n TYPE : updated object? (same return as TNOptimize)\\n \\\"\\\"\\\"\\n _spsa_vars = [c0, c1, c2, c3, c4]\\n theta = self.vectorizer.vector\\n nb_params = len(theta)\\n use_exact_grads = 'grads' in self._method\\n \\n if save_steps:\\n theta_vec = [theta]\\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\\n \\n \\n pbar = tqdm(total=maxiter, disable=not self.progbar)\\n def callback(_):\\n pbar.clear()\\n pbar.update()\\n val = round(self.loss, 5)\\n pbar.set_description(str(val))\\n\\n if self.loss_target is not None:\\n if self.loss < self.loss_target:\\n # returning True doesn't terminate optimization\\n pbar.close()\\n raise KeyboardInterrupt\\n \\n for ii in range(maxiter):\\n \\n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\\n delta = 2 * randint(0, 2, size=nb_params) - 1\\n # plus and minus directions\\n \\n if use_exact_grads:\\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\\n else:\\n theta_plus = theta + c_spsa * delta\\n theta_minus = theta - c_spsa * delta\\n\\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\\n # derivative estimate\\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\\n # updated theta\\n theta = theta - a_spsa * g_spsa\\n \\n callback(ii)\\n \\n if tol is not None:\\n if (cost_plus + cost_minus)/2 < tol:\\n pbar.close()\\n break\\n \\n if save_steps:\\n theta_vec.append(theta)\\n cost_vec.append(cost_plus/2+cost_minus/2)\\n \\n \\n result_dict = {'hyper_parameters':_spsa_vars,\\n 'maxiter':maxiter,\\n 'theta_opt':theta,\\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\\n if save_steps:\\n result_dict['theta_history'] = theta_vec\\n result_dict['cost_history'] = cost_vec\\n self.result_dict = result_dict\\n pbar.close()\\n\\n return self.inject_res_vector_and_return_tn()\\n return optimize\",\n \"def optimize(self, trial):\\r\\n num_leaves = trial.suggest_int(\\\"num_leaves\\\", 6, 50)\\r\\n min_child_samples = trial.suggest_int(\\\"min_child_samples\\\", 100, 500)\\r\\n min_child_weight = trial.suggest_uniform(\\\"min_child_weight\\\", 1, 7)\\r\\n subsample = trial.suggest_uniform(\\\"subsample\\\", 0.6, 1)\\r\\n colsample_bytree = trial.suggest_uniform(\\\"colsample_bytree\\\", 0.6, 1)\\r\\n reg_alpha = trial.suggest_uniform(\\\"reg_alpha\\\", 0.1, 100)\\r\\n reg_lambda = trial.suggest_uniform(\\\"reg_lambda\\\", 0.1, 100)\\r\\n\\r\\n model = LGBMRegressor(\\r\\n num_leaves=num_leaves,\\r\\n min_child_samples=min_child_samples,\\r\\n min_child_weight=min_child_weight,\\r\\n subsample=subsample,\\r\\n colsample_bytree=colsample_bytree,\\r\\n reg_alpha=reg_alpha,\\r\\n reg_lambda=reg_lambda,\\r\\n )\\r\\n\\r\\n model = ModelTrainer(file_object=self.file_object).get_trained_model(\\r\\n model, self.X_train, self.y_train\\r\\n )\\r\\n r_squared, rmse = ModelScorer(file_object=self.file_object).get_model_scores(\\r\\n model, self.X_test, self.y_test\\r\\n )\\r\\n\\r\\n return r_squared\",\n \"def _optimize(self) -> None:\\n\\n for i, agent in enumerate(self.agents):\\n states, actions, rewards, next_states, dones = self.memory.sample()\\n\\n actor_next_state = self._agent_states(i, next_states)\\n next_actions = torch.cat(\\n [a.actor_target(actor_next_state) for a in self.agents], 1\\n )\\n next_q = agent.critic_target(next_states, next_actions).detach()\\n target_q = rewards[:, i].view(-1, 1) + self.gamma * next_q * (\\n 1 - dones[:, i].view(-1, 1)\\n )\\n local_q = agent.critic_local(states, actions)\\n\\n value_loss = agent.loss_fn(local_q, target_q)\\n agent.value_optimizer.zero_grad()\\n value_loss.backward()\\n agent.value_optimizer.step()\\n\\n local_actions = []\\n for i, a in enumerate(self.agents):\\n local_states = self._agent_states(i, states)\\n local_actions.append(\\n a.actor_local(local_states)\\n if a == agent\\n else a.actor_local(local_states).detach()\\n )\\n local_actions = torch.cat(local_actions, 1)\\n policy_loss = -agent.critic_local(states, local_actions).mean()\\n\\n agent.policy_optimizer.zero_grad()\\n policy_loss.backward()\\n agent.policy_optimizer.step()\\n\\n self._update_target_model(agent.critic_local, agent.critic_target)\\n self._update_target_model(agent.actor_local, agent.actor_target)\",\n \"def hyperopt_func(model_dict, model_param_names, training_param_names, param_space, datasets, max_evals=30):\\n tester = fitness(model_dict, model_param_names, training_param_names, datasets)\\n trials = Trials()\\n \\n timer_start = timer()\\n best = fmin(fn=tester.objective, \\n space=param_space, \\n algo=tpe.suggest, \\n max_evals=max_evals, \\n trials=trials, \\n rstate=np.random.RandomState(50))\\n timer_end = timer()\\n print('Total training time (min):',(timer_end-timer_start)/60)\\n results = sorted(trials.results, key = lambda x: x['loss'])\\n return results\",\n \"def optimize(self,\\n max_grad_norm=0.5,\\n learning_rate=7e-4,\\n rms_decay=0.99,\\n rms_epsilon=1e-5):\\n grads = tf.gradients(tf.negative(self.objective), self.variables)\\n if max_grad_norm is not None:\\n grads, _ = tf.clip_by_global_norm(grads, max_grad_norm)\\n trainer = tf.train.RMSPropOptimizer(learning_rate=learning_rate,\\n decay=rms_decay,\\n epsilon=rms_epsilon)\\n return trainer.apply_gradients(list(zip(grads, self.variables)))\",\n \"def maximize(func, grad_func, x, y, theta_0, alpha_0=0.01, max_it=100):\\n return minimize(negate(func), negate_all(grad_func), x, y, theta_0, alpha_0=0.01, max_it=100)\",\n \"def optimizer(self):\\n \\n # taken from https://github.com/germain-hug/Deep-RL-Keras/blob/master/DDPG/actor.py\\n # I believe this is a work around to get keras to learn **given a gradient**\\n # As opposed to bunch of x_train, y_trains?\\n \\n #Inputs\\n state_pl = self.model.input\\n action_grads_pl = K.placeholder(shape=(None,1)) \\n \\n #Find grad_(pars) mu(state)\\n mu_pl = self.model.output\\n pars = self.model.trainable_weights\\n pars_grad_mu = tf.gradients(mu_pl, pars, -action_grads_pl)\\n \\n #grads_and_pars = zip(pars_grad_mu, pars) #keras needs this form\\n #updates = tf.train.AdamOptimizer(self.lr).apply_gradients(grads_and_pars)\\n\\n # The gradients as defined above work on my mac, but not ubuntu.\\n # Below I am trying a workaround. I changed the keras source code \\n # To get this working. Specifically, I make the optimizer.get_updates()\\n # function accept custom gradients. It was easy to do.\\n \\n opt = Adam(self.lr)\\n loss = pars_grad_mu #placeholder, I won't use it\\n updates = opt.get_updates(loss = loss, params = pars, grads = pars_grad_mu)\\n\\n return K.function(inputs = [state_pl, action_grads_pl], outputs = [], updates = updates)\\n #return K.function(inputs = [state_pl, action_grads_pl], outputs = [updates])\",\n \"def optimize(self, max_iters=1e3, messages=False, use_counter=False,\\\\\\n factr=1e7, pgtol=1e-05):\\n logger.debug('Beginning MLE to optimize hyperparams. grad_method=%s'\\\\\\n % self.grad_method)\\n\\n # setup the optimization\\n try:\\n x0 = self._transform_parameters(self.parameters)\\n assert np.all(np.isfinite(x0))\\n except:\\n logger.error('Transformation failed for initial values. '\\\\\\n + 'Ensure constraints are met or the value is not too small.')\\n raise\\n\\n # filter out the fixed parameters\\n free = np.logical_not(self._fixed_indicies)\\n x0 = x0[free]\\n\\n # setup the counter\\n if use_counter:\\n self._counter = solver_counter(disp=True)\\n else:\\n self._counter = None\\n\\n # run the optimization\\n try:\\n x_opt, f_opt, opt = fmin_l_bfgs_b(func=self._objective_grad, x0=x0,\\\\\\n factr=factr, pgtol=pgtol, maxiter=max_iters, disp=messages)\\n except (KeyboardInterrupt,IndexError):\\n logger.info('Keyboard interrupt raised. Cleaning up...')\\n if self._counter is not None and self._counter.backup is not None:\\n self.parameters = self._counter.backup[1]\\n logger.info('will return best parameter set with'\\\\\\n + 'log-likelihood = %.4g' % self._counter.backup[0])\\n else:\\n logger.info('Function Evals: %d. Exit status: %s' % (f_opt, opt['warnflag']))\\n # extract the optimal value and set the parameters to this\\n transformed_parameters = self._previous_parameters \\n transformed_parameters[free] = x_opt\\n self.parameters = self._untransform_parameters(transformed_parameters)\\n return opt\",\n \"def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\\n return x_best, -y_best\",\n \"def optimization_step(self):\\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\\n \\n var_list = [self.x_tilda, self.minibatch_set]\\n \\n if (self.num_samples > 0) and (not self.mixture):\\n \\n if ((self.mf_steps > 0) and self.alpha >0) or\\\\\\n self.gibbs_steps > 0: \\n \\n var_list.append(self.sampler_theta)\\n \\n elif \\\"CD\\\" in self.algorithm:\\n \\n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \\n \\n var_list = [self.minibatch_set]\\n \\n var_list.append(self.learning_rate)\\n \\n if self.use_momentum:\\n \\n var_list.append(self.momentum)\\n \\n output_vars = [self.pseudo_cost]\\n \\n if self.report_p_tilda:\\n \\n output_vars.append(self.p_tilda)\\n \\n else:\\n \\n output_vars.append(theano.shared(0))\\n \\n opt_step = theano.function(inputs = var_list,\\n outputs = output_vars,\\n updates = self.updates,\\n givens = input_dict,\\n on_unused_input='warn')\\n \\n return opt_step\",\n \"def fit(self, w):\\n w_former = w\\n w_next = w\\n w_t = w\\n w_t_100 = w\\n w_diff = 10000\\n i = 0\\n #tim_beg = t.time()\\n # use two part to calculate the a(w,w0):calculate the gradient using regular or SDG, batch = 10\\n # calculate the gradient and update the w,w0\\n while i < 10000 and np.abs(w_diff) > 0.00001:\\n loss_func = self.lost\\n grads = self.gradient(loss_func)\\n # calculate the y_pred(eta)\\n w_next = w_former - grads(w_former) / (10000)\\n k =self.lost(w_next) - self.lost(w_former)\\n m = np.dot(w_next-w_former, grads(w_former).T)\\n if i != 0 and i % 100 == 0:\\n w_t = w_t_100\\n w_t_100 = w_next\\n w_diff = 1 / len(w) * (np.sum(np.abs(w_t_100 - w_t)))\\n i_loss = self.lost(w_next)\\n print(\\\"Iteration < %d > with loss < %f >\\\" % (i, i_loss))\\n #self.los_plt.append(i_loss)\\n #tim = t.time() - tim_beg\\n #self.tim.append(tim)\\n i += 1\\n w_former = w_next\\n #plt.plot(self.tim, self.los_plt)\\n #plt.xlabel(\\\"time\\\")\\n #plt.ylabel('loss')\\n #plt.show()\\n if i >= 10000:\\n print(\\\"~Optimization stops because finishing iteration~\\\")\\n if np.abs(w_diff) <= 0.00001:\\n print(\\\"~Optimization stops because of difference between weights are less than 0.00001~\\\")\\n self.w_result = w_next\",\n \"def minimize(self):\\n self.normalize()\\n p0s = self.spacedvals(method='random')\\n if self.n_spots > 1:\\n opts = self.multifit(p0s)\\n else:\\n opts = self.singlefit(p0s)\\n self.yf = [self.solve(theta) for theta in opts]\\n self.bestps = opts\\n return opts\",\n \"def evaltr(x_solution): \\n \\n large = 10.0**30\\n pred = np.zeros(cfg.ntrain)\\n e0 = 0.0 # mean of observed values\\n y=0.0\\n for i in range(cfg.ntrain): # Computation of correct piece\\n e0 += cfg.a_unscaled[i][-1]\\n pind = 0\\n ipbest = 0\\n pbest = -large # for max\\n \\n for j1 in range(cfg.nomax):\\n ipmin=pind\\n pmin=large # for min\\n for _ in range(cfg.jk[j1]):\\n piece=x_solution[(pind+1)*cfg.nfea-1] \\n for j3 in range(cfg.nfea-1): #\\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\\n if piece < pmin:\\n ipmin = pind\\n pmin = piece\\n pind += 1 \\n \\n if pmin > pbest:\\n ipbest = ipmin\\n pbest = pmin\\n \\n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\\n for j1 in range(cfg.nfea-1):\\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\\n y += pred[i]\\n \\n y = y/cfg.ntrain \\n e0 = e0/cfg.ntrain\\n \\n # Computation of indices\\n rmse = 0.0\\n mae = 0.0\\n e1 = 0.0\\n for i in range(cfg.ntrain):\\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \\n e1 += (cfg.a_unscaled[i][-1] - e0)**2\\n ce = 1.0 - rmse/e1 \\n rmse = np.sqrt(rmse/cfg.ntrain)\\n mae = mae/cfg.ntrain \\n\\n if cfg.ntrain > 1:\\n sx=0.0\\n sy=0.0\\n rcor=0.0\\n for i in range(cfg.ntrain):\\n sx += (pred[i]-y)**2\\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \\n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \\n\\n r = rcor/np.sqrt(sx*sy)\\n \\n return rmse,mae,ce,r\",\n \"def optimize(self):\\n # Loop through every WD and WS individually\\n wd_array = self.fi_subset.floris.flow_field.wind_directions\\n ws_array = self.fi_subset.floris.flow_field.wind_speeds\\n for nwsi, ws in enumerate(ws_array):\\n\\n self.fi_subset.reinitialize(wind_speeds=[ws])\\n\\n for nwdi, wd in enumerate(wd_array):\\n # Find turbines to optimize\\n turbs_to_opt = self._turbs_to_opt_subset[nwdi, nwsi, :]\\n if not any(turbs_to_opt):\\n continue # Nothing to do here: no turbines to optimize\\n\\n # Extract current optimization problem variables (normalized)\\n yaw_lb = self._minimum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt]\\n yaw_ub = self._maximum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt]\\n bnds = [(a, b) for a, b in zip(yaw_lb, yaw_ub)]\\n x0 = self._x0_subset_norm[nwdi, nwsi, turbs_to_opt]\\n\\n J0 = self._farm_power_baseline_subset[nwdi, nwsi]\\n yaw_template = self._yaw_angles_template_subset[nwdi, nwsi, :]\\n turbine_weights = self._turbine_weights_subset[nwdi, nwsi, :]\\n yaw_template = np.tile(yaw_template, (1, 1, 1))\\n turbine_weights = np.tile(turbine_weights, (1, 1, 1))\\n\\n # Define cost function\\n def cost(x):\\n x_full = np.array(yaw_template, copy=True)\\n x_full[0, 0, turbs_to_opt] = x * self._normalization_length\\n return (\\n - 1.0 * self._calculate_farm_power(\\n yaw_angles=x_full,\\n wd_array=[wd],\\n turbine_weights=turbine_weights\\n )[0, 0] / J0\\n )\\n\\n # Perform optimization\\n residual_plant = minimize(\\n fun=cost,\\n x0=x0,\\n bounds=bnds,\\n method=self.opt_method,\\n options=self.opt_options,\\n )\\n\\n # Undo normalization/masks and save results to self\\n self._farm_power_opt_subset[nwdi, nwsi] = -residual_plant.fun * J0\\n self._yaw_angles_opt_subset[nwdi, nwsi, turbs_to_opt] = (\\n residual_plant.x * self._normalization_length\\n )\\n\\n # Finalize optimization, i.e., retrieve full solutions\\n df_opt = self._finalize()\\n return df_opt\",\n \"def _objective(self, trial, X, y, weights=None, split=None):\\n\\n # Generate even weights if none\\n if weights is None:\\n weights = pd.Series(np.ones(len(y)), index=y.index)\\n else:\\n weights = pd.Series(weights, index=y.index)\\n\\n # Execute trial function\\n try:\\n res = eval(self.function)\\n except:\\n raise RuntimeError(f\\\"Optuna execution error: {self.function}\\\")\\n\\n # If indicator result is tuple, select the one of interest\\n if isinstance(res, tuple):\\n res = res[self.idx]\\n\\n # Ensure result is a dataframe with same index as X\\n res = pd.DataFrame(res, index=X.index)\\n\\n # If indicator result is dataframe, select the one of interest\\n if len(res.columns) > 1:\\n res = pd.DataFrame(res.iloc[:, self.idx])\\n\\n # y may be a subset of X, so reduce result to y and convert to series\\n res_y = res.reindex(y.index).iloc[:, 0].replace([np.inf, -np.inf], np.nan)\\n\\n # Save all trial results for pruning and reporting\\n # Only the best trial will eventually be saved to limit storage requirements\\n self.res_y.append(res_y) # Save results\\n\\n # Indicator result may be all NANs based on parameter set\\n # Return FALSE and alert\\n if np.isnan(res_y).sum() / len(res_y) > .95: # Most or all NANs\\n self.res_y_corr.append(np.zeros(len(y)))\\n if split is not None:\\n return tuple([False] * (len(split) - 1))\\n else:\\n return False\\n\\n # Obtain correlation for entire dataset\\n if self.spearman:\\n corr = _weighted_spearman(np.array(y), np.array(res_y), np.array(weights))\\n else:\\n corr = _weighted_pearson(np.array(y), np.array(res_y), np.array(weights))\\n\\n # Save correlation for res_y\\n self.res_y_corr.append(corr)\\n\\n # Multi-objective optimization\\n # Obtain correlation to target for each split for Optuna to maximize\\n if split is not None:\\n mo = []\\n for i, e in enumerate(split):\\n if i == 0:\\n s = e\\n continue\\n\\n # y could be a subset of X, use index of X to filter y\\n idx = X[s:e].index\\n\\n # Filter y based on X split\\n y_se = np.array(y[y.index.isin(idx)]).astype('float64')\\n\\n # Filter y predictions based on X split\\n res_y_se = np.array(res_y[res_y.index.isin(idx)]).astype('float64')\\n\\n # Filter weights based on X split\\n weights_se = np.array(weights[weights.index.isin(idx)]).astype('float64')\\n\\n if np.isnan(res_y_se).sum() / len(res_y_se) > .95:\\n return tuple([False]*(len(split)-1))\\n\\n if self.spearman:\\n mo.append(_weighted_spearman(y_se, res_y_se, weights_se))\\n else:\\n mo.append(_weighted_pearson(y_se, res_y_se, weights_se))\\n s = e\\n return tuple(mo)\\n\\n # Single objective optimization return corr for entire dataset\\n else:\\n return corr\",\n \"def optimize(self, num_restarts=1, max_iters=100, max_f_eval=300.0, method='Anneal'):\\n dic = DictVectorizer()\\n # flatten the parameters\\n init_params,bounds=dic.fit_transform(self.params)\\n #we minimise minus the marginal likelihood\\n def objective(params_flatten):\\n self.params=dic.inverse_transform(params_flatten,bounds)\\n val = -self.log_marginal_likelihood()\\n return val# we want to maximize it\\n \\n \\n #run ptimisation with multiple restarts\\n optml=np.inf\\n for i in range(num_restarts):\\n #minimise function\\n if method=='Anneal':\\n res=dual_annealing(objective,bounds, maxiter=max_iters, maxfun=max_f_eval, x0=init_params)\\n else:\\n \\n res = minimize(objective, init_params, \\n bounds=bounds, method=method,options={'maxiter': max_iters, 'disp': False})\\n #print(\\\"Iteration \\\"+str(i)+\\\" \\\",-res.fun)\\n if res.fun<optml:\\n params_best=res.x #init_params \\n optml=res.fun\\n init_params=bounds[:,0]+(bounds[:,1]-bounds[:,0])*np.random.rand(len(bounds[:,0]))\\n print(\\\"Iteration \\\"+str(i)+\\\" \\\",-res.fun)\\n #params_best=res.x\\n #optml=res.fun\\n self.params=dic.inverse_transform(params_best,bounds)\\n return -optml\",\n \"def approximate_gradient(self, theta, c, iter):\\n\\n true_theta = utils.true_param(theta)\\n\\n if self.history_count > 0:\\n current_goal, _ = self.average_evaluations(30)\\n else:\\n current_goal = SPSA_minimization.BAD_GOAL\\n\\n logging.info(f'{__file__} > current_goal: {current_goal}')\\n\\n print(f'current optimizer mean goal: {current_goal:0.5f} (low is better, lowest: -1.0, highest: 1.0)')\\n # print(f'Sample, optimizer goal = -(engine match score) or -(3.0 pts/4 games) or -0.75')\\n\\n bernouilli = self.create_bernouilli(theta)\\n\\n count = 0\\n while True:\\n logging.info(f'{__file__} Apply bernouilli term to theta, theta={theta}, c={c}, bernouilli={bernouilli}')\\n # Calculate two evaluations of f at points M + c * bernouilli and\\n # M - c * bernouilli to estimate the gradient. We do not want to\\n # use a null gradient, so we loop until the two functions evaluations\\n # are different. Another trick is that we use the same seed for the\\n # random generator for the two function evaluations, to reduce the\\n # variance of the gradient if the evaluations use simulations (like\\n # in games).\\n state = random.getstate()\\n theta1 = utils.linear_combinaison(1.0, theta, c, bernouilli)\\n logging.info(f'{__file__} theta1: {theta1}')\\n\\n # Apply parameter limits\\n logging.info(f'{__file__} > Apply limits to theta1 before sending to engine')\\n theta1 = utils.apply_limits(theta1)\\n logging.info(f'{__file__} theta1 with limits: {theta1}')\\n logging.info(f'{__file__} > run 1st match with theta1: {theta1}')\\n\\n random.setstate(state)\\n theta2 = utils.linear_combinaison(1.0, theta, -c, bernouilli)\\n logging.info(f'{__file__} theta2: {theta2}')\\n\\n # Apply parameter limits\\n logging.info(f'{__file__} > Apply limits to theta2 before sending to engine')\\n theta2 = utils.apply_limits(theta2)\\n logging.info(f'{__file__} theta2 with limits: {theta2}')\\n logging.info(f'{__file__} > run 2nd match with theta2: {theta2}')\\n\\n # Run the 2 matches in parallel after iteration 1.\\n manager = multiprocessing.Manager()\\n res = manager.dict()\\n thetas = [theta1, theta2]\\n\\n if iter < self.iter_parallel_start:\\n print('Run match 1 ...')\\n true_param = utils.true_param(theta1)\\n print('test_engine param:')\\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\\n print(f' {name}: {val[\\\"value\\\"]}, ({val[\\\"value\\\"] - val1[\\\"value\\\"]:+})')\\n\\n print('base_engine param:')\\n for name, val in utils.true_param(theta).items():\\n print(f' {name}: {val[\\\"value\\\"]}')\\n\\n t1 = time.perf_counter()\\n f1 = self.evaluate_goal(theta1, theta, 0, res, iter)\\n logging.info(f'f1 elapse: {time.perf_counter() - t1:0.2f}s')\\n print(f'Done match 1!, elapse: {time.perf_counter() - t1:0.2f}sec')\\n print(f'goal after match 1: {f1:0.5f}')\\n\\n # Run match 2\\n print('Run match 2 ...')\\n true_param = utils.true_param(theta2)\\n print('test_engine param:')\\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\\n print(f' {name}: {val[\\\"value\\\"]}, ({val[\\\"value\\\"] - val1[\\\"value\\\"]:+})')\\n\\n print('base_engine param:')\\n for name, val in utils.true_param(theta).items():\\n print(f' {name}: {val[\\\"value\\\"]}')\\n\\n t1 = time.perf_counter()\\n f2 = self.evaluate_goal(theta2, theta, 1, res, iter)\\n logging.info(f'f2 elapse: {time.perf_counter() - t1:0.2f}s')\\n print(f'Done match 2!, elapse: {time.perf_counter() - t1:0.2f}sec')\\n print(f'goal after match 2: {f2:0.5f}')\\n\\n print('Done engine match!')\\n else:\\n print('Run 2 matches in parallel ...')\\n t1 = time.perf_counter()\\n jobs = []\\n for i in range(2):\\n print(f'Run match {i + 1} ...')\\n\\n true_param = utils.true_param(thetas[i])\\n print('test_engine param:')\\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\\n print(f' {name}: {val[\\\"value\\\"]}, ({val[\\\"value\\\"] - val1[\\\"value\\\"]:+})')\\n\\n print('base_engine param:')\\n for name, val in utils.true_param(theta).items():\\n print(f' {name}: {val[\\\"value\\\"]}')\\n\\n p = multiprocessing.Process(target=self.evaluate_goal, args=(thetas[i], theta, i, res, iter))\\n jobs.append(p)\\n p.start()\\n\\n for num, proc in enumerate(jobs):\\n proc.join()\\n\\n # If match is done in parallel, update the history count, eval and theta here.\\n self.history_eval[self.history_count % 1000] = res.values()[num]\\n self.history_theta[self.history_count % 1000] = thetas[num]\\n self.history_count += 1\\n\\n print(f'Done match {num + 1}!, elapse: {time.perf_counter() - t1:0.2f}sec')\\n\\n logging.info(f'parallel elapse: {time.perf_counter() - t1:0.2f}s')\\n\\n print('Done engine match!')\\n\\n f1, f2 = res.values()[0], res.values()[1]\\n\\n logging.info(f'{__file__} > f1: {f1}, f2: {f2}')\\n print(f'optimizer goal after match 1: {f1:0.5f} (low is better)')\\n print(f'optimizer goal after match 2: {f2:0.5f} (low is better)')\\n\\n if f1 != f2:\\n break\\n\\n print('perf is the same in match 1 and 2, launch new matches ...')\\n\\n count = count + 1\\n logging.info(f'{__file__} > f1 and f2 are the same, try the engine match again. num_tries = {count}')\\n\\n if count >= 100:\\n logging.info(f'{__file__} > too many evaluation to find a gradient, function seems flat')\\n break\\n\\n # Update the gradient\\n gradient = copy.deepcopy(theta)\\n # print(f'Basic gradient after 2 engine matches:')\\n for name, value in theta.items():\\n gradient[name]['value'] = (f1 - f2) / (2.0 * c * bernouilli[name]['value'])\\n # print(f' {name}: {gradient[name][\\\"value\\\"]}')\\n logging.info(f'{__file__} > {name} gradient: {gradient}')\\n\\n if (f1 > current_goal) and (f2 > current_goal):\\n logging.info(f'{__file__} > function seems not decreasing')\\n gradient = utils.linear_combinaison(0.1, gradient)\\n\\n print('Modify the gradient because the results of engine matches\\\\n'\\n 'did not improve when using the new param. But we will not\\\\n'\\n 're-run the engine matches.')\\n\\n print('Modified gradient at alpha=0.1:')\\n for n, v in gradient.items():\\n print(f' {n}: {v[\\\"value\\\"]}')\\n\\n # For the correction factor used in the running average for the gradient,\\n # see the paper \\\"Adam: A Method For Stochastic Optimization, Kingma and Lei Ba\\\"\\n\\n beta = 0.9\\n correction = 1.0 / 1.0 - pow(beta, self.iter)\\n\\n gradient = utils.linear_combinaison((1 - beta), gradient, beta, self.previous_gradient)\\n gradient = utils.linear_combinaison(correction, gradient)\\n\\n # print('New gradient after applying correction:')\\n # for n, v in gradient.items():\\n # print(f' {n}: {v[\\\"value\\\"]}')\\n\\n # Store the current gradient for the next time, to calculate the running average\\n self.previous_gradient = gradient\\n\\n # Store the best the two evals f1 and f2 (or both)\\n if (f1 <= current_goal):\\n self.best_eval[self.best_count % 1000] = f1\\n self.best_theta[self.best_count % 1000] = theta1\\n self.best_count += 1\\n\\n if (f2 <= current_goal):\\n self.best_eval[self.best_count % 1000] = f2\\n self.best_theta[self.best_count % 1000] = theta2\\n self.best_count += 1\\n\\n logging.info(f'{__file__} > final gradient: {gradient}')\\n \\n # Return the estimation of the new gradient\\n return gradient\",\n \"def optimize_model(self, gradient_clamping_value=None):\\n # TODO: worry about this later\\n # if self.kwargs['use_PER']:\\n # # Create batch with PrioritizedReplayBuffer/PER:\\n # transitions, importance_sampling_weights = self.replayBuffer.sample(self.batch_size)\\n # batch = EXPPER(*zip(*transitions))\\n # importance_sampling_weights = torch.from_numpy(importance_sampling_weights)\\n # if self.use_cuda:\\n # importance_sampling_weights = importance_sampling_weights.cuda()\\n\\n self.optimizer.zero_grad()\\n transitions, batch = self.sample_from_replay_buffer(self.batch_size)\\n\\n next_state_batch, state_batch, action_batch, reward_batch, \\\\\\n non_terminal_batch = self.create_tensors_for_optimization(batch,\\n use_cuda=self.use_cuda)\\n\\n dqn_loss = compute_loss(states=state_batch,\\n actions=action_batch,\\n next_states=next_state_batch,\\n rewards=reward_batch,\\n non_terminals=non_terminal_batch,\\n model=self.model,\\n target_model=self.target_model,\\n gamma=self.GAMMA,\\n use_double=self.use_double,\\n use_dueling=self.use_dueling,\\n iteration_count=self.target_update_count)\\n\\n dqn_loss.backward()\\n\\n if gradient_clamping_value is not None:\\n torch.nn.utils.clip_grad_norm(self.model.parameters(), gradient_clamping_value)\\n\\n self.optimizer.step()\\n\\n # TODO: Worry about this later\\n #loss_per_item = dqn_loss\\n #loss_np = loss_per_item.cpu().data.numpy()\\n #if self.kwargs['use_PER']:\\n # for (idx, new_error) in zip(batch.idx, loss_np):\\n # new_priority = self.replayBuffer.priority(new_error)\\n # self.replayBuffer.update(idx, new_priority)\\n\\n #return loss_np\",\n \"def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\\r\\n\\r\\n\\t\\r\\n\\tif grad == 'NO':\\r\\n\\t\\tif method == 'Powell' :\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'Nelder-Mead':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t options = {'ftol': 0.0001})\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'default':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, \\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\r\\n\\telif grad == 'YES':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \\r\\n \\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\\r\\n\\t\\treturn res.x, res.nit \\r\\n\\t\\t\\t\\r\\n\\t\\t\\r\\n\\telif grad == 'HESS':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\\r\\n\\t\\t\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t\\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \\r\\n\\t\\treturn res.x, res.nit\",\n \"def fit(self, X, y, weights=None, idx=0, verbose=False, early_stop=None, split=None):\\n\\n start_time = timer()\\n self.idx = idx\\n self.split = split\\n\\n # Display Optuna trial messages\\n if not verbose:\\n optuna.logging.set_verbosity(optuna.logging.ERROR)\\n\\n # Single objective optimization\\n if split is None:\\n\\n # Create optuna study maximizing correlation\\n self.study = optuna.create_study(direction='maximize', study_name=self.function)\\n\\n # Set required early stopping variables\\n self.study.early_stop = early_stop\\n self.study.early_stop_count = 0\\n self.study.best_score = None\\n\\n # Start optimization trial\\n try:\\n self.study.optimize(lambda trial: _objective(self, trial, X, y, weights),\\n n_trials=self.n_trials, callbacks=[_single_early_stopping_opt])\\n\\n # Early stopping (not officially supported by Optuna)\\n except optuna.exceptions.OptunaError:\\n pass\\n\\n # Keep only results of best trial for prune and reporting\\n self.res_y = self.res_y[self.study.best_trial.number]\\n self.res_y.name = col_name(self.function, self.study.best_trial.params)\\n self.res_y_corr = self.res_y_corr[self.study.best_trial.number]\\n\\n # Multi objective optimization\\n else:\\n\\n # Create study to maximize eash split\\n sampler = optuna.samplers.NSGAIISampler()\\n self.study = optuna.create_study(directions=(len(split)-1) * ['maximize'], sampler=sampler,\\n study_name=self.function)\\n\\n # Early stopping variables\\n self.study.early_stop = early_stop\\n self.study.early_stop_count = 0\\n\\n # Custom best trial variables (Optuna \\\"best\\\" are immutable)\\n self.study.top_trial = 0\\n self.study.top_params = None\\n self.study.top_value = None\\n\\n # Start optimization trial\\n try:\\n self.study.optimize(lambda trial: _objective(self, trial, X, y, weights, split),\\n n_trials=self.n_trials, callbacks=[_multi_early_stopping_opt])\\n\\n # Early stopping (not officially supported by Optuna)\\n except optuna.exceptions.OptunaError:\\n pass\\n\\n # Validation checks\\n if np.mean(self.study.trials[self.study.top_trial].values) != self.study.top_value:\\n raise RuntimeError(\\\"Top trial score invalid\\\")\\n if len(self.res_y) != len(self.study.trials) or len(self.res_y) != len(self.res_y_corr):\\n raise RuntimeError(\\\"Total results does not equal trials\\\")\\n\\n # Keep only results of best trial for prune and reporting\\n self.res_y = self.res_y[self.study.top_trial]\\n self.res_y.name = col_name(self.function, self.study.trials[self.study.top_trial].params)\\n self.res_y_corr = self.res_y_corr[self.study.top_trial]\\n\\n end_time = timer()\\n self.time = round(end_time - start_time, 2)\\n\\n return self\",\n \"def optimize(self):\\n \\n if self.verbose:\\n print('Starting grid search with bounds: [' + \\\\\\n ';'.join(['%5g to %5g']*len(self.steps))%tuple([(self.steps[i][0], self.steps[i][-1]) for i in range(len(self.steps))]) +']')\\n\\n for params in self._get_next_point():\\n self.transform.set_params(params)\\n\\n v, _ = self.measure.value_and_derivatives(self.transform)\\n\\n if v < self.best_value:\\n self.best_value = v\\n self.best_params = params\\n# print('New best value %2.4f at ('%v, ', '.join(['%8.3f']*len(params))%tuple(params), ')')\\n\\n self.value_history.append(v)\\n self.last_value = v\\n self.iteration += 1\\n\\n if self.report_freq > 0 and (self.iteration % self.report_freq == 0) and self.report_func is not None:\\n self.report_func(self)\\n\\n # Set the best transform\\n self.transform.set_params(self.best_params)\\n self.last_value = self.best_value\\n return self.best_value\",\n \"def set_optimal_parameters(self):\\n # Getting the best trial based on the test errors\\n idx = self.trial_losses.index(min(self.trial_losses))\\n self.best_trial = self.trial_list[idx]\\n self.objective.parse_trial(self.best_trial)\",\n \"def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\\n \\n costs = []\\n \\n for i in range(num_iterations):\\n \\n \\n # Cost and gradient calculation \\n grads, cost = propagate(w, b, X, Y)\\n\\n # Retrieve derivatives from grads\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n \\n # update rule (Gradient Descent)\\n w = w - learning_rate * dw\\n b = b - learning_rate * db\\n\\n # Record the change of costs\\n if i % 100 == 0:\\n costs.append(cost)\\n \\n # Print the cost every 100 training iterations\\n if print_cost and i % 100 == 0:\\n print (\\\"Cost after iteration %i: %f\\\" %(i, cost))\\n \\n params = {\\\"w\\\": w,\\n \\\"b\\\": b}\\n \\n grads = {\\\"dw\\\": dw,\\n \\\"db\\\": db}\\n \\n return params, grads, costs\",\n \"def optimizing(theta, data = data, target = target):\\n # num = (sin(individual[0] - individual[1] / 8))**2 + (sin(individual[1] + individual[0] / 8))**2\\n # denum = ((individual[0] - 8.6998)**2 + (individual[1] - 6.7665)**2)**0.5 + 1\\n learner = MLPClassifier(hidden_layer_sizes=theta[0], learning_rate_init=theta[1], alpha=theta[2], verbose=True, early_stopping=True, n_iter_no_change=6)\\n\\n model = learner.fit(data, target)\\n return model.best_loss_ # return the best error/residual (best error is cloes to zero) The error of a model is the difference between your predicted outcome and the real observed outcome and therefore 0 is desired\\n\\n # individual as a factor containing x, y = to tetha which \",\n \"def find_best_params(self, n_trials=120):\\r\\n self.logger_object.log(\\r\\n self.file_object,\\r\\n \\\"Entered find_best_params method of HyperparametersTuner class.\\\",\\r\\n )\\r\\n try:\\r\\n optimization_function = partial(self.optimize)\\r\\n study = optuna.create_study(direction=\\\"maximize\\\")\\r\\n study.optimize(optimization_function, n_trials=n_trials)\\r\\n self.logger_object.log(\\r\\n self.file_object, f\\\"Successfully ran {n_trials} optuna study trials.\\\"\\r\\n )\\r\\n\\r\\n self.tuned_hyperparams[\\\"LGBM Regression\\\"].append(study.best_params)\\r\\n self.logger_object.log(\\r\\n self.file_object,\\r\\n \\\"Successfully appended best model parameters as a dictionary.\\\",\\r\\n )\\r\\n\\r\\n with (open(str(Config.TUNED_HYPERPARAMS_FILE_PATH), \\\"w\\\")) as outfile:\\r\\n json.dump(self.tuned_hyperparams[\\\"LGBM Regression\\\"], outfile, indent=1)\\r\\n self.logger_object.log(\\r\\n self.file_object,\\r\\n \\\"Successfully dumped the best parameters in best_params.json .\\\",\\r\\n )\\r\\n except Exception as e:\\r\\n self.logger_object.log(\\r\\n self.file_object,\\r\\n f\\\"Exception occured in find_best_params method of HyperparametersTuner class. Exception message: {e}\\\",\\r\\n )\\r\\n self.logger_object.log(\\r\\n self.file_object,\\r\\n \\\"Dumping best parameters unsuccessful. Exited find_best_params method of HyperparametersTuner class\\\",\\r\\n )\\r\\n raise Exception()\",\n \"def minimize(self, func, grad, x0, args=()):\\n learning_rate = self._learning_rate\\n best_x = x = x0\\n best_value = func(x, *args)\\n iters_without_improve = 0\\n\\n for iteration in range(self._max_iterations):\\n gradient = grad(x, *args)\\n\\n # If absolute values of all partial derivatives are equal to 0 with specified accuracy, then parameters are\\n # close enough to the minimum and there is no need to continue gradient descent.\\n if np.abs(gradient).max() <= self._accuracy:\\n break\\n\\n x = x - learning_rate * gradient\\n\\n # If new values of x haven't lead to decrease of the function value for the specified number of iteration,\\n # the x is reverted to its previous best value and the learning rate is reduced\\n value = func(x, *args)\\n if value > best_value:\\n iters_without_improve += 1\\n if iters_without_improve >= self._lr_reduce_patience:\\n x = best_x\\n learning_rate *= self._lr_reduce_factor\\n else:\\n iters_without_improve = 0\\n best_value = value\\n best_x = x\\n\\n return best_x\",\n \"def opt_wrapper(m, **kwargs):\\r\\n m.optimize(**kwargs)\\r\\n return m.optimization_runs[-1]\",\n \"def optimize(self, X, y, *args):\\n self.loss_function.set_space(X, y, *args)\\n self.betas_ = fastgradalgo(\\n self.loss_function,\\n t_init=self.eta_init,\\n max_iter=self.max_iter\\n )\\n return self.betas_\",\n \"def opt_wrapper(m, **kwargs):\\n m.optimize(**kwargs)\\n return m.optimization_runs[-1]\",\n \"def run():\\n trials = 100\\n\\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\\n\\n mean_penalty = []\\n median_penalty = []\\n std_penalty = []\\n\\n mean_trial_time = []\\n median_trial_time = []\\n std_trial_time = []\\n\\n mean_success_rate = []\\n median_success_rate = []\\n std_success_rate = []\\n\\n for m in multipliers:\\n all_penalties = [] # All penalties from trail sets\\n all_average_trial_time = []\\n all_success_rates = []\\n\\n for i in range(0, 20):\\n # print \\\"Trial set:\\\", i\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n agent = e.create_agent(LearnerAgent) # create agent\\n agent.mult = m\\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\\n\\n sim.run(n_trials=trials) # run for a specified number of trials\\n\\n all_penalties.append(agent.all_trails_penalties)\\n all_average_trial_time.append(agent.time/float(trials))\\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\\n\\n mean_penalty.append(np.mean(all_penalties))\\n median_penalty.append(np.median(all_penalties))\\n std_penalty.append(np.std(all_penalties))\\n\\n mean_trial_time.append(np.mean(all_average_trial_time))\\n median_trial_time.append(np.median(all_average_trial_time))\\n std_trial_time.append(np.std(all_average_trial_time))\\n\\n mean_success_rate.append(np.mean(all_success_rates))\\n median_success_rate.append(np.median(all_success_rates))\\n std_success_rate.append(np.std(all_success_rates))\\n\\n for i in range(0, len(multipliers)):\\n print \\\"\\\"\\n print \\\"Multiplier:\\\", multipliers[i]\\n print \\\"\\\"\\n print \\\"Mean penalty per {} trials:\\\".format(trials), mean_penalty[i]\\n print \\\"Median penalty per {} trials:\\\".format(trials), median_penalty[i]\\n print \\\"Std.Dev. penalty per {} trials:\\\".format(trials), std_penalty[i]\\n\\n print \\\"\\\"\\n print \\\"Mean trial time:\\\", mean_trial_time[i]\\n print \\\"Median trial time:\\\", median_trial_time[i]\\n print \\\"Std.Dev. trial time:\\\", std_trial_time[i]\\n\\n print \\\"\\\"\\n print \\\"Mean success rate per {} trials:\\\".format(trials), mean_success_rate[i]\\n print \\\"Median success rate per {} trials:\\\".format(trials), median_success_rate[i]\\n print \\\"Std.Dev. success rate per {} trials:\\\".format(trials), std_success_rate[i]\",\n \"def optimize(w, b, X, Y, num_iterations,learning_rate,print_cost = False):\\n costs = []\\n for i in range(num_iterations):\\n\\n # Cost and gradient calculation (≈ 1-4 lines of code)\\n ### START CODE HERE ###\\n grads,cost = propagate(w,b,X,Y)\\n ### END CODE HERE ###\\n\\n # Retrieve derivatives from grads\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n\\n # update rule (≈ 2 lines of code)\\n ### START CODE HERE ###\\n w = w - learning_rate*dw\\n b = b - learning_rate*db\\n ### END CODE HERE ###\\n\\n # Record the costs\\n if i % 100 == 0:\\n costs.append(cost)\\n\\n # Print the cost every 100 training examples\\n if print_cost and i%100==0:\\n print(\\\"Cost after iteration %i: %f\\\"%(i,cost))\\n\\n params = {\\n \\\"w\\\":w,\\n \\\"b\\\":b\\n }\\n grads = {\\n \\\"dw\\\":dw,\\n \\\"db\\\":db\\n }\\n return params,grads,costs\",\n \"def makeOptimizationStep(modelNet, targetNet, gameMemory, optimizer):\\n statesBatch, actionsBatch, nextStatesBatch, rewardsBatch, terminalMask = gameMemory.getBatch()\\n currentQValues = modelNet(statesBatch).gather(1, actionsBatch.unsqueeze(1))\\n nextQValues = targetNet(nextStatesBatch).max(1)[0].detach()\\n nextQValues[terminalMask == 1] = 0\\n expectedQValues = rewardsBatch + nextQValues * DISCOUNT_FACTOR\\n expectedQValues = torch.tensor(expectedQValues).unsqueeze(1).to(DEVICE)\\n loss = F.smooth_l1_loss(currentQValues, expectedQValues)\\n optimizer.zero_grad()\\n loss.backward()\\n for param in modelNet.parameters():\\n param.grad.data.clamp_(-1, 1)\\n optimizer.step()\",\n \"def tune_model(self):\\n acc = 0\\n ### Early Stop Mechanism\\n loss = previous_loss = float(\\\"inf\\\")\\n patience_left = self.config.patience\\n ### Early Stop Mechanism\\n\\n self.generator = Generator(self.model.config, training_strategy=self.training_strategy)\\n self.evaluator = Evaluator(model=self.model,data_type=self.teston, debug=self.debug, tuning=True)\\n \\n for cur_epoch_idx in range(self.config.epochs):\\n loss = self.train_model_epoch(cur_epoch_idx, tuning=True)\\n ### Early Stop Mechanism\\n ### start to check if the loss is still decreasing after an interval. \\n ### Example, if early_stop_epoch == 50, the trainer will check loss every 50 epoche.\\n ### TODO: change to support different metrics.\\n if ((cur_epoch_idx + 1) % self.config.early_stop_epoch) == 0: \\n if patience_left > 0 and previous_loss <= loss:\\n patience_left -= 1\\n print('%s more chances before the trainer stops the training. (prev_loss, curr_loss): (%.f, %.f)' % \\\\\\n (patience_left, previous_loss, loss))\\n\\n elif patience_left == 0 and previous_loss <= loss:\\n self.evaluator.result_queue.put(Evaluator.TEST_BATCH_EARLY_STOP)\\n break\\n else:\\n patience_left = self.config.patience\\n\\n previous_loss = loss\\n\\n self.generator.stop()\\n self.evaluator.test(cur_epoch_idx)\\n acc = self.evaluator.output_queue.get()\\n self.evaluator.stop()\\n\\n return acc\",\n \"def optimizer() -> pd.DataFrame:\\n global iteration, coefs_all\\n\\n X_train, X_test, y_train, y_test = train_test()\\n\\n # Number of observations in train & test set\\n n_train = len(X_train)\\n n_test = len(X_test)\\n n_coefs = X_train.shape[1]\\n\\n # Initialize coefficients\\n coefs_init = np.random.normal(\\n loc=conf.coef_mu, \\n scale=conf.coef_sigma, \\n size=n_coefs\\n )\\n coefs_all = coefs_init.copy()\\n\\n # Coefficients shall be bounded\\n bounds = [conf.coef_bounds] * n_coefs\\n iteration = 0\\n\\n # Run optimization\\n result = minimize( \\n fun=lambda x: loss_func(x, X_train, y_train, n_train),\\n callback=lambda x: callback_func(x, X_train, y_train, n_train),\\n x0=coefs_init,\\n bounds=bounds\\n )\\n # Collect optimal coefficients\\n coefs = pd.Series(data=result.x, index=X_train.columns, name=\\\"coefs\\\")\\n coefs_df = pd.DataFrame(data=coefs_all, columns=X_train.columns).T\\n coefs_df.index.name = \\\"area\\\"\\n\\n rmse_train = result.fun\\n rmse_test = loss_func(\\n coefs=coefs, \\n X=X_test, \\n y=y_test, \\n n=n_test, \\n )\\n print(\\\"\\\\n\\\")\\n print (f\\\"Train RMSE: {rmse_train:.4f}\\\")\\n print (f\\\"Test RMSE: {rmse_test:.4f}\\\")\\n\\n return coefs_df\",\n \"def objective(self, trial):\\n # Suggest start row IDs\\n selected = [self.all_df.index.max()]\\n for i in range(self.n_points):\\n id_min = 3 * (self.n_points - len(selected) + 1)\\n id_max = selected[-1] - 3\\n if id_min + 3 > id_max:\\n return np.inf\\n new = trial.suggest_int(str(i), id_min, id_max)\\n selected.append(new)\\n start_ids = sorted(selected)[:-1]\\n # Create subsets\\n subsets = self.create_subsets(start_ids)\\n # Curve fitting for each subset\\n df_list = [self.curve_fit(df, num)\\n for (num, df) in enumerate(subsets, start=1)]\\n # Calculate the error\\n return self.error_f(df_list)\",\n \"def objective(trial):\\n # The parameters that we will calibrate the model for are shown here.\\n # Optuna trial i\\n BOD = trial.suggest_uniform(\\\"BOD\\\", 0, 1) #Review ranges here\\n k_r = trial.suggest_uniform(\\\"k_r\\\", 0, 1) #Review Ranges here \\n \\n def ChLa(t):\\n return 1 # Need to link to data\\n\\n def I(x):\\n return 1 # Need to link to data\\n\\n K_z = 2 * 10**(-5) # p.51\\n a = K_z\\n k_b = 0.1 # Table 5\\n th_b = 1.047 # Table 5\\n k_r = 0.1 # Table 5\\n YCHO2 = 0.0083 # Table 5\\n th_p = 1.036 # Table 5\\n th_s = 1.065 # Table 5\\n th_r = 1.047 # Table 5\\n\\n def Temp(t):\\n \\\"\\\"\\\"\\n Function that maps time to temperature\\n \\\"\\\"\\\"\\n return 20 # Need to link to data\\n\\n def P_max(t):\\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\\n\\n def L_min(t):\\n I = 1 # Need to link to PAR data\\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\\n K_2 = 15\\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\\n \\n # f deals with sink and source terms \\n def f(x, t):\\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \\n\\n L = 200 # Length of domain\\n dt = 1 / 48 # Mesh spacing in t\\n F = a * dt # a * dt / dx**2\\n T = 100 # Simulation time stop\\n\\n # Solving the PDE\\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\\n \\n # Creating some bogus targets while database errors are happening\\n DO_data = DO + np.random.random(len(DO))\\n\\n # Using mean squared error as the measure of fit, where we want\\n # to minimize this number\\n return ((DO - DO_data)**2).mean()\",\n \"def fit(self):\\n if self.minimizer == \\\"differential_evolution\\\":\\n kwargs = {\\\"maxiter\\\": self._maxiter}\\n elif self.minimizer == \\\"shgo\\\":\\n kwargs = {\\\"options\\\": {\\\"maxiter\\\": self._maxiter,\\n \\\"jac\\\": self.cost_func.jac_cost}}\\n elif self.minimizer == \\\"dual_annealing\\\":\\n kwargs = {\\\"maxiter\\\": self._maxiter, \\\"local_search_options\\\": {\\n \\\"jac\\\": self.cost_func.jac_cost}}\\n fun = self.cost_func.eval_cost\\n bounds = self.value_ranges\\n algorithm = getattr(optimize, self.minimizer)\\n result = algorithm(fun, bounds, **kwargs)\\n self._popt = result.x\\n if result.success:\\n self._status = 0\\n elif \\\"Maximum number of iteration\\\" in result.message:\\n self._status = 1\\n else:\\n self._status = 2\",\n \"def target_and_grad(x, ref_params, data_modelers, SIM, params):\\n target_functional = 0\\n grad = np.zeros(len(x))\\n\\n save_name = params.geometry.optimized_detector_name\\n if not all(params.geometry.fix.panel_rotations) and not all(params.geometry.fix.panel_rotations):\\n geometry_refiner.update_detector(x, ref_params, SIM, save_name)\\n\\n all_shot_sigZ = []\\n for i_shot in data_modelers:\\n Modeler = data_modelers[i_shot]\\n\\n neg_LL, neg_LL_grad, model_pix, per_shot_sigZ = model(x, ref_params, i_shot, Modeler, SIM)\\n all_shot_sigZ.append(per_shot_sigZ)\\n\\n # accumulate the target functional for this rank/shot\\n target_functional += neg_LL\\n\\n if params.use_restraints:\\n for name in ref_params:\\n par = ref_params[name]\\n if not par.is_global and not par.fix:\\n val = par.get_restraint_val(x[par.xpos])\\n target_functional += val\\n\\n # accumulate the gradients for this rank/shot\\n for name in ref_params:\\n if name in neg_LL_grad:\\n par = ref_params[name]\\n grad[par.xpos] += neg_LL_grad[name]\\n # for restraints only update the per-shot restraint gradients here\\n if params.use_restraints and not par.is_global and not par.fix:\\n grad[par.xpos] += par.get_restraint_deriv(x[par.xpos])\\n\\n # sum the target functional and the gradients across all ranks\\n target_functional = COMM.bcast(COMM.reduce(target_functional))\\n grad = COMM.bcast(COMM.reduce(grad))\\n\\n if params.use_restraints and params.geometry.betas.close_distances is not None:\\n target_functional += np.std(SIM.D.close_distances) / params.geometry.betas.close_distances\\n\\n ## add in the detector parameter restraints\\n if params.use_restraints:\\n for name in ref_params:\\n par = ref_params[name]\\n if par.is_global and not par.fix:\\n target_functional += par.get_restraint_val(x[par.xpos])\\n grad[par.xpos] += par.get_restraint_deriv(x[par.xpos])\\n\\n all_shot_sigZ = COMM.reduce(all_shot_sigZ)\\n if COMM.rank == 0:\\n all_shot_sigZ = np.median(all_shot_sigZ)\\n\\n return target_functional, grad, all_shot_sigZ\",\n \"def solver_mtw(Xf, mXf, Ls, y, M, alpha, beta1, beta2, epsilon, gamma, coef1,\\n coef2, R, b1, b2, sigmas, concomitant=False,\\n stable=False, tol=1e-4, max_iter=1000, tol_ot=1e-5,\\n max_iter_ot=20, max_iter_cd=2000,\\n positive=False, n_jobs=1, tol_cd=1e-5, gpu=False,\\n ot_threshold=0):\\n log = {'loss': [], 'dloss': [], 'log_sinkhorn1': [], 'log_sinkhorn2': [],\\n 'stable': stable, \\\"objcd\\\": [], \\\"fot1\\\": [0.], \\\"fot2\\\": [0.],\\n 'reweighting_loss': [], \\\"n_coords\\\": [], \\\"obj\\\": 0.}\\n n_samples, n_features = Xf[0].shape\\n n_tasks = len(Xf)\\n if n_jobs == -1:\\n n_jobs = n_tasks\\n marginals1, marginals2 = np.ones((2, n_tasks, n_features)) / n_features\\n\\n theta1 = coef1.copy()\\n theta2 = coef2.copy()\\n theta = theta1 - theta2\\n\\n thetaold = theta.copy()\\n\\n ot_img = True\\n if len(M) == n_features:\\n ot_img = False\\n\\n update_ot_1 = set_ot_func(stable, ot_img)\\n update_ot_2 = set_ot_func(stable, ot_img)\\n\\n xp = utils.set_module(gpu)\\n M = xp.asarray(- M / epsilon)\\n if b1 is not None:\\n b1 = xp.asarray(b1)\\n if b2 is not None:\\n b2 = xp.asarray(b2)\\n\\n thetabar1 = np.ones_like(coef1).mean(axis=-1)\\n thetabar2 = np.ones_like(coef2).mean(axis=-1)\\n\\n if positive:\\n theta2 *= 0.\\n thetabar2 *= 0.\\n theta = theta1\\n a = n_samples * alpha * gamma\\n beta1 = n_samples * beta1\\n beta2 = n_samples * beta2\\n\\n if concomitant:\\n sigma0 = 0.01 * np.linalg.norm(y, axis=1).min() / (n_samples ** 0.5)\\n else:\\n sigma0 = 0.\\n with Parallel(n_jobs=n_jobs, backend=\\\"threading\\\") as pll:\\n if alpha == 0.:\\n theta, R, sigmas, mx = update_coefs(pll, Xf, y, theta, R,\\n Ls, marginals1,\\n sigmas, a, beta1,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd,\\n positive=positive)\\n obj = 0.5 * (R ** 2).sum(axis=1).dot(1 / sigmas) / n_samples\\n obj += beta1 * abs(theta).sum() + 0.5 * sigmas.sum()\\n theta1, theta2 = utils.get_unsigned(theta)\\n log['loss'].append(obj)\\n else:\\n for i in range(max_iter):\\n obj = 0.\\n if not positive:\\n Y1 = utils.residual(Xf, - theta2, y)\\n else:\\n Y1 = y\\n theta1, R, sigmas, mxp = update_coefs(pll, Xf, Y1, theta1, R,\\n Ls,\\n marginals1,\\n sigmas,\\n a, beta1,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd)\\n if not positive:\\n Y2 = utils.residual(Xf, theta1, y)\\n theta2, R, sigmas, mx = update_coefs(pll, mXf, Y2, theta2,\\n R,\\n Ls,\\n marginals2,\\n sigmas,\\n a, beta2,\\n sigma0,\\n tol=tol_cd,\\n max_iter=max_iter_cd)\\n theta = theta1 - theta2\\n else:\\n theta = theta1\\n\\n dx = abs(theta - thetaold) / max(1, thetaold.max(),\\n theta.max())\\n dx = dx.max()\\n thetaold = theta.copy()\\n if alpha:\\n if (theta1 > ot_threshold).any(0).all():\\n fot1, log_ot1, marginals1, b1, q1 = \\\\\\n update_ot_1(theta1, M, epsilon, gamma,\\n b=b1, tol=tol_ot,\\n max_iter=max_iter_ot,\\n threshold=ot_threshold)\\n if fot1 is None or not theta1.max(0).all():\\n warnings.warn(\\\"Numerical errors. Moving in \\\"\\n \\\"log-domain.\\\")\\n b1 = xp.log(b1 + 1e-100, out=b1)\\n stable = True\\n update_ot_1 = set_ot_func(True, ot_img)\\n fot1, log_ot1, marginals1, b1, q1 = \\\\\\n update_ot_1(theta1, M, epsilon, gamma, b=b1,\\n tol=tol_ot, max_iter=max_iter_ot,\\n threshold=ot_threshold)\\n\\n log[\\\"log_sinkhorn1\\\"].append(log_ot1)\\n thetabar1 = q1\\n log[\\\"fot1\\\"].append(fot1)\\n obj += alpha * fot1\\n if not positive and (theta2 > ot_threshold).any(0).all():\\n fot2, log_ot2, marginals2, b2, q2 = \\\\\\n update_ot_2(theta2, M, epsilon, gamma,\\n b=b2, tol=tol_ot, max_iter=max_iter_ot)\\n\\n if fot2 is None or not theta2.max(0).all():\\n warnings.warn(\\\"Numerical errors. Moving in \\\"\\n \\\"log-domain.\\\")\\n b2 = xp.log(b2 + 1e-100, out=b2)\\n stable = True\\n update_ot_2 = set_ot_func(True, ot_img)\\n fot2, log_ot2, marginals2, b2, q2 = \\\\\\n update_ot_2(theta2, M, epsilon, gamma,\\n b=b2, tol=tol_ot,\\n max_iter=max_iter_ot)\\n\\n log[\\\"log_sinkhorn2\\\"].append(log_ot2)\\n thetabar2 = q2\\n log[\\\"fot2\\\"].append(fot2)\\n obj += alpha * fot2\\n\\n log['loss'].append(obj)\\n log['dloss'].append(dx)\\n\\n if dx < tol:\\n break\\n if i == max_iter - 1:\\n warnings.warn('Objective did not converge.' +\\n ' You might want' +\\n ' to increase the number of iterations.' +\\n ' Fitting data with very small alpha and' +\\n ' beta may cause precision problems.',\\n ConvergenceWarning)\\n log['stable'] = stable\\n\\n if positive:\\n theta2 *= 0.\\n thetabar2 = xp.zeros_like(thetabar1)\\n try:\\n thetabar2 = thetabar2.get()\\n except AttributeError:\\n pass\\n return (theta1, theta2, thetabar1, thetabar2, log, sigmas, b1, b2, R)\",\n \"def example():\\n Optimizer = BFGS(f, g)\\n startPoint = 100 * numpy.ones(2);\\n res = Optimizer.optimize(startPoint,\\n epsilon=1e-5,\\n maxIterations=10)\\n print res\\n pass\",\n \"def run_qae_optimization(training_states, n_repetitions, exact=no_noise, noisy=gate_error):\\n result_list = []\\n def proxy(params, training_states, n_repetitions, exact=no_noise, noisy=gate_error):\\n \\\"\\\"\\\"Embedded function version\\n \\\"\\\"\\\"\\n input_list = fix_list(params, all_param_array=all_param, var_param_array=var_param, fixed_vals_array=fixed_vals)\\n fidelities = []\\n for training_state in training_states:\\n fid = cusp_stage2.compute_stage2_cost_function(*input_list, alpha=training_state, n_repetitions=n_repetitions,\\n exact=exact, noisy=noisy)\\n fidelities.append(fid)\\n avg_fid = np.mean(fidelities)\\n result_list.append(1-avg_fid)\\n print(1-avg_fid)\\n return 1. - avg_fid\\n\\n \\n # Initialize parameters\\n half_turn_min = 0\\n half_turn_max = 2\\n init_params = np.random.uniform(low=half_turn_min, high=half_turn_max,\\n size=num_param)\\n\\n # Optimization using Nelder-Mead.\\n h2_qae_wrap = lambda params: proxy(params, training_states=training_states,\\n n_repetitions=n_repetitions, exact=exact, noisy=noisy)\\n \\n if noisy:\\n maxiter = 60\\n else:\\n maxiter = None\\n \\n res = minimize(h2_qae_wrap, init_params, args=(),\\n method='Nelder-Mead', tol=None, \\n options={'disp': False, 'maxiter': maxiter, 'xatol': 0.001,\\n 'return_all': False, 'fatol': 0.001})\\n np.savetxt('stage2_data.csv',result_list, delimiter=',')\\n return res.x\",\n \"def step(self, closure=None):\\n orig_loss,err,pred = closure()\\n loss = orig_loss\\n\\n group = self.param_groups[0]\\n lr = group['lr']\\n decay_lr = group['decay_lr']\\n max_iter = group['max_iter']\\n reg = group['reg']\\n backtrack = group['backtrack']\\n bt_alpha = group['bt_alpha']\\n bt_beta = group['bt_beta']\\n sketch_size = group['sketch_size']\\n tolerance = group['tolerance']\\n\\n #import pdb; pdb.set_trace()\\n n = err.shape[0] #batch size\\n #If sketching the jacobian, randomly select [sketch_size] samples\\n \\n if sketch_size is not None:\\n idx = torch.randperm(n)[:sketch_size]\\n else:\\n idx = torch.arange(n) #Don't sketch, use all samples\\n \\n w0 = nn.utils.parameters_to_vector(self._params) #weight parameters in vector form\\n \\n #Compute Gauss-Newton vector product \\n grad, ggnvp = _make_ggnvp(err,self._params,w0,n,reg,idx) #return gradient in vector form + ggnvp function\\n #Solve for the Conjugate Gradient Direction\\n dw, cost_log = _conjugate_gradient(ggnvp, grad, max_iter, tolerance)\\n\\n #Perform backtracking line search\\n val = loss + 0.5 * reg * torch.norm(w0)**2\\n fprime = -1*dw @ grad\\n \\n self.grad_update += 1\\n if backtrack > 0:\\n t = lr\\n\\n #TODO: If using backtracking, get new loss with (w0 - t*dw) as network parameters\\n bts = 0\\n alpha = bt_alpha\\n beta = bt_beta \\n while (loss + 0.5 * reg * torch.norm(w0 - t*dw)**2 > val + alpha * t * fprime):\\n t = beta * t\\n bts += 1\\n if bts > backtrack:\\n print('Maximum backtracking reached, accuracy not guaranteed')\\n break\\n elif decay_lr: #decay lr\\n t = lr/np.maximum(1, self.grad_update-10)\\n else: #use lr step-size\\n t = lr\\n\\n print('step size: {}'.format(t))\\n\\n #Update the model parameters\\n self._add_grad(-t, dw)\\n \\n return val, pred\",\n \"def run(self, n_trials=10):\\n # Create study object\\n if self.study is None:\\n self.study = optuna.create_study(\\n direction=\\\"minimize\\\",\\n sampler=optuna.samplers.RandomSampler(seed=123)\\n )\\n # Run trials\\n self.study.optimize(\\n lambda x: self.objective(x),\\n n_trials=n_trials,\\n n_jobs=-1\\n )\",\n \"def _optimize(self):\\n # Retrieve all trainable variables\\n train_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\\n\\n # Compute the gradient (return a pair of variable and their respective gradient)\\n grads = self.optimizer.compute_gradients(loss=self.loss, var_list=train_variables)\\n self.train_dis = self.optimizer.apply_gradients(grads, global_step=self.global_step)\",\n \"def optimize(self,s,max_steps,td_n):\\r\\n \\r\\n s1, d1, a1, r1, s2, done = self.ram.sample(self.batch_size)\\r\\n s1 = torch.from_numpy(s1).float()\\r\\n #print(s1.shape)\\r\\n d1 = torch.from_numpy(d1).float()\\r\\n d1 = d1.unsqueeze(1)\\r\\n d1.requires_grad = True\\r\\n d1_copy = d1.detach().cpu().numpy()\\r\\n self.mse_logic.append(d1_copy[-1][-1])\\r\\n a1 = torch.from_numpy(a1).float()\\r\\n #print(a1.shape)\\r\\n r1 = torch.from_numpy(r1).float()\\r\\n r1 = torch.squeeze(r1)\\r\\n #print(r1.size())\\r\\n s2 = torch.from_numpy(s2).float()\\r\\n done = torch.from_numpy(done).float()\\r\\n self.t = s\\r\\n self.T = max_steps\\r\\n self.td_n = td_n\\r\\n self.td_tau = self.t-self.td_n+1\\r\\n if self.td_tau >= 0:\\r\\n for i in range(self.td_tau+1, min(self.td_tau+self.td_n, self.T)):\\r\\n self.G = self.gamma**(i-self.td_tau-1)*(r1)\\r\\n if self.td_tau+self.td_n < self.T:\\r\\n #-----------optimize critic -----------------------------------\\r\\n a2 = self.target_actor.forward(s2).detach()\\r\\n noise = a1.data.normal_(0,0.2)\\r\\n noise = noise.clamp(-0.5,0.5)\\r\\n a2 = (a2+noise).clamp(-1,1)\\r\\n next_val = torch.squeeze(self.target_critic.forward(s2,a2).detach())\\r\\n y_expected = self.G + self.gamma**(self.td_n)*next_val*(1-done)\\r\\n y_predicted = torch.squeeze(self.critic.forward(s1, a1))\\r\\n # compute critic loss, and update the critic\\r\\n loss_critic = self.l_loss(y_predicted, y_expected.detach()).unsqueeze(0)\\r\\n self.critic_optimizer.zero_grad()\\r\\n loss_critic.backward()\\r\\n self.critic_optimizer.step()\\r\\n \\r\\n #-----------optimize actor --------------------------------------\\r\\n pred_a1 = self.actor.forward(s1)\\r\\n pred_a1_copy = pred_a1.detach().numpy()\\r\\n self.actor_logic.append(pred_a1_copy[-1][-1])\\r\\n loss_actor = -self.critic.forward(s1, pred_a1).mean()\\r\\n #entropy = torch.mean(pred_a1*torch.log(pred_a1))\\r\\n loss_policy = loss_actor\\r\\n self.loss_l1_list.append(loss_policy.item())\\r\\n mse_policy = self.target_critic(s1,d1).mean()\\r\\n loss_mse = self.mse(loss_actor, mse_policy)\\r\\n self.loss_mse_list.append(loss_mse.item())\\r\\n loss = sum([(1-self.lambda_mse)*loss_policy, self.lambda_mse*loss_mse])\\r\\n self.loss_final_list.append(loss.item())\\r\\n self.actor_optimizer.zero_grad()\\r\\n loss.backward()\\r\\n self.actor_optimizer.step()\\r\\n \\r\\n soft_update(self.target_actor, self.actor, self.tau)\\r\\n soft_update(self.target_critic, self.critic, self.tau)\\r\\n \\r\\n #self.actor.state_dict(self.target_actor.state_dict())\\r\\n #self.critic.state_dict(self.target_critic.state_dict())\\r\",\n \"def least_squares_GD(y, tx, initial_w, max_iters, gamma):\\n # Define parameters to store w and loss\\n w = initial_w\\n for n_iter in range(max_iters):\\n # compute gradient\\n grad = compute_gradient(y, tx, w)\\n # gradient w by descent update\\n if n_iter % (max_iters//10) == 0:\\n print(compute_cost(y, tx, w))\\n w -= gamma * grad\\n\\n return w, compute_cost(y, tx, w)\",\n \"def test_gradient_step(var_f, len_f, var_y, N):\\n\\n x, y = build_data(N)\\n\\n gp_model = initialise_gp_model(var_f, len_f, var_y, x, y)\\n markovgp_model = initialise_markovgp_model(var_f, len_f, var_y, x, y)\\n\\n gv = objax.GradValues(gp_model.energy, gp_model.vars())\\n gv_markov = objax.GradValues(markovgp_model.energy, markovgp_model.vars())\\n\\n lr_adam = 0.1\\n lr_newton = 1.\\n opt = objax.optimizer.Adam(gp_model.vars())\\n opt_markov = objax.optimizer.Adam(markovgp_model.vars())\\n\\n gp_model.update_posterior()\\n gp_grads, gp_value = gv()\\n gp_loss_ = gp_value[0]\\n opt(lr_adam, gp_grads)\\n gp_hypers = np.array([gp_model.kernel.lengthscale, gp_model.kernel.variance, gp_model.likelihood.variance])\\n print(gp_hypers)\\n print(gp_grads)\\n\\n markovgp_model.update_posterior()\\n markovgp_grads, markovgp_value = gv_markov()\\n markovgp_loss_ = markovgp_value[0]\\n opt_markov(lr_adam, markovgp_grads)\\n markovgp_hypers = np.array([markovgp_model.kernel.lengthscale, markovgp_model.kernel.variance,\\n markovgp_model.likelihood.variance])\\n print(markovgp_hypers)\\n print(markovgp_grads)\\n\\n np.testing.assert_allclose(gp_grads[0], markovgp_grads[0], rtol=1e-4)\\n np.testing.assert_allclose(gp_grads[1], markovgp_grads[1], rtol=1e-4)\\n np.testing.assert_allclose(gp_grads[2], markovgp_grads[2], rtol=1e-4)\",\n \"def optimize(self):\\n\\n self.logger.info(\\\"Solving with Dynamic Slope Scaling Procedure in Julia :\\\")\\n optimization_start = time.time()\\n\\n # 1. Preprocess for old network graph\\n if self.old_network_graph is not None:\\n\\n # DSSP on old network\\n old_network_obj = sum(list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values()))-1e-5\\n try:\\n self.check_infeasibility(self.old_network_graph, old_network_obj)\\n except DHCOptimizerException as e:\\n e.data = \\\"Invalid existing network: \\\" + e.data\\n raise e\\n\\n flows, obj_val = self.optimize_with_dssp_julia(self.old_network_graph, old_network_obj, set())\\n self.logger.info(\\\"Optimization phase time: %.2fs\\\" % (time.time() - optimization_start))\\n solution_old_graph = self.build_solution_graph(self.old_network_graph, flows)\\n\\n if self.modify_old_network:\\n\\n # Add max capacity on old edges\\n self.old_capacity = deepcopy(flows)\\n old_buildings = list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values())\\n for key in flows:\\n if (key[1],key[0],0) not in self.old_capacity and key[1] not in old_buildings:\\n self.old_capacity[(key[1],key[0],0)] = self.old_capacity[key]\\n\\n # Add Imaginary edges\\n for edge in self.old_capacity:\\n if self.optimization_graph.has_edge(*edge):\\n\\n # add nodes\\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[0]):\\n self.optimization_graph.add_node(config.IM_PREFIX+edge[0])\\n self.optimization_graph.nodes[config.IM_PREFIX+edge[0]][config.GPD_GEO_KEY] = \\\\\\n self.optimization_graph.nodes[edge[0]][config.GPD_GEO_KEY]\\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[1]):\\n self.optimization_graph.add_node(config.IM_PREFIX+edge[1])\\n self.optimization_graph.nodes[config.IM_PREFIX+edge[1]][config.GPD_GEO_KEY] = \\\\\\n self.optimization_graph.nodes[edge[1]][config.GPD_GEO_KEY]\\n # add edges\\n if not self.optimization_graph.has_edge(edge[0],config.IM_PREFIX+edge[0]):\\n self.optimization_graph.add_edge(edge[0],config.IM_PREFIX+edge[0])\\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1]):\\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1])\\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[1],edge[1]):\\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[1],edge[1])\\n\\n # put cost\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY] = \\\\\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY]\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\\n self.optimization_graph.edges[(edge[0],config.IM_PREFIX+edge[0],0)][config.EDGE_COST_KEY] = 1e-5\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[1],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\\n\\n else:\\n # if we don't modify the old network, we have to change the capacity of the supplies\\n already_consummed = {}\\n for edge in solution_old_graph.edges():\\n if solution_old_graph.nodes[edge[0]].get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\\n already_consummed[edge[0]] = already_consummed.get(edge[0], 0) + \\\\\\n solution_old_graph.edges[edge][config.SOLUTION_POWER_FLOW_KEY]\\n for source in already_consummed:\\n if already_consummed[source] <= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]:\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] -= already_consummed[source]\\n self.network_objective -= already_consummed[source]\\n else:\\n self.network_objective -= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] = 0\\n\\n # Remove edges from old network\\n edges_to_remove = set()\\n for e in self.optimization_graph.edges():\\n if self.old_network_graph.has_edge(*e) or self.old_network_graph.has_edge(e[1],e[0]):\\n edges_to_remove.add(e)\\n self.optimization_graph.remove_edges_from(edges_to_remove)\\n\\n # Remove isolated buildings of optimization graph\\n isolated_to_remove = set()\\n for e in self.old_network_graph.edges():\\n if e[0] in self.old_network_graph.nodes() and \\\\\\n self.optimization_graph.nodes[e[1]].get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\\n isolated_to_remove.add(e)\\n self.optimization_graph.remove_edges_from(isolated_to_remove)\\n\\n # Remove buildings from old network\\n for n, data in self.old_network_graph.nodes(data=True):\\n if data.get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\\n self.optimization_graph.remove_node(n)\\n\\n # Re-link sources\\n sources = set()\\n for n, data in self.optimization_graph.nodes(data=True):\\n if data.get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\\n sources.add(n)\\n source_graph = self.optimization_graph.subgraph(sources).copy()\\n self.optimization_graph.remove_nodes_from(sources)\\n gnx.remove_isolates(self.optimization_graph)\\n node_filter = lambda n: self.optimization_graph.nodes.get(n,{}).get(config.NODE_TYPE_KEY) != config.BUILDING_NODE_TYPE\\n gnx.spatial_points_merge(self.optimization_graph, source_graph.nodes_to_gdf(), node_filter=node_filter, inplace=True)\\n\\n # fill missing information\\n gnx.fill_edges_missing_geometry_attributes(self.optimization_graph)\\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_LENGTH_KEY, only_missing=True)\\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_COST_KEY, only_missing=True)\\n for e in self.optimization_graph.edges(keys=True):\\n self.optimization_graph.edges[e][config.LEASTCOST_COEF_KEY] = \\\\\\n self.optimization_graph.edges[e].get(config.LEASTCOST_COEF_KEY,0)\\n\\n\\n\\n # 2. Process the DSSP on optimization graph\\n self.check_is_ready()\\n self.check_infeasibility(self.optimization_graph, self.network_objective)\\n\\n if self.old_network_graph is not None and self.modify_old_network:\\n old_buildings = set(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).keys())\\n else:\\n old_buildings = set()\\n flows, obj_val = self.optimize_with_dssp_julia(self.optimization_graph, self.network_objective, old_buildings,postprocess= (not self.modify_old_network))\\n self.logger.info(\\\"Optimization phase time: %.2fs\\\" % (time.time() - optimization_start))\\n self.solution_graph = self.build_solution_graph(self.optimization_graph, flows, self.connected)\\n\\n # 3. Postprocess for old network graph\\n if self.old_network_graph is not None:\\n \\n if self.modify_old_network:\\n # Put the right supply capacity and cost\\n for edge in self.old_capacity:\\n if self.solution_graph.has_edge(edge[0],edge[1]):\\n self.solution_graph.edges[(edge[0],edge[1])][config.EDGE_COST_KEY] = \\\\\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY]\\n \\n # Remove imaginary edges\\n imaginary_nodes_to_remove = set()\\n nodes_to_relabel = {}\\n for edge in self.solution_graph.edges():\\n if str(edge[0]).startswith(config.IM_PREFIX) and str(edge[1]).startswith(config.IM_PREFIX):\\n real_edge = edge[0][len(config.IM_PREFIX):],edge[1][len(config.IM_PREFIX):]\\n self.old_capacity[(real_edge[0], real_edge[1], 0)] = pd.np.inf\\n self.old_capacity[(real_edge[1], real_edge[0], 0)] = pd.np.inf\\n if not self.solution_graph.has_edge(*real_edge):\\n for i in range(2):\\n nodes_to_relabel[edge[i]] = real_edge[i]\\n else:\\n self.solution_graph.edges[real_edge[0],real_edge[1]][config.SOLUTION_POWER_FLOW_KEY] += \\\\\\n self.solution_graph.edges[edge].get(config.SOLUTION_POWER_FLOW_KEY,0)\\n imaginary_nodes_to_remove.add(edge[0])\\n imaginary_nodes_to_remove.add(edge[1])\\n elif str(edge[0]).startswith(config.IM_PREFIX):\\n imaginary_nodes_to_remove.add(edge[0])\\n elif str(edge[1]).startswith(config.IM_PREFIX):\\n imaginary_nodes_to_remove.add(edge[1])\\n\\n nx.relabel_nodes(self.solution_graph, nodes_to_relabel, copy=False)\\n self.solution_graph.remove_nodes_from(list(imaginary_nodes_to_remove))\\n for node in nodes_to_relabel.values():\\n if self.solution_graph.has_edge(node, node):\\n self.solution_graph.remove_edge(node, node)\\n\\n else:\\n for source in nx.get_node_attributes(self.solution_graph, config.SUPPLY_POWER_CAPACITY_KEY):\\n self.solution_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\\n\\n return flows, obj_val\",\n \"def optimize(w, b, x, y, num_iterations, learning_rate, print_cost=False):\\n\\n costs = []\\n\\n for i in range(num_iterations):\\n\\n # Cost and gradient calculation\\n grads, cost = propagate(w, b, x, y)\\n\\n # Retrieve derivatives from grads\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n\\n # Update rule\\n w = w - (dw * learning_rate)\\n b = b - (db * learning_rate)\\n\\n # Record the costs\\n if i % 100 == 0:\\n costs.append(cost)\\n\\n # Print the cost every 100 training iterations\\n if print_cost and i % 100 == 0:\\n print(\\\"Cost after iteration %i: %f\\\" % (i, cost))\\n\\n params = {\\\"w\\\": w,\\n \\\"b\\\": b}\\n\\n grads = {\\\"dw\\\": dw,\\n \\\"db\\\": db}\\n\\n return params, grads, costs\",\n \"def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\\n costs = []\\n for i in range(num_iterations):\\n # Cost and gradient calculation \\n grads, cost = propagate(w, b, X, Y)\\n # Retrieve derivatives from grads\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n # update rule (≈ 2 lines of code)\\n w = w-learning_rate*dw\\n b = b-learning_rate*db\\n # Record the costs\\n if i % 100 == 0:\\n costs.append(cost)\\n # Print the cost every 100 training examples\\n if print_cost and i % 100 == 0:\\n print (\\\"Cost after iteration %i: %f\\\" %(i, cost))\\n params = {\\\"w\\\": w,\\n \\\"b\\\": b}\\n grads = {\\\"dw\\\": dw,\\n \\\"db\\\": db}\\n return params, grads, costs\",\n \"def sgd_optimization(dataset, learning_rate, n_epochs, batch_size):\\n datasets = load_data(dataset)\\n train_set_x, train_set_y = datasets[0]\\n valid_set_x, valid_set_y = datasets[1]\\n test_set_x, test_set_y = datasets[2]\\n\\n #number of minibatches\\n n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size\\n n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] / batch_size\\n n_test_batches = test_set_x.get_value(borrow=True).shape[0] / batch_size\\n\\n #build the model\\n print \\\"... building the model\\\"\\n\\n index = T.lscalar()\\n x = T.matrix('x') #data for the rasterized images\\n y = T.ivector('y') # labels (int)\\n\\n # logistic regression Class\\n classifierLR = LogisticRegression(input=x, n_in=28*28, n_out=10)\\n cost = classifierLR.negative_log_likelihood(y)\\n\\n # test model (no updates)\\n test_model = theano.function(\\n inputs=[index],\\n outputs=classifierLR.errors(y),\\n givens={\\n x: test_set_x[index * batch_size: (index + 1) * batch_size],\\n y: test_set_y[index * batch_size: (index + 1) * batch_size]\\n }\\n )\\n\\n #validate model (no updates)\\n validate_model = theano.function(\\n inputs=[index],\\n outputs=classifierLR.errors(y),\\n givens={\\n x: valid_set_x[index * batch_size: (index + 1) * batch_size],\\n y: valid_set_y[index * batch_size: (index + 1) * batch_size]\\n }\\n )\\n\\n #compute the gradient of cost wrt W, b\\n g_W = T.grad(cost=cost, wrt=classifierLR.W)\\n g_b = T.grad(cost=cost, wrt=classifierLR.b)\\n\\n #updating expression\\n updates = [(classifierLR.W, classifierLR.W - learning_rate * g_W),\\n (classifierLR.b, classifierLR.b - learning_rate * g_b)]\\n\\n # Train model (theano function); updates\\n train_model = theano.function(\\n inputs=[index],\\n outputs=cost,\\n updates=updates,\\n givens={\\n x: train_set_x[index * batch_size: (index + 1) * batch_size],\\n y: train_set_y[index * batch_size: (index + 1) * batch_size]\\n\\n }\\n )\\n\\n # Training model (early stopping with validation examples)\\n print \\\"... training the model\\\"\\n patience = 5000\\n patience_inc = 2 # wait this much\\n improved_threshold = 0.995 # relative improvement (significant)\\n validation_frequency = min(n_train_batches, patience / 2)\\n best_validation_loss = numpy.inf\\n test_score = 0.\\n start_time = timeit.default_timer()\\n\\n done_looping = False\\n epoch = 0\\n while (epoch < n_epochs) and (not done_looping):\\n epoch += 1\\n for minibatch_index in xrange(n_train_batches):\\n minibatch_avg_cost = train_model(minibatch_index)\\n iter = (epoch - 1) * n_train_batches + minibatch_index\\n\\n if (iter + 1) % validation_frequency == 0:\\n # compute loss on validation set\\n validation_losses = [validate_model(i) for i in xrange(n_valid_batches)]\\n this_validation_loss = numpy.mean(validation_losses)\\n\\n print(\\n \\\"Epoch: %i, minibatch: %i/%i, validation_error: %f %%\\\" %\\n (\\n epoch,\\n minibatch_index + 1,\\n n_train_batches,\\n this_validation_loss * 100.\\n )\\n )\\n\\n if this_validation_loss < best_validation_loss:\\n #improve patience if good improvement\\n if this_validation_loss < best_validation_loss * improved_threshold:\\n patience = max(patience, iter * patience_inc)\\n\\n best_validation_loss = this_validation_loss\\n\\n #testing on test_set\\n test_losses = [test_model(i) for i in xrange(n_test_batches)]\\n test_score = numpy.mean(test_losses)\\n\\n print(\\n (\\n \\\"Epoch : %i, minibatch %i/%i,\\\"\\n \\\" test error of best model %f %%\\\"\\n ) % (\\n epoch,\\n minibatch_index,\\n n_train_batches,\\n test_score * 100.\\n )\\n )\\n\\n #save the best model\\n print \\\"New best model found; saving ...\\\"\\n with open('best_model.pkl', \\\"w\\\") as f:\\n cPickle.dump(classifierLR, f)\\n\\n if patience <= iter:\\n done_looping = True\\n break\\n\\n\\n end_time = timeit.default_timer()\\n print(\\n (\\n \\\"Optimization Complete: best validation score : %f %%,\\\"\\n \\\" test performance : %f %%\\\"\\n )\\n % (best_validation_loss * 100., test_score * 100.)\\n )\\n print \\\"The code run for %d epochs, with %f epochs/sec\\\" %(epoch, 1. * epoch / (end_time - start_time))\\n print >> sys.stderr, (\\\"The code for file \\\" + os.path.split(__file__)[1] + \\\" ran for %.1fs\\\" % ((end_time - start_time)))\",\n \"def _optimize(optimizer, regularization_losses, scope, **kwargs):\\n sum_loss = _gather_loss(regularization_losses, scope)\\n grad = None\\n if sum_loss is not None:\\n grad = optimizer.compute_gradients(sum_loss, **kwargs)\\n return sum_loss, grad\",\n \"def run(self):\\n\\n # Initializing required variables for the algorithm\\n start = time.time()\\n i = 0\\n w = self.w\\n k = 99.99\\n\\n #Running the algorithm till tolerance is reached\\n while k > self.tolerance: \\n\\n i = i + 1\\n\\n if self.verbose:\\n print(\\\"Iteration \\\" + str(i),end=\\\"\\\\r\\\")\\n\\n # Following is a gradient descent algorithm\\n # You can find the update step at the following\\n # link, https://raw.githubusercontent.com/mnk400/linearRegression/master/img/EUC.png\\n t_0 = w.T.dot(w)\\n t_1 = self.x.T.dot(self.x).dot(w)\\n gradient = (2/t_0) * (t_1) - (2/t_0**2) * np.transpose(w).dot(t_1) * (w)\\n w_new = w - (1/self.DATAPOINTS) * 0.3 * gradient\\n w_new[-1] = -1\\n l = len(self.x[0]) - 1 \\n y_plt = np.dot(self.x[:,0:l],w_new[:-1]) \\n\\n #tolerance is checked against the root mean square of change in weights\\n k = np.dot(np.transpose(w - w_new),(w - w_new))\\n\\n #Updating the weights \\n w = w_new\\n\\n if self.verbose:\\n print(\\\"Tolerance Reached\\\")\\n timetaken = round(time.time() - start, 3)\\n print(\\\"Ran for \\\" + str(timetaken) + \\\" seconds\\\" + \\\" in \\\" + str(i) + \\\" iterations.\\\")\\n\\n return w_new, y_plt\",\n \"def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\\n\\n costs = []\\n\\n for i in range(num_iterations):\\n\\n grads, cost = propagate(w, b, X, Y)\\n\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n\\n w = w - learning_rate * dw\\n b = b - learning_rate * db\\n\\n if i % 100 == 0:\\n costs.append(cost)\\n\\n # Print the cost every 100 training iterations\\n if print_cost and i % 100 == 0:\\n print (\\\"Cost after iteration %i: %f\\\" %(i, cost))\\n\\n params = {\\\"w\\\": w,\\n \\\"b\\\": b}\\n\\n grads = {\\\"dw\\\": dw,\\n \\\"db\\\": db}\\n\\n return params, grads, costs\",\n \"def optimize(self, iterations=1000):\\r\\n prev = None\\r\\n finalx = None\\r\\n finaly = None\\r\\n while iterations:\\r\\n maxei, eis = self.acquisition()\\r\\n new_y = self.f(maxei)\\r\\n if maxei == prev:\\r\\n break\\r\\n self.gp.update(maxei, new_y)\\r\\n pycodehack = finaly is None or self.minimize and finaly > new_y\\r\\n if ((pycodehack or not self.minimize and finaly < new_y)):\\r\\n finaly = new_y\\r\\n finalx = maxei\\r\\n prev = maxei\\r\\n iterations -= 1\\r\\n return finalx, finaly\",\n \"def least_squares_GD(y, tx, initial_w, max_iters, gamma, debug = False):\\n losses, ws = gradient_descent(y, tx, initial_w, max_iters, gamma, loss_f = model_linear.compute_loss, grad_f = model_linear.compute_gradient, debug = debug)\\n return get_last_ans(ws, losses)\",\n \"def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost=False):\\n costs = []\\n\\n for i in range(num_iterations):\\n\\n grads, cost = propagate(w, b, X, Y)\\n\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n\\n w = w - learning_rate * dw\\n b = b - learning_rate * db\\n\\n # Record the costs\\n if i % 100 == 0:\\n costs.append(cost)\\n\\n # Print the cost every 100 training examples\\n if print_cost and i % 100 == 0:\\n print(\\\"Cost after iteration %i: %f\\\" % (i, cost))\\n\\n params = {\\\"w\\\": w,\\n \\\"b\\\": b}\\n\\n grads = {\\\"dw\\\": dw,\\n \\\"db\\\": db}\\n\\n return params, grads, costs\",\n \"def test_grad_computations(self, samples, training_points):\\n \\n self.add_p_tilda(training = False)\\n \\n do_updates = OrderedDict()\\n \\n self.b.set_value(self.b_init)\\n \\n self.W.set_value(self.W_init)\\n \\n gradW = theano.shared(np.zeros([self.num_vars,self.num_vars]))\\n \\n gradb = theano.shared(np.zeros([self.num_vars]))\\n \\n [gradW, gradb], updates =\\\\\\n theano.scan(lambda i, gradW, gradb: [gradW+ \\\\\\n (1.0-self.batch_size*self.p_tilda[i])\\\\\\n *self.xn_xn_prod(self.x[i,:]),\\n gradb+ \\\\\\n (1.0-self.batch_size*self.p_tilda[i])\\\\\\n *self.x[i,:]],\\n outputs_info =[gradW, gradb],\\n sequences =[T.arange(self.batch_size)])\\n \\n gradW = gradW[-1]\\n \\n gradb = gradb[-1]\\n \\n do_updates.update(updates)\\n \\n [gradW, gradb], updates = \\\\\\n theano.scan(lambda i, gradW, gradb: [gradW - \\\\\\n self.batch_size*self.p_tilda[self.batch_size+i]*\\\\\\n self.xn_xn_prod(self.x_tilda[i,:]),\\n gradb-self.batch_size*self.p_tilda[self.batch_size+i]*\\\\\\n self.x_tilda[i,:]],\\n outputs_info =[gradW, gradb],\\n sequences =[T.arange(self.num_samples)])\\n \\n gradW = gradW[-1] /self.batch_size\\n \\n gradb = gradb[-1] /self.batch_size\\n \\n gradW = gradW - T.diag(T.diag(gradW)) # no recurrent connections\\n \\n do_updates.update(updates)\\n \\n ## ML objective log likelihood (ascend gradient)\\n ## the first, more efficient implementation uses the cost\\n ## objective which is negative of the log likelihood.\\n \\n do_updates.update([(self.W, self.W + self.learning_rate*gradW)])\\n \\n do_updates.update([(self.b, self.b + self.learning_rate*gradb)])\\n \\n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\\n \\n var_list = [self.x_tilda, self.minibatch_set, self.learning_rate]\\n \\n test_grads = theano.function(inputs = var_list,\\n outputs= [],\\n updates= do_updates,\\n givens = input_dict,\\n on_unused_input='warn')\\n \\n test_grads(samples, training_points)\",\n \"def maximize(self, budget, optimizer):\\n\\n\\t\\tpass\",\n \"def perform_bayesian_optimization(self):\\n bounds = {'hunits': (self.hunits_lower, self.hunits_upper),\\n 'embedding_dim': (self.embedding_dim_lower, self.embedding_dim_upper)}\\n optimizer = BayesianOptimization(f=self.lstm_score, pbounds=bounds, random_state=1)\\n optimizer.maximize(init_points=2, n_iter=self.iterations)\\n print(optimizer.max)\\n print(optimizer.res)\",\n \"def run_step_blackbox_optimizer(config,\\n current_input,\\n blackbox_optimizer,\\n proposed_perturbations,\\n finished_dnas,\\n results,\\n logging_data=None):\\n core_hyperparameters = blackbox_optimizer.get_hyperparameters()\\n function_values = [0.0] * len(proposed_perturbations)\\n rewards_for_controller = []\\n perturbations = proposed_perturbations\\n evaluation_stats = []\\n current_value_exact = 0.0\\n current_value_exact_counter = 0\\n\\n for i in range(len(results)):\\n rewards_for_controller.append(results[i]['function_value'])\\n tag = results[i]['tag']\\n index = 0\\n if tag > 0:\\n if config.est_type == 'antithetic':\\n index = (tag - 1) * 2\\n function_values[index] += results[i]['function_value']\\n else:\\n index = tag - 1\\n function_values[index] += results[i]['function_value']\\n if tag < 0:\\n index = (-tag - 1) * 2 + 1\\n function_values[index] += results[i]['function_value']\\n if tag == 0:\\n current_value_exact += results[i]['function_value']\\n current_value_exact_counter += 1\\n current_value_exact /= float(current_value_exact_counter)\\n\\n for result in results:\\n evaluation_stat = list(result['evaluation_stat'])\\n evaluation_stats.append(evaluation_stat)\\n\\n function_values_reshaped = np.array(function_values)\\n perturbations_reshaped = np.array(perturbations)\\n\\n logging.info('LIST OF FUNCTION VALUES')\\n logging.info(function_values_reshaped)\\n\\n logging.info('MAX VALUE SEEN CURRENTLY')\\n logging.info(np.max(function_values_reshaped))\\n\\n logging.info('MEAN OF VALUES')\\n logging.info(np.mean(function_values_reshaped))\\n\\n if logging_data is not None:\\n iteration = logging_data['iteration']\\n best_value = logging_data['best_value']\\n iteration = logging_data['iteration']\\n best_input = logging_data['best_input']\\n best_core_hyperparameters = logging_data['best_core_hyperparameters']\\n optimizer_state = blackbox_optimizer.get_state()\\n\\n if current_value_exact > best_value[0]:\\n best_value[0] = current_value_exact\\n best_input = current_input\\n best_core_hyperparameters = core_hyperparameters\\n\\n # Writing logs.\\n if iteration % config.log_frequency == 0:\\n util.log_row(config.params_file, current_input)\\n util.log_row(config.best_params_file, best_input)\\n util.log_row(config.best_core_hyperparameters_file,\\n best_core_hyperparameters)\\n util.log_row(config.best_value_file, best_value)\\n util.log_row(config.optimizer_internal_state_file, optimizer_state)\\n util.log_row(config.current_values_list_file, [current_value_exact])\\n util.log_row(config.best_values_list_file, [best_value[0]])\\n util.log_row(config.fvalues_file, function_values_reshaped)\\n util.log_row(config.iteration_file, [iteration])\\n\\n print('Current exact value estimate:')\\n print(current_value_exact)\\n sys.stdout.flush()\\n\\n new_current_input = blackbox_optimizer.run_step(perturbations_reshaped,\\n function_values_reshaped,\\n current_input,\\n current_value_exact)\\n config.controller.collect_rewards_and_train(rewards_for_controller,\\n finished_dnas)\\n\\n evaluation_stats_reduced = [sum(x) for x in zip(*evaluation_stats)]\\n blackbox_optimizer.update_state(evaluation_stats_reduced)\\n\\n return [True, new_current_input]\",\n \"def train(network_def, target_params, optimizer, states, actions, next_states, rewards,\\n terminals, loss_weights, cumulative_gamma, target_opt, mse_inf,tau,alpha,clip_value_min, rng):\\n online_params = optimizer.target\\n def loss_fn(params, rng_input, target, loss_multipliers):\\n def q_online(state):\\n return network_def.apply(params, state, rng=rng_input)\\n\\n q_values = jax.vmap(q_online)(states).q_values\\n q_values = jnp.squeeze(q_values)\\n replay_chosen_q = jax.vmap(lambda x, y: x[y])(q_values, actions)\\n \\n if mse_inf:\\n loss = jax.vmap(mse_loss)(target, replay_chosen_q)\\n else:\\n loss = jax.vmap(dqn_agent.huber_loss)(target, replay_chosen_q)\\n\\n mean_loss = jnp.mean(loss_multipliers * loss)\\n return mean_loss, loss\\n\\n rng, rng2, rng3, rng4 = jax.random.split(rng, 4)\\n\\n def q_target(state):\\n return network_def.apply(target_params, state, rng=rng2)\\n\\n def q_target_online(state):\\n return network_def.apply(online_params, state, rng=rng4)\\n\\n if target_opt == 0:\\n target = dqn_agent.target_q(q_target, next_states, rewards, terminals, cumulative_gamma) \\n elif target_opt == 1:\\n #Double DQN\\n target = target_DDQN(q_target_online, q_target, next_states, rewards, terminals, cumulative_gamma)\\n\\n elif target_opt == 2:\\n #Munchausen\\n target = target_m_dqn(q_target_online, q_target, states,next_states,actions,rewards,terminals,\\n cumulative_gamma,tau,alpha,clip_value_min)\\n else:\\n print('error')\\n\\n grad_fn = jax.value_and_grad(loss_fn, has_aux=True)\\n (mean_loss, loss), grad = grad_fn(online_params, rng3, target, loss_weights)\\n optimizer = optimizer.apply_gradient(grad)\\n return optimizer, loss, mean_loss\",\n \"def sgd_optimize(self, train_set, test_set, n_epochs, learning_rate, batch_size):\\n\\n train_set_x, train_set_y, train_set_c = train_set\\n assert train_set_x.shape == (60000, 784)\\n assert train_set_y.shape == (60000,)\\n assert train_set_c.shape == (60000, 10)\\n\\n test_set_x, test_set_y, test_set_c = test_set\\n assert test_set_x.shape == (10000, 784)\\n assert test_set_y.shape == (10000,)\\n assert test_set_c.shape == (10000, 10)\\n\\n from toolbox import make_shared_data\\n\\n train_set_x = make_shared_data(train_set_x)\\n train_set_c = make_shared_data(train_set_c)\\n train_set_y = T.cast(make_shared_data(train_set_y), 'int32')\\n\\n test_set_x = make_shared_data(test_set_x)\\n test_set_c = make_shared_data(test_set_c)\\n test_set_y = T.cast(make_shared_data(test_set_y), 'int32')\\n\\n print '... building the model'\\n\\n index = T.lscalar()\\n\\n cost = self.MSE\\n\\n gparams = [T.grad(cost, param) for param in self.params]\\n\\n train_model = theano.function(\\n inputs=[index],\\n outputs=cost,\\n updates=[\\n (param, param - learning_rate * gparam)\\n for param, gparam in zip(self.params, gparams)\\n ],\\n givens={\\n self.input: train_set_x[index * batch_size: (index + 1) * batch_size],\\n self.cost_vector: train_set_c[index * batch_size: (index + 1) * batch_size]\\n },\\n name='train_model'\\n )\\n\\n in_sample_result = theano.function(\\n inputs=[],\\n outputs=[self.error, self.future_cost],\\n givens={\\n self.input: train_set_x,\\n self.y: train_set_y,\\n self.cost_vector: train_set_c\\n },\\n name='in_sample_result'\\n )\\n\\n out_sample_result = theano.function(\\n inputs=[],\\n outputs=[self.error, self.future_cost],\\n givens={\\n self.input: test_set_x,\\n self.y: test_set_y,\\n self.cost_vector: test_set_c\\n },\\n name='out_sample_result'\\n )\\n\\n n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size\\n\\n print '... training the model'\\n\\n best_Cout = np.inf\\n corresponding_Eout = np.inf\\n for epoch in xrange(n_epochs):\\n print 'epoch #%d' % (epoch + 1)\\n for batch_index in xrange(n_train_batches):\\n batch_cost = train_model(batch_index)\\n Ein, Cin = in_sample_result()\\n Eout, Cout = out_sample_result()\\n if Cout < best_Cout:\\n best_Cout = Cout\\n corresponding_Eout = Eout\\n print ' better performance achieved ... best_Cout = %f' % best_Cout\\n\\n print 'after training %d epochs, best_Cout = %f, and corresponding_Eout = %f' \\\\\\n % (n_epochs, best_Cout, corresponding_Eout)\",\n \"def get_GP_optimum(obj):\\n\\n # Define space\\n space = Design_space(obj.domain, obj.constraints)\\n bounds = space.get_bounds()\\n\\n # Get function to optimize + gradients\\n # Also mask by everything that is allowed by the constraints\\n # fun = lambda d: fun_dfun(obj, space, d)[0]\\n # f_df = lambda d: fun_dfun(obj, space, d)\\n # def fun(d):\\n # return fun_dfun(obj, space, d)[0]\\n # Specify Optimizer --- L-BFGS\\n optimizer = OptLbfgs(space.get_bounds(), maxiter=1000)\\n\\n # Do the optimisation\\n x, _ = optimizer.optimize(\\n x0=obj.x_opt,\\n f=lambda d: fun_dfun(obj, space, d)[0],\\n f_df=lambda d: fun_dfun(obj, space, d))\\n # TODO: MULTIPLE RE-STARTS FROM PREVIOUS BEST POINTS\\n\\n # Round values if space is discrete\\n xtest = space.round_optimum(x)[0]\\n\\n if space.indicator_constraints(xtest):\\n opt = xtest\\n else:\\n # Rounding mixed things up, so need to look at neighbours\\n\\n # Compute neighbours to optimum\\n idx_comb = np.array(\\n list(itertools.product([-1, 0, 1], repeat=len(bounds))))\\n opt_combs = idx_comb + xtest\\n\\n # Evaluate\\n GP_evals = list()\\n combs = list()\\n for idx, d in enumerate(opt_combs):\\n\\n cons_check = space.indicator_constraints(d)[0][0]\\n bounds_check = indicator_boundaries(bounds, d)[0][0]\\n\\n if cons_check * bounds_check == 1:\\n pred = obj.model.predict(d)[0][0][0]\\n GP_evals.append(pred)\\n combs.append(d)\\n else:\\n pass\\n\\n idx_opt = np.where(GP_evals == np.min(GP_evals))[0][0]\\n opt = combs[idx_opt]\\n\\n return opt\",\n \"def do_optimisation(self):\\n\\n print('--> Parameters for optimisation:')\\n print('--> Using measurements : {}'.format(self.stoma_cfg.comparison_helper.optimisation_keys))\\n print('')\\n\\n x0 = self.initial_guess()\\n\\n tol, eps = 1e-4, 0.001\\n\\n print('--> Using SLSQP with tol={} and eps={}'.format(tol, eps))\\n\\n soln = opt.minimize(fun=self.optimise_fn,\\n x0=x0,\\n method='SLSQP',\\n tol=tol,\\n options={'eps': eps})\\n\\n print('*' * 120)\\n print('--> Optimisation procedure has finished...')\\n print(soln)\\n print('*' * 120)\\n\\n if soln.success:\\n print('--> Optimisation succeeded. Result is...')\\n self._set_material_parameters(soln.x)\\n print('--> {}'.format(self.material_model))\\n else:\\n print('--> The optimisation failed!')\\n\\n print('*' * 120)\\n\\n return soln\",\n \"def compute_optimalReward(task):\\n\\n\\tT = 15.0\\n\\tweights = 0\\n\\tif task == TABLE_TASK or task == COFFEE_TASK:\\n\\t\\tweights = 1\\n\\telif task == LAPTOP_TASK:\\n\\t\\tweights = 10\\n\\n\\t# initialize start/goal based on task \\n\\tif task == COFFEE_TASK or task == HUMAN_TASK:\\n\\t\\tpick = pick_shelf\\n\\telse:\\n\\t\\tpick = pick_basic\\n\\n\\tif task == LAPTOP_TASK:\\n\\t\\tplace = place_higher\\n\\telse:\\n\\t\\tplace = place_lower\\n\\t\\t\\n\\tstartRad = np.array(pick)*(math.pi/180.0)\\n\\tgoalRad = np.array(place)*(math.pi/180.0)\\n\\tstart = startRad\\n\\tgoal = goalRad\\n\\n\\tplan = Planner(task)\\t\\n\\tfilename = None\\n\\tif task == 1:\\n\\t\\tfilename = \\\"task1.csv\\\"\\n\\telif task == 2:\\n\\t\\tfilename = \\\"task2.csv\\\"\\n\\telif task == 3:\\n\\t\\tfilename = \\\"task3.csv\\\"\\n\\t\\t\\n\\t# get optimal waypts from file\\n\\twaypts = get_opt_waypts(filename)\\n\\tr = plan.featurize(waypts)\\n\\tRvel = r[0]\\n\\tRfeat = np.sum(r[1])\\n\\n\\tplan.kill_planner()\\n\\treturn (Rvel, Rfeat)\",\n \"def objective(args: Namespace, trial: optuna.trial._trial.Trial) -> float:\\n # Paramters (to tune)\\n args.embedding_dim = trial.suggest_int(\\\"embedding_dim\\\", 128, 512)\\n args.num_filters = trial.suggest_int(\\\"num_filters\\\", 128, 512)\\n args.hidden_dim = trial.suggest_int(\\\"hidden_dim\\\", 128, 512)\\n args.dropout_p = trial.suggest_uniform(\\\"dropout_p\\\", 0.3, 0.8)\\n args.lr = trial.suggest_loguniform(\\\"lr\\\", 5e-5, 5e-4)\\n\\n # Train (can move some of these outside for efficiency)\\n logger.info(f\\\"\\\\nTrial {trial.number}:\\\")\\n logger.info(json.dumps(trial.params, indent=2))\\n artifacts = run(args=args, trial=trial)\\n\\n # Set additional attributes\\n args = artifacts[\\\"args\\\"]\\n performance = artifacts[\\\"performance\\\"]\\n logger.info(json.dumps(performance[\\\"overall\\\"], indent=2))\\n trial.set_user_attr(\\\"threshold\\\", args.threshold)\\n trial.set_user_attr(\\\"precision\\\", performance[\\\"overall\\\"][\\\"precision\\\"])\\n trial.set_user_attr(\\\"recall\\\", performance[\\\"overall\\\"][\\\"recall\\\"])\\n trial.set_user_attr(\\\"f1\\\", performance[\\\"overall\\\"][\\\"f1\\\"])\\n\\n return performance[\\\"overall\\\"][\\\"f1\\\"]\",\n \"def _optfn(self, x):\\n\\n logger.debug(\\\" optfn(theta=%s)\\\", str(x))\\n\\n wmx = max(self.weights) * self.weighttrunc\\n\\n ip = []\\n for i,w in enumerate(self.weights):\\n if w < wmx:\\n continue\\n ip.append((i,w,x))\\n\\n if self.pool is None:\\n itr = map(self.worker.loglik_grad, ip)\\n else:\\n itr = self.pool.imap_unordered(_pool_loglik_grad, ip, 10)\\n\\n if self._prior_shape is None:\\n ll = 0.\\n grad = np.zeros(len(x))\\n else:\\n ll = sum(sp.special.xlogy(self._prior_shape-1,x)-(x/self._prior_scale))\\n grad = (self._prior_shape - 1)/x - 1/self._prior_scale\\n\\n for l,g in itr:\\n ll += l\\n grad += g\\n\\n logger.debug(\\\" optfn=%g\\\", ll)\\n\\n return -ll, -grad\",\n \"def compute_optimal_policy(self):\\n\\n self.theta_history.append(self.theta)\\n\\n since = time()\\n for it in range(self.n_itr):\\n print(\\\"lr: {} | Iteration N: {} \\\\r\\\".format(self.lr, it), end=\\\"\\\")\\n\\n self.policy = GaussianPolicy(self.theta, self.sigma)\\n\\n # Simulate N trajectories\\n paths = collect_episodes(\\n self.sim, policy=self.policy, horizon=self.T, n_episodes=self.n_episodes)\\n\\n avg_return = self._compute_performance(paths=paths)\\n self.avg_returns.append(avg_return)\\n\\n # Gradient update\\n self.theta += self.update_rule(self.policy.grad_J(\\n paths, self.discounts, n_ep=self.n_episodes, T=self.T), lr=self.lr)\\n\\n # History update\\n self.theta_history.append(self.theta)\\n\\n # print(\\\"\\\\nTook {}s\\\".format(round(time() - since, 2)))\\n print(\\\"lr: {} | Iteration N: {} | Took: {}s\\\".format(self.lr, self.n_itr, round(time() - since, 2)))\",\n \"def objective(trial):\\n %time\\n env = gym.make('Delivery-v0')\\n alpha = trial.suggest_discrete_uniform('alpha', 0.3,0.9,0.3)\\n gamma = trial.suggest_discrete_uniform('gamma', 0.6, 1,0.1)\\n epsilon = trial.suggest_discrete_uniform('epsilon', 0.01, 0.11, 0.04)\\n episodes = 1000000\\n \\n # For plotting metrics\\n all_epochs = []\\n all_penalties = []\\n rewards = []\\n \\n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \\n \\n for i in range(1, episodes+1):\\n state = env.reset()\\n episode_rewards = []\\n\\n epochs, penalties, reward, = 0, 0, 0\\n done = False\\n\\n while not done:\\n if random.uniform(0, 1) < epsilon:\\n action = env.action_space.sample() # Explore action space randomly\\n else:\\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\\n\\n next_state, reward, done, info = env.step(action) \\n\\n old_value = q_table[state, action]\\n next_max = np.max(q_table[next_state])\\n\\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\\n q_table[state, action] = new_value\\n\\n if reward == -10:\\n penalties += 1\\n \\n\\n state = next_state\\n episode_rewards.append(reward)\\n epochs += 1\\n \\n if done == True:\\n break \\n if epochs == 1000:\\n break \\n rewards.append(np.sum(episode_rewards))\\n \\n last_reward = np.mean(rewards)\\n # trial.report(-1 * last_reward)\\n\\n return -1 * last_reward\",\n \"def _optimize(self, objective):\\n # Initial value\\n initial = self.get_initial()[0]\\n\\n if self.vector_to_matrix_transform is not None:\\n initial = self.vector_to_matrix_transform(initial)\\n\\n if self.solver_type is 'NelderMead' or self.solver_type is 'ParticleSwarm':\\n initial = None\\n\\n # Create tensorflow variable\\n if self.matrix_manifold_dimension is None:\\n x_tf = tf.Variable(tf.zeros(self.dimension, dtype=tf.float64))\\n else:\\n x_tf = tf.Variable(tf.zeros([self.matrix_manifold_dimension, self.matrix_manifold_dimension], dtype=tf.float64))\\n\\n # Cost function for pymanopt\\n def objective_fct(x):\\n if self.matrix_to_vector_transform_tf is not None:\\n # Reshape x from matrix to vector form to compute the objective function (tensorflow format)\\n x = self.matrix_to_vector_transform_tf(x, self.matrix_manifold_dimension)\\n return objective(x)[0]\\n\\n # Transform the cost function to tensorflow function\\n cost = tf.py_function(objective_fct, [x_tf], tf.float64)\\n\\n # Gradient function for pymanopt\\n def objective_grad(x):\\n if self.matrix_to_vector_transform is not None:\\n # Reshape x from matrix to vector form to compute the gradient\\n x = self.matrix_to_vector_transform(x)\\n\\n # Compute the gradient\\n grad = np.array(objective(x)[1])[0]\\n\\n if self.vector_to_matrix_transform is not None:\\n # Reshape the gradient in matrix form for the optimization on the manifold\\n grad = self.vector_to_matrix_transform(grad)\\n return grad\\n\\n # Define pymanopt problem\\n problem = pyman.Problem(manifold=self.manifold, cost=cost, egrad=objective_grad, arg=x_tf, verbosity=2)\\n\\n # Optimize the parameters of the problem\\n opt_x, opt_log = self.solver.solve(problem, x=initial)\\n\\n if self.matrix_to_vector_transform is not None:\\n # Reshape the optimum from matrix to vector form\\n opt_x = self.matrix_to_vector_transform(opt_x)\\n\\n # Format the result to fit with GPflowOpt\\n result = sc_opt.OptimizeResult(x=opt_x, fun=opt_log['final_values']['f(x)'], nit=opt_log['final_values']['iterations'], message=opt_log['stoppingreason'], success=True)\\n\\n return result\",\n \"def optimize(self):\\n optimizer = tf.train.RMSPropOptimizer(self.config.learning_rate)\\n return optimizer.minimize(self.cost)\",\n \"def cross_validation(lambd_values = [0.1], maxfun_values = [200]):\\n \\n n_lambd, n_maxfun = len(lambd_values), len(maxfun_values)\\n \\n # Creation of the DataFrame where the results are to be stored\\n df_results = pd.DataFrame(index = range(n_lambd * n_maxfun))\\n df_results['Maxfun'], df_results['Lambd'] = list(maxfun_values) * n_lambd, list(lambd_values) * n_maxfun\\n df_results['Hidden layers'] = num_of_hidden_layers\\n nodes_avg = np.mean(layers[1:-1])\\n df_results['Nodes per hidden layer (avg)'] = nodes_avg\\n accuracy_col = []\\n \\n for lambd in lambd_values:\\n \\n for maxfun in maxfun_values:\\n \\n start = time() # start of the timer\\n \\n res = opt.fmin_l_bfgs_b(costFunction, nn_weights, fprime = backwards, args = (layers, images_validation, labels_training, num_labels, lambd), maxfun = maxfun, factr = 1., disp = True)\\n Theta = roll_params(res[0], layers)\\n \\n # input('\\\\nProgram paused. Press enter to continue!!!')\\n \\n # print(\\\"\\\\nTesting Neural Network... \\\\n\\\")\\n \\n pred = predict(Theta, images_test)\\n end = time() # end of the timer\\n accuracy = np.mean(labels_test == pred) * 100\\n print('\\\\nLambda =', lambd)\\n print('Maxfun =', maxfun)\\n time_complexity = end - start\\n print('Time:', time_complexity, 'seconds')\\n print('Accuracy =', accuracy, '%')\\n \\n # Modification of the 'Accuracy' column\\n accuracy_col.append(accuracy)\\n \\n # Accuracy values stored into the dataframe\\n df_results['Accuracy'] = accuracy_col\\n \\n return df_results\",\n \"def solve(self):\\n max_iter = 1000\\n iter_count = 0\\n yhat = self.predict()\\n loss = self.cross_entropy(yhat)\\n gradloss = self.cross_entropy_gradient(yhat)\\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\\n alpha = 1.0\\n slope = la.norm(gradloss)**2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n while loss_new < loss + 1e-4 * alpha * slope:\\n alpha = alpha / 2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n self.beta = beta_new\\n loss = loss_new\\n gradloss = self.cross_entropy_gradient(yhat)\\n iter_count += 1\",\n \"def hyperparameter_tunning(self, pipeline, max_evals):\\n space = self.create_space(pipeline)\\n\\n trials = Trials()\\n best = fmin(\\n self.objective,\\n space,\\n algo=tpe.suggest,\\n max_evals=max_evals,\\n catch_eval_exceptions=True,\\n trials=trials)\\n\\n best = hyperopt.space_eval(space, best)\\n return best\",\n \"def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\\n K=10):\\n\\n # Sampling of indices is done for you. Do not modify this if you\\n # wish to match the autograder and receive points!\\n indices = [target]\\n indices.extend(getNegativeSamples(target, dataset, K))\\n\\n ### YOUR CODE HERE\\n #The cost now is maximize the predicted and target pair,\\n #minimizing the predicted and the sampled pairs\\n cost = 0\\n gradPred = np.zeros(predicted.shape[0])\\n grad = np.zeros(outputVectors.shape)\\n\\n for indice in indices:\\n target_vector = outputVectors[indice]\\n vector_product = np.dot(target_vector,predicted)\\n if indice != target:\\n cost += -np.log(sigmoid(-vector_product))\\n gradPred += sigmoid(vector_product)*target_vector\\n # use += in case of repeatance\\n grad[indice,:] += sigmoid(vector_product)*predicted\\n else:\\n cost += -np.log(sigmoid(vector_product))\\n gradPred += (sigmoid(vector_product) - 1)*target_vector\\n grad[indice,:] += (sigmoid(vector_product)-1)*predicted\\n ### END YOUR CODE\\n #print indices\\n\\n return cost, gradPred, grad\",\n \"def optimize_model(optimizer, policy_net, target_net, memory_batch):\\n state_batch, action_batch, reward_batch, next_state_batch, done_batch = memory_batch\\n state_batch =state_batch.to(device, torch.float32)\\n action_batch = action_batch.to(device, torch.int64).view(-1,1)\\n reward_batch = reward_batch.to(device, torch.float32)\\n next_state_batch = next_state_batch.to(device, torch.float32)\\n done_batch = done_batch.to(device, torch.float32)\\n\\n # Compute Q(s_t, a) - the model computes Q(s_t), then we select the\\n # columns of actions taken\\n state_action_values = policy_net(state_batch).gather(1, action_batch)\\n\\n # Compute V(s_{t+1}) for all next states.\\n with torch.no_grad():\\n next_state_action_values = target_net(next_state_batch)\\n next_state_values = next_state_action_values.max(1)[0]\\n next_state_values = next_state_values * (1 - done_batch) # no reward if this episode is done.\\n # Compute the expected Q values\\n expected_state_action_values = (next_state_values * gamma) + reward_batch\\n expected_state_action_values = expected_state_action_values.unsqueeze(1)\\n\\n # Compute Huber loss\\n assert expected_state_action_values.requires_grad == False\\n assert state_action_values.requires_grad == True\\n loss = F.smooth_l1_loss(state_action_values, expected_state_action_values)\\n\\n # Optimize the model\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n return loss\",\n \"def train(self, iterations: int):\\n\\n s = \\\"{:3d} reward {:6.2f}/{:6.2f}/{:6.2f} len {:6.2f} epsilon {:1.3f} {}\\\"\\n s_check = \\\"{:3d} reward {:6.2f}/{:6.2f}/{:6.2f} len {:6.2f} epsilon {:1.3f} saved {} \\\"\\n total_steps = 0\\n iter_metrics = []\\n for n in range(iterations):\\n r_min, r_mean, r_max, iter_steps = self.train_iter()\\n iter_metrics.append((r_min, r_mean, r_max))\\n total_steps += iter_steps\\n\\n if n == int(iterations / 2):\\n self.steps_to_update_target_model = int(self.steps_to_update_target_model / 2)\\n\\n # checkpointing & logging\\n s_print = s\\n file_name = \\\"\\\"\\n if n % self.checkpoint_freq == 0:\\n file_name = f'my_dqn_{n}.pth'\\n torch.save(self.target_dqn.state_dict(), os.path.join(self.checkpoint_path, file_name))\\n s_print = s_check\\n\\n if self.verbose:\\n print(s_print.format(\\n n + 1,\\n r_min,\\n r_mean,\\n r_max,\\n total_steps,\\n self.e_greedy,\\n file_name\\n ))\\n iter_min = np.mean([x[0] for x in iter_metrics])\\n iter_mean = np.mean([x[1] for x in iter_metrics])\\n iter_max = np.mean([x[2] for x in iter_metrics])\\n return iter_min, iter_mean, iter_max\",\n \"def GradientDescent(x, y, theta, alpha, tolerate, maxiterate, epsilon):\\n i = 0 # set the iteration counting index\\n tolerate_rule = 1 # set the initial tolerate rate\\n n = x.shape[0]\\n current_theta = theta\\n scost_vector = np.empty([0, 1])\\n lcost_vector = np.empty([0, 1])\\n hcost_vector = np.empty([0, 1])\\n\\n # iterate\\n while tolerate_rule >= tolerate and i <= maxiterate:\\n sl = np.array(SquareLoss(x, y, current_theta)).reshape([1, 1])\\n scost_vector = np.append(scost_vector, sl, axis=0) # store cost\\n abs = np.array(AbsoluteLoss(x, y, current_theta)).reshape([1, 1])\\n lcost_vector = np.append(lcost_vector, abs, axis=0) # store cost\\n hbs = np.array(HuberLoss(x, y, current_theta, epsilon)).reshape([1, 1])\\n hcost_vector = np.append(hcost_vector, hbs, axis=0) # store cost\\n fx = x @ current_theta\\n update_theta = current_theta - alpha * (1/n) * x.transpose() @ (fx - y)\\n tolerate_rule = np.minimum(np.abs(update_theta - current_theta))\\n i += 1\\n current_theta = update_theta\\n\\n cost_matrix = np.asmatrix(np.stack((scost_vector, lcost_vector,\\n hcost_vector),\\n axis=-1))\\n cost_dataframe = pd.DataFrame(cost_matrix, columns=['AbsoluteLoss',\\n 'SquareLoss',\\n 'HuberLoss'])\\n return(current_theta, cost_dataframe)\",\n \"def adaptive_step(self):\\n\\n s = self\\n \\n # adaptive line search parameters\\n down_adjustment_frequency = 1\\n up_adjustment_frequency = 50\\n alpha=0.3 # acceptable fraction of predicted decrease\\n beta=0.8 # how much to shrink when violation\\n gamma=1.05 # how much to grow when too conservative\\n report_frequency = 1\\n \\n\\n s.model.advance_batch()\\n s.update_stats() # update cov matrices and svds\\n\\n s.grad.update() # gradient (ptodo, already updated in stats)\\n s.grad2.update() # gradient from synth labels (don't need?)\\n s.grad_new.update() # corrected gradient\\n\\n # TODO: decide on s vs s.\\n s.run(s.param_save_op) # TODO: insert lr somewhere\\n lr0, loss0 = s.run(s.lr, s.model.loss)\\n\\n s.run(s.param_update_op)\\n loss1 = s.run(s.model.loss)\\n \\n target_slope = -s.run(s.grad_dot_grad_new_op)\\n target_delta = lr0*target_slope\\n actual_delta = loss1 - loss0\\n actual_slope = actual_delta/lr0\\n slope_ratio = actual_slope/target_slope # between 0 and 1.01\\n \\n s.record('loss', loss0)\\n s.record('step_length', lr0)\\n s.record('grad_norm', s.run(s.grad_norm_op))\\n s.record('grad_new_norm', s.run(s.grad_new_norm_op))\\n s.record('target_delta', target_delta)\\n\\n if step_rejection and actual_delta > 0:\\n print('Observed increase in loss %.2f, rejecting step'%(actual_delta,))\\n s.run(s.param_restore_op)\\n\\n if s.step_counter % report_frequency == 0:\\n print('NStep %d loss %.2f, target decrease %.3f, actual decrease, %.3f ratio %.2f'%(self.step_counter, loss0, target_delta, actual_delta, slope_ratio))\\n\\n if (adaptive_step and s.step_counter % down_adjustment_frequency == 0 and\\n slope_ratio < alpha and abs(target_delta)>eps):\\n print('%.2f %.2f %.2f'%(loss0, loss1, slope_ratio))\\n print('Slope optimality %.2f, shrinking learning rate to %.2f'%(slope_ratio, lr0*beta,))\\n s.lr.set(lr0*beta)\\n elif (adaptive_step and s.step_counter % up_adjustment_frequency == 0 and\\n slope_ratio>0.90):\\n print('%.2f %.2f %.2f'%(loss0, loss1, slope_ratio))\\n print('Growing learning rate to %.2f'%(lr0*gamma))\\n s.lr.set(lr0*gamma)\\n \\n s.step_counter+=1\",\n \"def add_grad_updates(self):\\n \\n gradients = T.grad(self.cost, self.theta)\\n \\n for target_param, grad in zip(self.theta, gradients):\\n \\n if target_param.name ==\\\"W\\\" and self.num_hidden ==0\\\\\\n and self.zero_diag:\\n \\n grad = grad - T.diag(T.diag(grad)) # no x i - xi connections\\n # for all i = 1, ..., D\\n ##############################################################\\n if target_param.name ==\\\"b\\\" and self.learn_biases == False:\\n print(\\\"Will not learn bias terms\\\")\\n pass\\n \\n elif target_param.name ==\\\"bhid\\\" and self.learn_biases == False:\\n print(\\\"Will not learn bias terms\\\")\\n pass\\n \\n else:\\n \\n if self.use_momentum:\\n \\n # alternative definition (mostly seen):\\n #g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\\\\n #T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\\n #self.updates[target_param] = target_param + g_tilda\\n \\n g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\\\\n (1-self.momentum)*grad\\n \\n self.updates[target_param] = target_param +\\\\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*g_tilda\\n \\n # store g_tilda for next iteration:\\n self.updates[self.grad_vec[target_param.name]] = g_tilda\\n \\n else:\\n \\n self.updates[target_param] = target_param -\\\\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\\n \\n if (\\\"PCD\\\" in self.algorithm) and self.num_hidden > 0:\\n \\n self.updates[self.persistent_gibbs] = self.hid_samples\",\n \"def optimize(self): \\n if self.model == 'ARD':\\n estimate = minimize(\\n fun=optim_func,\\n x0=np.array([self.alpha, self.beta]),\\n args=(self,),\\n method='L-BFGS-B',\\n bounds=((0, 50), (0, 50)),\\n )\\n # logger.info(estimate)\\n\\n # organize into a dict\\n result = {\\n \\\"alpha\\\": estimate.x[0],\\n \\\"beta\\\": estimate.x[1],\\n \\\"Lik\\\": estimate.fun,\\n \\\"negLogLik\\\": -np.log(-estimate.fun),\\n \\\"convergence\\\": estimate.success,\\n }\\n logger.debug(result)\\n\\n elif self.model == 'ER':\\n estimate = minimize(\\n fun=optim_func,\\n x0=np.array([self.alpha]),\\n args=(self,),\\n method='L-BFGS-B',\\n bounds=[(0, 50)],\\n )\\n\\n result = {\\n \\\"alpha\\\": estimate.x[0],\\n \\\"Lik\\\": estimate.fun, \\n \\\"negLogLik\\\": -np.log(-estimate.fun),\\n \\\"convergence\\\": estimate.success,\\n }\\n logger.debug(result)\\n\\n else:\\n raise Exception('model must be specified as either ARD or ER')\\n\\n # get scaled likelihood values\\n self.log_lik = result[\\\"negLogLik\\\"]\\n self.tree = self.tree.set_node_values(\\n 'likelihood',\\n values={\\n node.idx: np.array(node.likelihood) / sum(node.likelihood)\\n for node in self.tree.idx_dict.values()\\n }\\n )\",\n \"def least_squares_SGD(y, tx, initial_w, max_iters, gamma, debug = False):\\n losses, ws = stochastic_gradient_descent(y, tx, initial_w, 1, max_iters, gamma, loss_f = model_linear.compute_loss, grad_f = model_linear.compute_gradient, debug = debug)\\n return get_last_ans(ws, losses)\",\n \"def Optimise(LogLikelihood,par,func_args,fixed=None,type='max',method='NM',maxiter=10000, maxfun=10000, verbose=True):\\n \\n if fixed==None:\\n var_par = np.copy(par)\\n #otherwise construct the parameter vector from var_par and fixed_par_val\\n else:\\n par = np.array(par)\\n fixed = np.array(fixed) #ensure fixed is a np array\\n #assign parameters to normal param vector\\n fixed_par = par[np.where(fixed==True)]\\n var_par = par[np.where(fixed!=True)]\\n \\n #set the algorithm to use - CG and P not working (at least not well)\\n add_kwords = {'verbose':verbose}\\n if method == 'NM':\\n Algorithm = NelderMead\\n add_kwords = {'maxiter':maxiter, 'maxfun':maxfun,'verbose':verbose}\\n elif method == 'CG':\\n print \\\"warning: CG method didn't work properly during testing\\\"\\n Algorithm = ConjugateGradient\\n elif method == 'P':\\n print \\\"warning: Powell algorithm didn't work properly during testing\\\"\\n Algorithm = Powell\\n else:\\n print \\\"error: optimisation function not found\\\"\\n return par\\n \\n #set the optimisation function to pos or neg for the fmin funcitons\\n if type == 'max': OptFunc = NegFixedPar_func\\n elif type == 'min': OptFunc = FixedPar_func\\n else:\\n print \\\"error: %s not a valid option\\\" % type\\n return par\\n \\n #call the optimser with the appropriate function\\n fitted_par = Algorithm(OptFunc, var_par, (LogLikelihood,func_args,fixed,fixed_par), \\\\\\n **add_kwords)\\n \\n #now return the params in the correct order...\\n if fixed==None:\\n return_par = fitted_par\\n else:\\n return_par = np.copy(par) \\n return_par[np.where(fixed!=True)] = fitted_par\\n \\n return return_par\",\n \"def target_fit_test(fitnesses, smoothing=3):\\n global obj_func, pop_size\\n\\n results_pso = []\\n results_de = []\\n for fitness in fitnesses:\\n print \\\"Fitness: \\\", fitness\\n\\n result_pso = 0\\n result_de = 0\\n\\n stopping_criterion = problem.StoppingCriterion('target_fitness', fitness)\\n\\n for i in xrange(smoothing):\\n result_pso += solver.minimize(obj_func, method='pso',\\n stopping_criterion=stopping_criterion,\\n population_size=pop_size, params=pso_params)\\n\\n result_de += solver.minimize(obj_func, method='de',\\n stopping_criterion=stopping_criterion,\\n population_size=pop_size)\\n\\n print \\\"Calculated de\\\"\\n\\n result_pso /= float(smoothing)\\n result_de /= float(smoothing)\\n\\n results_pso.append(result_pso)\\n results_de.append(result_de)\\n\\n plt.plot(fitnesses, results_pso, 'bo-', label='pso')\\n plt.plot(fitnesses, results_de, 'r^-', label='de')\\n plt.gca().invert_xaxis()\\n plt.legend()\\n plt.title('Comparison of pso and de methods using a target fitness')\\n plt.xlabel('Target fitness')\\n plt.ylabel('Iterations required to acheive that fitness')\\n plt.show()\",\n \"def get_winners(self):\\n\\n if self.optimal is not None:\\n return self.optimal\\n clean_proposals = self.cleaner.create_scenarios(self.proposals)\\n self.optimal = self.optimizer.optimize(clean_proposals)\\n return self.optimal\",\n \"def gradient_step(self):\\n n = 3 #Granularity of line search\\n grad = self.gradient()\\n #grad = grad/np.linalg.norm(grad, 2)\\n W = project(self.W[-1] + grad)\\n A = np.linspace(0., 1., n+2)[1:-1]\\n Objective = map(self, [(1. - a)*self.W[-1] + a*W for a in A])\\n a = A[np.argmax(Objective)]\\n W = (1. - a)*self.W[-1] + a*W\\n obj = np.max(Objective)\\n self.objective.append(obj)\\n self.W.append(W)\\n self.iterations += 1\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n ### YOUR CODE HERE\\n y_hat = softmax(np.dot(outputVectors,predicted))\\n y = np.zeros(outputVectors.shape[0])\\n y[target] = 1.0\\n\\n cost = -np.log(y_hat[target])\\n gradPred = np.dot(outputVectors.T,y_hat - y)\\n grad = np.outer(y_hat - y,predicted)\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def optimize(opt, target, n_agents, n_variables, n_iterations, lb, ub, hyperparams):\\n\\n # Creating the SearchSpace\\n space = SearchSpace(n_agents=n_agents, n_variables=n_variables,\\n n_iterations=n_iterations, lower_bound=lb, upper_bound=ub)\\n\\n # Creating the Function\\n function = Function(pointer=target)\\n\\n # Creating Optimizer\\n if opt.__name__ is not 'BH':\\n optimizer = opt(hyperparams=hyperparams)\\n else:\\n optimizer = opt()\\n\\n # Creating the optimization task\\n task = Opytimizer(space=space, optimizer=optimizer, function=function)\\n\\n return task.start(store_best_only=True)\",\n \"def fit_GD(self, X, y, eta=None,\\n eps=0, tmax=10000, verbose=False) :\\n if self.lambda_ != 0 :\\n raise Exception(\\\"GD with regularization not implemented\\\")\\n\\n if verbose :\\n plt.subplot(1, 2, 2)\\n plt.xlabel('iteration')\\n plt.ylabel(r'$J(\\\\theta)$')\\n plt.ion()\\n plt.show()\\n\\n X = self.generate_polynomial_features(X) # map features\\n n,d = X.shape\\n eta_input = eta\\n self.coef_ = np.zeros(d) # coefficients\\n err_list = np.zeros((tmax,1)) # errors per iteration, the value of error on each iteration\\n\\n\\n\\n # GD loop\\n for t in xrange(tmax) :\\n ### ========== TODO : START ========== ###\\n # part f: update step size\\n # change the default eta in the function signature to 'eta=None'\\n # and update the line below to your learning rate function\\n #print (\\\"this eta line was exectued\\\")\\n eta = 1/float(1+t)\\n #print eta\\n #eta = eta_input\\n #print (\\\"eta value is %f, and t = %d\\\") % (eta,t)\\n\\n\\n\\n\\n ### ========== TODO : END ========== ###\\n\\n ### ========== TODO : START ========== ###\\n # part d: update theta (self.coef_) using one step of GD\\n # hint: you can write simultaneously update all theta using vector math\\n\\n # track error\\n # hint: you cannot use self.predict(...) to make the predictions\\n # IMPORTANT: The reason you can not use predict or cost is because they operat\\n # delta_J = X_T*X*Theta - X_T*y\\n\\n #updated\\n y_pred_vector = np.dot(X, self.coef_)\\n delta_J = np.dot(X.transpose(),np.dot(X,self.coef_)) - np.dot(X.transpose(),y)\\n\\n\\n #cost = np.dot((y - y_pred_vector).transpose(), (y - y_pred_vector)) # write in the matrix form\\n\\n #updated\\n #self.coef_ = self.coef_ - eta*delta_J\\n #update the coeffient here\\n #for x in X, y in y: #returns row\\n for index, x in enumerate(X):\\n #get prediction\\n #w.T*X\\n y_true = y[index]\\n pred = np.dot(x, self.coef_)\\n #make sure that the values are compatible\\n self.coef_ = self.coef_ - 2*eta *(pred - y_true)*x\\n\\n\\n y_pred = np.dot(X, self.coef_) # change this line\\n err_list[t] = np.sum(np.power(y - y_pred, 2)) / float(n)\\n ### ========== TODO : END ========== ###\\n\\n # stop?\\n if t > 0 and abs(err_list[t] - err_list[t-1]) <= eps :\\n break\\n\\n # debugging\\n if verbose :\\n x = np.reshape(X[:,1], (n,1))\\n cost = self.cost(x,y)\\n plt.subplot(1, 2, 1)\\n plt.cla()\\n plot_data(x, y)\\n self.plot_regression()\\n plt.subplot(1, 2, 2)\\n plt.plot([t+1], [cost], 'bo')\\n plt.suptitle('iteration: %d, cost: %f' % (t+1, cost))\\n plt.draw()\\n plt.pause(0.05) # pause for 0.05 sec\\n\\n print 'number of iterations: %d' % (t+1)\\n\\n return self, t\",\n \"def optimize(self, maxiter):\\n for iteration in range(maxiter):\\n self.sortParticles()\\n self.phi = int(phiMin + iteration *((phiMax - phiMin) / float(maxiter)))\\n self.cluster()\\n #self.ConnectClusters()\\n for i in range(self.n_particles):\\n x = self.particles_pos[i]\\n v = self.velocities[i]\\n p_best = self.p_best[i]\\n self.velocities[i] = self.update_velocity(x, v, p_best , self.g_best , self.getLbestOfCluster(self.getClusterOfParticle(i)) , i)\\n self.particles_pos[i] = self.update_position(x, v)\\n # Update the best position for particle i\\n if self.func(self.particles_pos[i]) < self.func(p_best):\\n self.p_best[i] = self.particles_pos[i]\\n # Update the best position overall\\n if self.func(self.particles_pos[i]) < self.func(self.g_best):\\n \\n self.g_best = self.particles_pos[i]\\n return self.g_best, self.func(self.g_best)\",\n \"def optimize(self):\\n\\t\\ts1,a1,r1,s2 = self.ram.agg_sample(self.batch_size)\\n\\n\\t\\ts1 = Variable(torch.from_numpy(s1))\\n\\t\\ta1 = Variable(torch.from_numpy(a1))\\n\\t\\tr1 = Variable(torch.from_numpy(r1))\\n\\t\\ts2 = Variable(torch.from_numpy(s2))\\n\\n\\t\\tfor i in range(self.critic_step):\\n\\t\\t\\t# ---------------------- optimize critic ----------------------\\n\\t\\t\\t# Use target actor exploitation policy here for loss evaluation\\n\\t\\t\\t\\n\\t\\t\\t# a2 = self.target_actor.forward(s2).detach()\\n\\t\\t\\t# next_val = torch.squeeze(self.target_critic.forward(s2, a2).detach())\\n\\t\\t\\t\\n\\t\\t\\t# y_exp = r + gamma*Q'( s2, pi'(s2))\\n\\t\\t\\ty_expected = r1 #+ GAMMA*next_val\\n\\t\\t\\t# y_pred = Q( s1, a1)\\n\\t\\t\\ty_predicted = torch.squeeze(self.critic.forward(s1, a1))\\n\\t\\t\\t# compute critic loss, and update the critic\\n\\t\\t\\t#print(y_predicted,y_expected,\\\"hi\\\")\\n\\t\\t\\tloss_critic = F.smooth_l1_loss(y_predicted, y_expected.squeeze())\\n\\t\\t\\tself.critic_optimizer.zero_grad()\\n\\t\\t\\tloss_critic.backward()\\n\\t\\t\\tself.critic_optimizer.step()\\n\\n\\t\\t# ---------------------- optimize actor ----------------------\\n\\t\\tpred_a1 = self.actor.forward(s1)\\n\\t\\tloss_actor = -1*torch.sum(self.critic.forward(s1, pred_a1))\\n\\t\\tself.actor_optimizer.zero_grad()\\n\\t\\tloss_actor.backward()\\n\\t\\tself.actor_optimizer.step()\\n\\n\\t\\tutils.soft_update(self.target_actor, self.actor, TAU)\\n\\t\\tutils.soft_update(self.target_critic, self.critic, TAU)\\n\\n\\t\\t# if self.iter % 100 == 0:\\n\\t\\tif self.batch_size > 1:\\n\\t\\t\\ty_1 = y_predicted.data.numpy()[0]\\n\\t\\t\\tr_1 = r1.data.numpy()[0]\\n\\t\\telse:\\n\\t\\t\\ty_1 = y_predicted.data.numpy()\\n\\t\\t\\tr_1 = r1.data.numpy()\\n\\t\\tprint ('Iteration :- ', self.iter, ' Loss_actor :- ', loss_actor.data.numpy(),\\\\\\n\\t\\t\\t' Loss_critic :- ', loss_critic.data.numpy(), ' Critic Pred Reward :- ', y_1, ' Actual Reward :- ', r_1)\\n\\t\\tself.iter += 1\",\n \"def fast_grad(beta_init, theta_init, lambdat, t_init, maxiter, X, y):\\n beta = beta_init\\n theta = theta_init\\n grad = compute_grad(theta, lambdat=lambdat, X=X, y=y)\\n beta_vals = beta\\n iter = 0\\n obj_vals = []\\n while iter < maxiter:\\n t = backtracking(theta, lambdat=lambdat, t=t_init, X=X, y=y)\\n beta_new = theta - t*grad\\n theta = beta_new + iter/(iter+3)*(beta_new-beta)\\n beta_vals = np.vstack((beta_vals, beta_new))\\n obj_vals.append(objective(beta_new,lambdat,X=X,y=y))\\n grad = compute_grad(theta, lambdat=lambdat, X=X, y=y)\\n beta = beta_new\\n iter += 1\\n return beta_vals, obj_vals\",\n \"def AdaGrad(score_list, closure, batch_size, D, labels,\\n max_epoch=100, init_step_size=None, linesearch_option=0, \\n adaptive_termination=0, threshold_at=0.5,\\n c=0.5, beta=0.7,\\n x0=None, verbose=True, D_test=None, labels_test=None):\\n n = D.shape[0]\\n d = D.shape[1]\\n \\n m = int(n/batch_size)\\n\\n if x0 is None:\\n x = np.zeros(d)\\n x0 = np.zeros(d)\\n elif isinstance(x0, np.ndarray) and x0.shape == (d,):\\n x = x0.copy()\\n else:\\n raise ValueError('x0 must be a numpy array of size (d, )')\\n\\n num_grad_evals = 0\\n Gk2 = 0\\n \\n if linesearch_option in [0]:\\n step_size = init_step_size\\n if linesearch_option in [1]:\\n step_size = init_step_size / 2**(batch_size/n) \\n \\n condition_checked = False\\n \\n if adaptive_termination == 1:\\n Gk2_list = np.zeros(max_epoch * m)\\n iteration_counter = 0\\n warmup_time = int(n / (batch_size))\\n ratio_max = 0\\n print(threshold_at, warmup_time)\\n\\n \\n\\n for k in range(max_epoch): \\n # if num_grad_evals >= 2 * n * max_epoch:\\n # # exceeds the number of standard SVRG gradient evaluations (only for batch-size = 1)\\n # print('End of budget for gradient evaluations')\\n # break\\n t_start = time.time()\\n\\n\\n\\n loss, full_grad = closure(x, D, labels)\\n \\n if verbose:\\n output = 'Epoch.: %d, Grad. norm: %.2e' % \\\\\\n (k, np.linalg.norm(full_grad))\\n output += ', Func. value: %e' % loss\\n output += ', Step size: %e' % step_size\\n output += ', Num gradient evaluations/n: %f' % (num_grad_evals / n) \\n print(output) \\n\\n \\n\\n score_dict = {\\\"epoch\\\": k}\\n score_dict[\\\"optimizer\\\"] = 0\\n score_dict[\\\"n_grad_evals\\\"] = num_grad_evals\\n score_dict[\\\"n_grad_evals_normalized\\\"] = num_grad_evals / n\\n score_dict[\\\"train_loss\\\"] = loss\\n score_dict[\\\"grad_norm\\\"] = np.linalg.norm(full_grad)\\n score_dict[\\\"train_accuracy\\\"] = accuracy(x, D, labels)\\n score_dict[\\\"train_loss_log\\\"] = np.log(loss)\\n score_dict[\\\"grad_norm_log\\\"] = np.log(score_dict[\\\"grad_norm\\\"])\\n # score_dict[\\\"train_accuracy_log\\\"] = np.log(score_dict[\\\"train_accuracy\\\"])\\n if D_test is not None:\\n test_loss = closure(x, D_test, labels_test, backwards=False)\\n score_dict[\\\"test_loss\\\"] = test_loss\\n score_dict[\\\"test_accuracy\\\"] = accuracy(x, D_test, labels_test)\\n score_dict[\\\"test_loss_log\\\"] = np.log(test_loss)\\n # score_dict[\\\"test_accuracy_log\\\"] = np.log(score_dict[\\\"test_accuracy\\\"])\\n\\n score_list += [score_dict]\\n \\n if np.linalg.norm(full_grad) <= 1e-10:\\n break\\n if np.linalg.norm(full_grad) >= 1e10:\\n break\\n if np.isnan(full_grad).any():\\n break\\n \\n # Create Minibatches:\\n minibatches = make_minibatches(n, m, batch_size)\\n for i in range(m):\\n # get the minibatch for this iteration\\n indices = minibatches[i]\\n Di, labels_i = D[indices, :], labels[indices]\\n\\n # compute the loss, gradients\\n loss, x_grad = closure(x, Di, labels_i) \\n gk = x_grad\\n num_grad_evals = num_grad_evals + batch_size\\n \\n Gk2 = Gk2 + (np.linalg.norm(gk) ** 2)\\n \\n if linesearch_option == 0:\\n step_size = init_step_size\\n\\n \\n elif linesearch_option == 1:\\n step_size, armijo_iter = armijo_ls(closure, Di, labels_i, x, loss,\\n x_grad, x_grad, 2**(batch_size/n) * step_size, c=c, beta=beta,\\n precond = 1)\\n num_grad_evals += batch_size * armijo_iter\\n \\n if \\\"armijo_iter\\\" in score_list[len(score_list) - 1].keys(): \\n score_list[len(score_list) - 1][\\\"armijo_iter\\\"] += armijo_iter\\n else:\\n score_list[len(score_list) - 1][\\\"armijo_iter\\\"] = armijo_iter\\n \\n if adaptive_termination == 1: \\n if iteration_counter >= warmup_time:\\n Gk2_list[iteration_counter] = Gk2\\n if iteration_counter % 2 == 0: \\n if iteration_counter/2 >= warmup_time:\\n Gk2_last = Gk2_list[int(iteration_counter/2)] \\n ratio = (Gk2 - Gk2_last) / Gk2_last\\n #print(ratio)\\n if ratio > ratio_max:\\n ratio_max = ratio\\n if ratio > threshold_at:\\n x -= (step_size / np.sqrt(Gk2)) * gk\\n print('Breaking out of inner loop at iteration', iteration_counter)\\n condition_checked = True\\n break\\n iteration_counter += 1\\n \\n \\n \\n x -= (step_size / np.sqrt(Gk2)) * gk\\n \\n \\n\\n \\n \\n t_end = time.time()\\n time_epoch = t_end - t_start\\n score_list[len(score_list) - 1][\\\"time\\\"] = time_epoch \\n if condition_checked:\\n break\\n \\n return score_list, x, num_grad_evals, k\",\n \"def optimize_agent(self, itr, samples=None, sampler_itr=None, offline_samples=None):\\n itr = itr if sampler_itr is None else sampler_itr # Async uses sampler_itr.=\\n if samples is not None:\\n if self.save_data:\\n self.data_writer.write(samples)\\n samples_to_buffer = self.samples_to_buffer(samples)\\n self.replay_buffer.append_samples(samples_to_buffer)\\n opt_info = ModelOptInfo(*([] for _ in range(len(ModelOptInfo._fields))))\\n if not self.offline and itr < self.min_itr_learn:\\n return opt_info\\n for _ in range(1 if self.offline else self.updates_per_optimize):\\n start = time.time()\\n samples_from_replay = self.sample_batch()\\n\\n end = time.time()\\n sample_time = end - start\\n\\n forward_time = time.time()\\n rl_loss, td_abs_errors, goal_loss,\\\\\\n t0_spr_loss, model_spr_loss, \\\\\\n diversity, inverse_model_loss, bc_loss, \\\\\\n goal_abs_errors \\\\\\n = self.loss(samples_from_replay, self.offline)\\n forward_time = time.time() - forward_time\\n\\n total_loss = self.rl_weight * rl_loss\\n total_loss += self.spr_weight * model_spr_loss\\n total_loss += self.goal_weight * goal_loss\\n total_loss += self.inverse_model_weight * inverse_model_loss\\n total_loss += self.bc_weight * bc_loss\\n\\n self.optimizer.zero_grad()\\n total_loss.backward()\\n stem_params, model_params = self.model.split_stem_model_params()\\n if self.clip_grad_norm > 0:\\n grad_norm = torch.nn.utils.clip_grad_norm_(stem_params,\\n self.clip_grad_norm)\\n else:\\n grad_norm = 0\\n if self.clip_model_grad_norm > 0:\\n model_grad_norm = torch.nn.utils.clip_grad_norm_(model_params,\\n self.clip_model_grad_norm)\\n else:\\n model_grad_norm = 0\\n\\n cnn_weight_norm = find_weight_norm(self.model.conv.parameters())\\n\\n self.optimizer.step()\\n\\n if not self.offline and self.prioritized_replay:\\n self.replay_buffer.update_batch_priorities(td_abs_errors)\\n opt_info.loss.append(rl_loss.item())\\n opt_info.gradNorm.append(torch.tensor(grad_norm).item()) # grad_norm is a float sometimes, so wrap in tensor\\n opt_info.GoalLoss.append(goal_loss.item())\\n opt_info.modelGradNorm.append(torch.tensor(model_grad_norm).item())\\n opt_info.T0SPRLoss.append(t0_spr_loss.item())\\n opt_info.InverseModelLoss.append(inverse_model_loss.item())\\n opt_info.BCLoss.append(bc_loss.item())\\n opt_info.CNNWeightNorm.append(cnn_weight_norm.item())\\n opt_info.SampleTime.append(sample_time)\\n opt_info.ForwardTime.append(forward_time)\\n opt_info.Diversity.append(diversity.item())\\n opt_info.ModelSPRLoss.append(model_spr_loss.item())\\n opt_info.tdAbsErr.extend(td_abs_errors[::8].cpu().numpy()) # Downsample.\\n opt_info.GoalError.extend(goal_abs_errors[::8].cpu().numpy()) # Downsample.\\n self.update_counter += 1\\n if self.update_counter % self.target_update_interval == 0:\\n self.agent.update_target(self.target_update_tau)\\n self.update_itr_hyperparams(itr)\\n return opt_info\",\n \"def fit(self, ymeas, mmeas=None, alg='optls'): # alg: {'optls','mine'}\\n\\n # [ X ]*dm = [ dy ]\\n # [ a ] [ 0 ] <-- using built-in Ridge model does this\\n #\\n # [ X ]*dm = [ dy ]\\n # [-a ] [ a*m ] <-- but I want this for iterated nonlin problem\\n #\\n # [ X ]*dm = [ dy ]\\n # [-aL ] [ a*L*m ] <-- and more generally I want this (higher-order Tihk)\\n #\\n # which can be rewritten:\\n # G * dm = D (and then loop that from m0 with m=m+dm...)\\n\\n # X is the Jacobian matrix of derivs of predicted data points wrt model\\n # params m, as given by ypred,X=self.fwd_deriv_code(m)...\\n\\n\\n if alg=='optls':\\n # https://docs.scipy.org/doc/scipy/reference/optimize.html\\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.least_squares.html\\n def fun(m):\\n mlen = m.size\\n L = create_findiff_mtx(mlen,self.beta)\\n ypred,J = self.fwd_deriv_code(m) # m: model params vector, J: derivs matrix\\n resids = ymeas-ypred\\n modelfunc = self.alpha * np.dot(L,m)\\n modelfunc = modelfunc.reshape(len(modelfunc),1)\\n f = np.squeeze(np.concatenate((resids,modelfunc),axis=0))\\n return f\\n\\n def jac(m):\\n mlen = m.size\\n L = create_findiff_mtx(mlen,self.beta)\\n ypred,J = self.fwd_deriv_code(m) # m: model params vector, J: derivs matrix\\n Jreg = self.alpha * L\\n Jout = np.concatenate((J,Jreg))\\n return Jout\\n\\n if self.usefindiff:\\n jacfn='2-point'\\n else:\\n jacfn=jac\\n if self.verbose:\\n verblevel=2\\n else:\\n verblevel=0\\n res = least_squares(fun, np.squeeze(self.minit), jac=jacfn,\\n bounds=(0., 3.5), diff_step=None, verbose=verblevel, max_nfev=self.max_nfev,\\n method='trf', ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0)\\n #ftol=1e-4, xtol=1e-1, gtol=1e-8, x_scale=1.0)\\n #ftol=1e0, xtol=1e-01, gtol=1e-01, x_scale=1.0)\\n #ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0)\\n\\n if mmeas is not None:\\n testMSE = cplxMSE(res.x.reshape(len(res.x),1),mmeas)\\n else:\\n testMSE = npl.nan\\n ypred,J = self.fwd_deriv_code(res.x.reshape(len(res.x),1))\\n ypred=np.log10(ypred)\\n residnorm = norm(ypred-ymeas)\\n print('resid norm',residnorm)\\n L = create_findiff_mtx(len(self.minit),self.beta)\\n print('maxeig JJ',np.real(np.amax(np.linalg.eigvals(np.dot(J.T,J))))) # J'J has real eigvals but kept cplx type\\n print('maxeig LL',np.amax(np.linalg.eigvals(np.dot(L.T,L))))\\n if self.showplot:\\n f, ax = plt.subplots(1, 2, figsize=(11,4))\\n # plot the meas and pred data:\\n # print('ypred',ypred)\\n # print('ymeas',ymeas)\\n ax[0].plot(ypred,'r.-')\\n ax[0].plot(ymeas,'k.-')\\n ax[0].grid()\\n #ax[0].set_ylabel('cost')\\n #ax[0].set_xlabel('iterations')\\n ax[0].set_title('Measured (blk) and predicted (blu) data')\\n # plot the init, true, and final model param vectors:\\n ax[1].plot(self.minit,'g.-')\\n ax[1].plot(res.x,'r.--')\\n ax[1].plot(mmeas,'k.--')\\n ax[1].grid()\\n #ax[1].set_ylabel('model value')\\n #ax[1].set_xlabel('indep var')\\n ax[1].set_title('Model vectors (true=blk, init=grn, soln=red)')\\n\\n # return m,cost,misfit,modelnorm,norm(dm),testMSE\\n return res.x,res.cost,np.nan,np.nan,np.nan,testMSE\\n\\n elif alg=='mine':\\n cost = []\\n m = self.minit\\n mlen = len(m)\\n if self.verbose:\\n print('iter alpha cost norm(dd) norm(dm) dmtol')\\n for i in range(self.max_nfev):\\n ypred,X = self.fwd_deriv_code(m) # m: model params vector, X: derivs matrix\\n if self.usefindiff:\\n def tmpfwdcode(m):\\n return np.squeeze(self.fwd_deriv_code(m)[0])\\n X = jacfindiff(tmpfwdcode,m,dx=1.0e-6) # dx=1.0e-6 is problem dependent!\\n L = create_findiff_mtx(mlen,self.beta)\\n G = np.concatenate((X, -self.alpha*L),axis=0)\\n D = np.concatenate((ymeas-ypred, self.alpha*np.dot(L,m)),axis=0)\\n misfit = cplxMSE(ymeas, ypred)\\n modelnorm = norm(np.dot(L,m))**2\\n current_cost = misfit + pow(self.alpha,2)*modelnorm\\n dm,res,rnk,sv = lstsq(G,D)\\n m = m + dm\\n cost.append(current_cost)\\n if self.verbose:\\n print('%3d %6.1g %10.3f %10.3f %10.2g %6.3g' %\\n (i, self.alpha, current_cost, norm(ymeas-ypred), norm(dm), self.dmtol))\\n if norm(dm) < self.dmtol:\\n break\\n self.G = G\\n self.ypred = ypred\\n if mmeas is not None:\\n testMSE = cplxMSE(m,mmeas)\\n else:\\n testMSE = npl.nan\\n print('maxeig JJ',np.real(np.amax(np.linalg.eigvals(np.dot(X.T,X))))) # X'X has real eigvals but kept cplx type\\n print('maxeig LL',np.amax(np.linalg.eigvals(np.dot(L.T,L))))\\n if self.showplot:\\n f, ax = plt.subplots(1, 2, figsize=(11,4))\\n # plot the cost (ie loss) per iterations:\\n ax[0].semilogy(cost,'.-') # (last element of cost)\\n ax[0].grid()\\n ax[0].set_ylabel('cost')\\n ax[0].set_xlabel('iterations')\\n ax[0].set_title('Cost history (misfit^2 + alpha^2*modelnorm^2)')\\n # plot the init, true, final, and evolution of model params:\\n #print('m',np.squeeze(m.T))\\n ax[1].plot(mmeas,'k')\\n ax[1].plot(self.minit,'g')\\n ax[1].plot(m,'r')\\n ax[1].grid()\\n #ax[1].set_ylabel('model value')\\n ax[1].set_xlabel('indep var')\\n ax[1].set_title('Model vectors')\\n\\n return m,cost[-1],misfit,modelnorm,norm(dm),testMSE\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6879043","0.6779472","0.6599153","0.6580296","0.6474444","0.6437695","0.6382017","0.6354665","0.62422895","0.62376463","0.62362105","0.6233735","0.6200726","0.6200518","0.61941844","0.6183736","0.61756665","0.61680037","0.6155385","0.61435944","0.61411583","0.61388886","0.61224794","0.61218715","0.61043954","0.6083752","0.60682666","0.6065925","0.6061931","0.6040068","0.60238487","0.6022695","0.60204643","0.6010627","0.60092145","0.5994461","0.59939396","0.59911114","0.5984624","0.5966756","0.5960607","0.59529006","0.59482753","0.59222317","0.59198374","0.5917234","0.59108645","0.59068644","0.59067017","0.5904549","0.5904483","0.5902709","0.58951336","0.5881172","0.5877128","0.5871534","0.5867592","0.5859048","0.5848558","0.5847024","0.58362037","0.58358437","0.5831013","0.5809046","0.580472","0.58016735","0.57974803","0.5796132","0.5791315","0.5787215","0.5772895","0.5766968","0.5766016","0.5748469","0.57380897","0.57379764","0.5737867","0.57300675","0.5726192","0.57226795","0.5720197","0.57199454","0.57045835","0.5689795","0.56894207","0.56878287","0.5671743","0.56684136","0.5666974","0.5662797","0.5660276","0.5659028","0.5657405","0.565595","0.56541014","0.56529385","0.565069","0.5648606","0.56379455","0.5636887"],"string":"[\n \"0.6879043\",\n \"0.6779472\",\n \"0.6599153\",\n \"0.6580296\",\n \"0.6474444\",\n \"0.6437695\",\n \"0.6382017\",\n \"0.6354665\",\n \"0.62422895\",\n \"0.62376463\",\n \"0.62362105\",\n \"0.6233735\",\n \"0.6200726\",\n \"0.6200518\",\n \"0.61941844\",\n \"0.6183736\",\n \"0.61756665\",\n \"0.61680037\",\n \"0.6155385\",\n \"0.61435944\",\n \"0.61411583\",\n \"0.61388886\",\n \"0.61224794\",\n \"0.61218715\",\n \"0.61043954\",\n \"0.6083752\",\n \"0.60682666\",\n \"0.6065925\",\n \"0.6061931\",\n \"0.6040068\",\n \"0.60238487\",\n \"0.6022695\",\n \"0.60204643\",\n \"0.6010627\",\n \"0.60092145\",\n \"0.5994461\",\n \"0.59939396\",\n \"0.59911114\",\n \"0.5984624\",\n \"0.5966756\",\n \"0.5960607\",\n \"0.59529006\",\n \"0.59482753\",\n \"0.59222317\",\n \"0.59198374\",\n \"0.5917234\",\n \"0.59108645\",\n \"0.59068644\",\n \"0.59067017\",\n \"0.5904549\",\n \"0.5904483\",\n \"0.5902709\",\n \"0.58951336\",\n \"0.5881172\",\n \"0.5877128\",\n \"0.5871534\",\n \"0.5867592\",\n \"0.5859048\",\n \"0.5848558\",\n \"0.5847024\",\n \"0.58362037\",\n \"0.58358437\",\n \"0.5831013\",\n \"0.5809046\",\n \"0.580472\",\n \"0.58016735\",\n \"0.57974803\",\n \"0.5796132\",\n \"0.5791315\",\n \"0.5787215\",\n \"0.5772895\",\n \"0.5766968\",\n \"0.5766016\",\n \"0.5748469\",\n \"0.57380897\",\n \"0.57379764\",\n \"0.5737867\",\n \"0.57300675\",\n \"0.5726192\",\n \"0.57226795\",\n \"0.5720197\",\n \"0.57199454\",\n \"0.57045835\",\n \"0.5689795\",\n \"0.56894207\",\n \"0.56878287\",\n \"0.5671743\",\n \"0.56684136\",\n \"0.5666974\",\n \"0.5662797\",\n \"0.5660276\",\n \"0.5659028\",\n \"0.5657405\",\n \"0.565595\",\n \"0.56541014\",\n \"0.56529385\",\n \"0.565069\",\n \"0.5648606\",\n \"0.56379455\",\n \"0.5636887\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6747765"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":10489,"cells":{"query":{"kind":"string","value":"optimizes the current library to maximize the result of the target function using simulated annealing. By default, the function returns the best value and the associated interaction matrix as result. `direction` is either 'min' or 'max' and determines whether a minimum or a maximum is sought. `steps` determines how many optimization steps we try `ret_info` determines whether extra information is returned from the optimization `args` is a dictionary of additional arguments that is passed to the target function"},"document":{"kind":"string","value":"def optimize_library_anneal(self, target, direction='max', steps=100,\n ret_info=False, args=None):\n # lazy import\n from .optimizer import ReceptorOptimizerAnnealer # @UnresolvedImport\n \n # prepare the class that manages the simulated annealing\n annealer = ReceptorOptimizerAnnealer(self, target, direction, args,\n ret_info=ret_info)\n annealer.steps = int(steps)\n annealer.Tmax = self.parameters['anneal_Tmax']\n annealer.Tmin = self.parameters['anneal_Tmin']\n if self.parameters['verbosity'] == 0:\n annealer.updates = 0\n\n # do the optimization\n MI, state = annealer.optimize()\n\n # sort the best state and store it in the current object\n state = self.sort_sensitivity_matrix(state)\n self.sens_mat = state.copy()\n \n if ret_info:\n return MI, state, annealer.info\n else:\n return MI, state"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def optimize_library_descent(self, target, direction='max', steps=100,\n multiprocessing=False, ret_info=False,\n args=None):\n # get the target function to call\n target_function = getattr(self, target)\n if args is not None:\n target_function = functools.partial(target_function, **args)\n\n # initialize the optimizer\n value = target_function()\n value_best, state_best = value, self.sens_mat.copy()\n \n if ret_info:\n # store extra information\n start_time = time.time()\n info = {'values': {}}\n values_count = self.parameters['optimizer_values_count']\n values_step = max(1, steps // values_count)\n \n if multiprocessing:\n # run the calculations in multiple processes\n pool_size = self.get_number_of_cores()\n pool = mp.Pool(processes=pool_size)\n if ret_info:\n values_step = max(1, values_step // pool_size)\n \n # iterate for given number of steps\n for step in range(int(steps) // pool_size):\n joblist = []\n init_arguments = self.init_arguments\n for _ in range(pool_size):\n # modify the current state and add it to the job list\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n params = init_arguments['parameters'] \n params['sensitivity_matrix'] = self.sens_mat\n params['initialize_state']['sensitivity'] = 'exact'\n \n joblist.append((copy.deepcopy(init_arguments), target))\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # run all the jobs\n results = pool.map(_run_job, joblist)\n \n # find the best result \n if direction == 'max':\n res_best = np.argmax(results)\n if results[res_best] > value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n elif direction == 'min':\n res_best = np.argmin(results)\n if results[res_best] < value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n else:\n raise ValueError('Unsupported direction `%s`' % direction)\n \n if ret_info and step % values_step == 0:\n info['values'][step * pool_size] = results[res_best]\n \n else:\n # run the calculations in this process\n for step in range(int(steps)):\n # modify the current state\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # get the value of the new state\n value = target_function()\n \n improved = ((direction == 'max' and value > value_best) or\n (direction == 'min' and value < value_best))\n if improved:\n # save the state as the new best value\n value_best, state_best = value, self.sens_mat.copy()\n else:\n # undo last change\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n if ret_info and step % values_step == 0:\n info['values'][step] = value_best\n\n # sort the best state and store it in the current object\n state_best = self.sort_sensitivity_matrix(state_best)\n self.sens_mat = state_best.copy()\n\n if ret_info:\n info['total_time'] = time.time() - start_time \n info['states_considered'] = steps\n info['performance'] = steps / info['total_time']\n return value_best, state_best, info\n else:\n return value_best, state_best","def optimize_library_descent_multiple(self, target, direction='max',\n trials=4, multiprocessing=False,\n ret_error=False, **kwargs):\n \n # pass some parameters down to the optimization function to call\n kwargs['target'] = target\n kwargs['direction'] = direction\n \n # initialize the list of jobs with an optimization job starting from the\n # current interaction matrix\n joblist = [(self.init_arguments, 'optimize_library_descent', kwargs)]\n sens_mat = self.sens_mat #< store matrix to restore it later\n\n # set the ensemble of sensitivity matrices to try\n self.choose_sensitivity_matrix(density='auto')\n self.parameters['initialize_state']['sensitivity'] = 'ensemble'\n\n # add additional jobs with random initial interaction matrices\n init_arguments = self.init_arguments\n for _ in range(trials - 1):\n joblist.append((copy.deepcopy(init_arguments),\n 'optimize_library_descent', kwargs))\n \n # restore interaction matrix of this object\n self.sens_mat = sens_mat\n \n if multiprocessing:\n # calculate all results in parallel\n pool = mp.Pool(processes=self.get_number_of_cores())\n result_iter = pool.imap_unordered(_run_job, joblist)\n \n else:\n # create a generator over which we iterate later\n result_iter = (_run_job(job) for job in joblist)\n \n # find the best result by iterating over all results\n result_best, values = None, []\n for result in result_iter:\n values.append(result[0])\n # check whether this run improved the result\n if result_best is None:\n result_best = result\n elif ((direction == 'max' and result[0] > result_best[0]) or\n (direction == 'min' and result[0] < result_best[0])):\n result_best = result\n \n # sort the best state and store it in the current object\n state = self.sort_sensitivity_matrix(result_best[1])\n self.sens_mat = state.copy()\n\n if ret_error:\n # replace the best value by a tuple of the best value and its error\n value_best = result_best[0]\n value_err = np.abs(value_best - np.median(values))\n result_best = ((value_best, value_err), ) + result_best[1:]\n return result_best","def optimize_library(self, target, method='descent', direction='max',\n **kwargs):\n if method == 'descent':\n return self.optimize_library_descent(target, direction, **kwargs)\n elif method == 'descent_multiple' or method == 'descent-multiple':\n return self.optimize_library_descent_multiple(target, direction,\n **kwargs)\n elif method == 'anneal':\n return self.optimize_library_anneal(target, direction, **kwargs)\n \n else:\n raise ValueError('Unknown optimization method `%s`' % method)","def Optimise(LogLikelihood,par,func_args,fixed=None,type='max',method='NM',maxiter=10000, maxfun=10000, verbose=True):\n \n if fixed==None:\n var_par = np.copy(par)\n #otherwise construct the parameter vector from var_par and fixed_par_val\n else:\n par = np.array(par)\n fixed = np.array(fixed) #ensure fixed is a np array\n #assign parameters to normal param vector\n fixed_par = par[np.where(fixed==True)]\n var_par = par[np.where(fixed!=True)]\n \n #set the algorithm to use - CG and P not working (at least not well)\n add_kwords = {'verbose':verbose}\n if method == 'NM':\n Algorithm = NelderMead\n add_kwords = {'maxiter':maxiter, 'maxfun':maxfun,'verbose':verbose}\n elif method == 'CG':\n print \"warning: CG method didn't work properly during testing\"\n Algorithm = ConjugateGradient\n elif method == 'P':\n print \"warning: Powell algorithm didn't work properly during testing\"\n Algorithm = Powell\n else:\n print \"error: optimisation function not found\"\n return par\n \n #set the optimisation function to pos or neg for the fmin funcitons\n if type == 'max': OptFunc = NegFixedPar_func\n elif type == 'min': OptFunc = FixedPar_func\n else:\n print \"error: %s not a valid option\" % type\n return par\n \n #call the optimser with the appropriate function\n fitted_par = Algorithm(OptFunc, var_par, (LogLikelihood,func_args,fixed,fixed_par), \\\n **add_kwords)\n \n #now return the params in the correct order...\n if fixed==None:\n return_par = fitted_par\n else:\n return_par = np.copy(par) \n return_par[np.where(fixed!=True)] = fitted_par\n \n return return_par","def simulatedAnnealing(problem, maxSteps, userInteraction, beQuiet):\n\n import random\n from math import exp\n\n currentState = problem.state\n steps = 0\n bestYet = currentState\n # for visualization\n problem.hVals.append(problem.getObjValue(currentState))\n\n while steps<maxSteps:\n if problem.isGlobalOptimum(currentState):\n return steps, bestYet\n temperature = tempSchedule(steps, maxSteps)\n # print(temperature)\n if temperature == 0:\n return currentState\n neighbour = problem.getRandomNeighbour(currentState)\n changeInObj = problem.getObjValue(neighbour) - \\\n problem.getObjValue(currentState)\n if changeInObj > 0:\n # if the neighbour is better, jump\n currentState = neighbour\n if not beQuiet:\n if userInteraction:\n input(\"Press enter to continue \")\n print(\"Greedy step taken.\")\n problem.visualize(currentState)\n steps+=1\n\n currentVal = problem.getObjValue(currentState)\n bestYetVal = problem.getObjValue(bestYet)\n if problem.isBetter(currentVal, bestYetVal):\n bestYet = currentState\n\n # for visualization later on\n problem.hVals.append(problem.getObjValue(currentState))\n\n else:\n # if the neighbour is worse, jump with some probability\n if random.random() < exp(-1*changeInObj/temperature):\n \n currentState = neighbour\n if not beQuiet:\n if userInteraction:\n input(\"Press enter to continue \")\n print(\"Step in a worse direction taken.\")\n problem.visualize(currentState)\n steps+=1\n\n currentVal = problem.getObjValue(currentState)\n bestYetVal = problem.getObjValue(bestYet)\n if problem.isBetter(currentVal, bestYetVal):\n bestYet = currentState\n\n # for visualization later on\n problem.hVals.append(problem.getObjValue(currentState))\n return steps, bestYet","def process_solve_kwargs(**kwargs):\n\n tol = kwargs.get('tol', DEFAULT_TOL)\n maxiter = kwargs.get('maxiter', MAX_ITER)\n Ainv = kwargs.get('Ainv', None)\n verbose = kwargs.get('verbose', False)\n\n if VERBOSE:\n print(\"tol:\", tol)\n print(\"maxiter:\", maxiter)\n print(\"Ainv:\", Ainv)\n\n return tol, int(maxiter), Ainv, verbose","def __call__(self, origin, state, **kwargs):\n fun = kwargs['function']\n d = state['direction']/np.linalg.norm(state['direction'])\n # filter directions that are too large\n if self.filter:\n ndabs_log = -np.log10(np.abs(d))\n mean_log = np.mean(ndabs_log)\n #print \"\\n ** MEAN =\", mean_log\n direction = (ndabs_log > mean_log-1.5).astype(int)*d\n else:\n direction = d\n state['direction'] = direction\n## for pos, d in enumerate(direction):\n## use_dir = self.use_dirs[pos]\n## if use_dir * d < 0:\n## # directions don't match so don't move in this direction\n## direction[pos] = 0\n maxStepSize = self.maxStepSize\n if np.isscalar(maxStepSize):\n stepSize = maxStepSize\n else:\n stepfacs = np.zeros(self.dim)\n for d in range(self.dim):\n # explicit loop so as to catch any ZeroDivisionErrors\n try:\n stepfacs[d] = abs(maxStepSize[d] / direction[d])\n except ZeroDivisionError:\n # Direction is orthogonal to this parameter direction,\n # so ensure won't choose this as the minimum step size\n stepfacs[d] = Inf\n # Stop stepping with giant sizes if direction vector has strong\n # separation of scales\n stepSize = min(stepfacs)\n# print \"direction = \", direction\n# print \"step = \", step\n i = 1\n old_value = state['old_value']\n not_done = True\n# print \"** TEMP: Hardwiring step size to be 0.0005\"\n# stepSize = 0.0005\n init_step = stepSize\n while not_done:\n print(\"\\nLinestep: i =\", i, \"step size =\", stepSize, \"direction =\\n\", end='')\n print(direction)\n p = origin + i * stepSize * direction\n print(\"Testing p = \", p)\n new_value = fun(p)\n if new_value < old_value:\n i += 1\n old_value = new_value\n else:\n if i == 1:\n # don't shrink step size to be less than 1/maxReduceFac of initial\n if stepSize*self.maxReduceFac < init_step:\n not_done = False\n p = origin + (i-1) * stepSize * direction\n else:\n stepSize /= self.stepMod\n else:\n # had found a working step but it's no longer stepping to lower residuals\n not_done = False\n p = origin + (i-1) * stepSize * direction\n state['alpha_step'] = stepSize\n return p","def opt_wrapper(m, **kwargs):\r\n m.optimize(**kwargs)\r\n return m.optimization_runs[-1]","def opt_wrapper(m, **kwargs):\n m.optimize(**kwargs)\n return m.optimization_runs[-1]","def MAXED(N, sigma2, R, f_def, params):\n\n # pull out algorithm-specific parameters\n Omega = params['Omega']\n\n # create the function that we will maximize, Z\n def Z(lam, N, sigma2, R, f_def, Omega):\n \"\"\"A function, the maximization of which is equivalent to the\n maximization of \"\"\"\n\n A = - np.sum(f_def * np.exp(- np.sum((lam * R.T).T, axis=0)))\n B = - (Omega * np.sum(lam**2 * sigma2))**(0.5)\n C = - np.sum(N * lam)\n\n # negate because it's a minimization\n return - (A + B + C)\n\n # create a lambda\n lam = np.ones(len(N))\n\n # apply the simulated annealing to the Z\n mk = {'args': (N, sigma2, R, f_def, Omega)}\n lam = basinhopping(Z, lam, minimizer_kwargs=mk).x\n\n # back out the spectrum values from the lam\n return f_def * np.exp(-np.sum((lam * R.T).T, axis=0))","def test_optimalagentfinder () :\n def valNetwork (s) : \n s = s.float()\n v = reduce(model.withReluDropout, model.v[:-1], s)\n v = model.v[-1](v)\n return v\n acrobotBases = acrobotRewardBases(np.pi / 8, np.pi / 8)\n fn = random.sample(acrobotBases, k=1).pop()\n agent = findOptimalAgent(fn)\n model = agent.model\n toExternal = lambda x, y : toExternalStateRep([x, y, 0, 0])\n valFn = reduce(compose, [float, valNetwork, torch.tensor, toExternal])\n RFn = compose(fn, toExternal)\n xRange = np.arange(-np.pi, np.pi, 0.1)\n yRange = np.arange(-np.pi, np.pi, 0.1)\n plotFunction(RFn, xRange, yRange, 'theta1', 'theta2', 'R')\n plotFunction(valFn, xRange, yRange, 'theta1', 'theta2', 'V')","def Optimization(*args, **kwargs):\n from warnings import warn\n\n warn(\n \"Optimization has been renamed to OptimizationResult and will be removed as soon as v0.13.0\", DeprecationWarning\n )\n return OptimizationResult(*args, **kwargs)","def optimize(self):\n \n if self.verbose:\n print('Starting grid search with bounds: [' + \\\n ';'.join(['%5g to %5g']*len(self.steps))%tuple([(self.steps[i][0], self.steps[i][-1]) for i in range(len(self.steps))]) +']')\n\n for params in self._get_next_point():\n self.transform.set_params(params)\n\n v, _ = self.measure.value_and_derivatives(self.transform)\n\n if v < self.best_value:\n self.best_value = v\n self.best_params = params\n# print('New best value %2.4f at ('%v, ', '.join(['%8.3f']*len(params))%tuple(params), ')')\n\n self.value_history.append(v)\n self.last_value = v\n self.iteration += 1\n\n if self.report_freq > 0 and (self.iteration % self.report_freq == 0) and self.report_func is not None:\n self.report_func(self)\n\n # Set the best transform\n self.transform.set_params(self.best_params)\n self.last_value = self.best_value\n return self.best_value","def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\n return x_best, -y_best","def nn_ga_optimise_from_args(func_caller, worker_manager, max_capital, mode, mutation_op,\n crossover_op=None, options=None, reporter='default'):\n if options is None:\n reporter = get_reporter(reporter)\n options = load_options(ga_opt_args, reporter=reporter)\n options.mode = mode\n return (NNGAOptimiser(func_caller, worker_manager, mutation_op, crossover_op,\n options, reporter)).optimise(max_capital)","def produce_max(self, *args, **kwargs):\n raise NotImplementedError('This interaction has no produce_max method yet!')","def run_step_blackbox_optimizer(config,\n current_input,\n blackbox_optimizer,\n proposed_perturbations,\n finished_dnas,\n results,\n logging_data=None):\n core_hyperparameters = blackbox_optimizer.get_hyperparameters()\n function_values = [0.0] * len(proposed_perturbations)\n rewards_for_controller = []\n perturbations = proposed_perturbations\n evaluation_stats = []\n current_value_exact = 0.0\n current_value_exact_counter = 0\n\n for i in range(len(results)):\n rewards_for_controller.append(results[i]['function_value'])\n tag = results[i]['tag']\n index = 0\n if tag > 0:\n if config.est_type == 'antithetic':\n index = (tag - 1) * 2\n function_values[index] += results[i]['function_value']\n else:\n index = tag - 1\n function_values[index] += results[i]['function_value']\n if tag < 0:\n index = (-tag - 1) * 2 + 1\n function_values[index] += results[i]['function_value']\n if tag == 0:\n current_value_exact += results[i]['function_value']\n current_value_exact_counter += 1\n current_value_exact /= float(current_value_exact_counter)\n\n for result in results:\n evaluation_stat = list(result['evaluation_stat'])\n evaluation_stats.append(evaluation_stat)\n\n function_values_reshaped = np.array(function_values)\n perturbations_reshaped = np.array(perturbations)\n\n logging.info('LIST OF FUNCTION VALUES')\n logging.info(function_values_reshaped)\n\n logging.info('MAX VALUE SEEN CURRENTLY')\n logging.info(np.max(function_values_reshaped))\n\n logging.info('MEAN OF VALUES')\n logging.info(np.mean(function_values_reshaped))\n\n if logging_data is not None:\n iteration = logging_data['iteration']\n best_value = logging_data['best_value']\n iteration = logging_data['iteration']\n best_input = logging_data['best_input']\n best_core_hyperparameters = logging_data['best_core_hyperparameters']\n optimizer_state = blackbox_optimizer.get_state()\n\n if current_value_exact > best_value[0]:\n best_value[0] = current_value_exact\n best_input = current_input\n best_core_hyperparameters = core_hyperparameters\n\n # Writing logs.\n if iteration % config.log_frequency == 0:\n util.log_row(config.params_file, current_input)\n util.log_row(config.best_params_file, best_input)\n util.log_row(config.best_core_hyperparameters_file,\n best_core_hyperparameters)\n util.log_row(config.best_value_file, best_value)\n util.log_row(config.optimizer_internal_state_file, optimizer_state)\n util.log_row(config.current_values_list_file, [current_value_exact])\n util.log_row(config.best_values_list_file, [best_value[0]])\n util.log_row(config.fvalues_file, function_values_reshaped)\n util.log_row(config.iteration_file, [iteration])\n\n print('Current exact value estimate:')\n print(current_value_exact)\n sys.stdout.flush()\n\n new_current_input = blackbox_optimizer.run_step(perturbations_reshaped,\n function_values_reshaped,\n current_input,\n current_value_exact)\n config.controller.collect_rewards_and_train(rewards_for_controller,\n finished_dnas)\n\n evaluation_stats_reduced = [sum(x) for x in zip(*evaluation_stats)]\n blackbox_optimizer.update_state(evaluation_stats_reduced)\n\n return [True, new_current_input]","def run_migrad(self, fitarg, **kwargs):\n self.fitarg = fitarg\n kwargs['up'] = 1.\n\n\n logging.debug(self._par_names)\n logging.debug(self.__wrap_likelihood(list(fitarg['pinit'].values())))\n\n if kwargs['scipy']:\n self._res = op.minimize(self.__wrap_likelihood,\n list(fitarg['pinit'].values()),\n bounds=list(fitarg['limits'].values()),\n method='TNC',\n #method='Powell',\n options={'maxiter': kwargs['ncall']} #'xtol': 1e-20, 'eps' : 1e-20, 'disp': True}\n #tol=None, callback=None,\n #options={'disp': False, 'minfev': 0, 'scale': None,\n #'rescale': -1, 'offset': None, 'gtol': -1,\n #'eps': 1e-08, 'eta': -1, 'maxiter': kwargs['ncall'],\n #'maxCGit': -1, 'mesg_num': None, 'ftol': -1, 'xtol': -1, 'stepmx': 0,\n #'accuracy': 0}\n )\n logging.info(self._res)\n for i, k in enumerate(self._par_names):\n fitarg[k] = self._res.x[i]\n\n logging.debug(fitarg)\n\n cmd_string = \"lambda {0}: self.__calcLikelihood({0})\".format(\n (\", \".join(self._par_names), \", \".join(self._par_names)))\n\n string_args = \", \".join(self._par_names)\n global f # needs to be global for eval to find it\n f = lambda *args: self.__calc_likelihood(*args)\n\n cmd_string = \"lambda %s: f(%s)\" % (string_args, string_args)\n logging.debug(cmd_string)\n\n # work around so that the parameters get names for minuit\n self._minimize_f = eval(cmd_string, globals(), locals())\n self._minimize_f.errordef = minuit.Minuit.LEAST_SQUARES\n\n self._m = minuit.Minuit(self._minimize_f,\n #list(fitarg['pinit'].values()),\n **fitarg['pinit'],\n #names=self._par_names\n )\n# print_level=kwargs['verbosity'],\n# errordef=kwargs['up'],\n# pedantic=kwargs['pedantic'],\n #**fitarg)\n\n for p in self._par_names:\n self._m.fixed[p] = fitarg['fix'][p]\n self._m.limits[p] = fitarg['limits'][p]\n self._m.errors[p] = fitarg['error'][p]\n\n self._m.tol = kwargs['tol']\n self._m.strategy = kwargs['strategy']\n\n logging.debug(\"tol {0:.2e}, strategy: {1:n}\".format(\n self._m.tol, self._m.strategy.strategy))\n\n self._m.migrad(ncall=kwargs['ncall']) #, precision = kwargs['precision'])","def solve(self, **kwargs) -> OptimizationResult:\n raise NotImplementedError","def optimize(self, objective_sense=None, **kwargs):\n\n if objective_sense:\n self.objective.direction = objective_sense\n\n try:\n # self._hidden_optimize_call(kwargs)\n Model.optimize(self, **kwargs)\n solution = self.get_solution()\n self.solution = solution\n return solution\n except SolverError as SE:\n status = self.solver.status\n self.logger.error(SE)\n self.logger.warning('Solver status: {}'.format(status))\n raise (SE)","def getMaximum(self, arguments, maximum):\n\n self.sequence.append({\"type\": \"findingMaximum\", \"coords\": arguments})\n\n self.sequence.append({\"type\": \"foundMaximum\", \"coord\": maximum})","def maximize(self,x0,method='fmin',**kwargs):\n return self._optimize(x0,'max',method,**kwargs)","def _random_max_wrap(*args):\n _, opt_pt = random_maximise(*args)\n return opt_pt","def minimize_neldermead(func, x0, args=(), callback=None,\n maxiter=None, maxfev=None, disp=False,\n return_all=False, initial_simplex=None,\n xatol=1e-4, fatol=1e-4, **unknown_options):\n maxfun = maxfev\n retall = return_all\n\n rho = 1\n chi = 2\n psi = 0.5\n sigma = 0.5\n nonzdelt = 0.05\n zdelt = 0.00025\n\n if initial_simplex is None:\n N = len(x0)\n\n sim = numpy.zeros((N + 1, N), dtype=x0.dtype)\n sim[0] = x0\n for k in range(N):\n y = numpy.array(x0, copy=True)\n if y[k] != 0:\n y[k] = (1 + nonzdelt) * y[k]\n else:\n y[k] = zdelt\n sim[k + 1] = y\n\n maxiter = 10\n maxfun = 10\n\n one2np1 = list(range(1, N + 1))\n fsim = numpy.zeros((N + 1,), float)\n\n for k in range(N + 1):\n fsim[k] = func(sim[k])\n\n ind = numpy.argsort(fsim)\n fsim = numpy.take(fsim, ind, 0)\n # sort so sim[0,:] has the lowest function value\n sim = numpy.take(sim, ind, 0)\n raise Exception()\n print('aaaaffaaaaaa')\n\n iterations = 1\n\n while iterations < maxiter:\n if (numpy.max(numpy.ravel(numpy.abs(sim[1:] - sim[0]))) <= xatol and\n numpy.max(numpy.abs(fsim[0] - fsim[1:])) <= fatol):\n break\n logger.debug('itr: %s' % iterations)\n print('aaaaaaaaaa')\n xbar = numpy.add.reduce(sim[:-1], 0) / N\n xr = (1 + rho) * xbar - rho * sim[-1]\n fxr = func(xr)\n doshrink = 0\n\n if fxr < fsim[0]:\n xe = (1 + rho * chi) * xbar - rho * chi * sim[-1]\n fxe = func(xe)\n\n if fxe < fxr:\n sim[-1] = xe\n fsim[-1] = fxe\n else:\n sim[-1] = xr\n fsim[-1] = fxr\n else: # fsim[0] <= fxr\n if fxr < fsim[-2]:\n sim[-1] = xr\n fsim[-1] = fxr\n else: # fxr >= fsim[-2]\n # Perform contraction\n if fxr < fsim[-1]:\n xc = (1 + psi * rho) * xbar - psi * rho * sim[-1]\n fxc = func(xc)\n\n if fxc <= fxr:\n sim[-1] = xc\n fsim[-1] = fxc\n else:\n doshrink = 1\n else:\n # Perform an inside contraction\n xcc = (1 - psi) * xbar + psi * sim[-1]\n fxcc = func(xcc)\n\n if fxcc < fsim[-1]:\n sim[-1] = xcc\n fsim[-1] = fxcc\n else:\n doshrink = 1\n\n if doshrink:\n for j in one2np1:\n sim[j] = sim[0] + sigma * (sim[j] - sim[0])\n fsim[j] = func(sim[j])\n\n ind = numpy.argsort(fsim)\n sim = numpy.take(sim, ind, 0)\n fsim = numpy.take(fsim, ind, 0)\n if callback is not None:\n callback(sim[0])\n iterations += 1\n\n x = sim[0]\n fval = numpy.min(fsim)\n warnflag = 0\n\n result = OptimizeResult(fun=fval, nit=iterations, nfev=0,\n status=warnflag, success=(warnflag == 0),\n message=None, x=x, final_simplex=(sim, fsim))\n return result","def expectimax_move(game, method='score'):\n\n if method == 'score':\n def val(g):\n return g[1]\n elif method == 'empty':\n val = empty_squares\n elif method == 'gradient':\n val = gradient_value\n else:\n print('Invalid method given to expectimax function')\n exit(1)\n\n _, move = expectimax(game, 2, val)\n return move","def optimize(self, max_iters=1e3, messages=False, use_counter=False,\\\n factr=1e7, pgtol=1e-05):\n logger.debug('Beginning MLE to optimize hyperparams. grad_method=%s'\\\n % self.grad_method)\n\n # setup the optimization\n try:\n x0 = self._transform_parameters(self.parameters)\n assert np.all(np.isfinite(x0))\n except:\n logger.error('Transformation failed for initial values. '\\\n + 'Ensure constraints are met or the value is not too small.')\n raise\n\n # filter out the fixed parameters\n free = np.logical_not(self._fixed_indicies)\n x0 = x0[free]\n\n # setup the counter\n if use_counter:\n self._counter = solver_counter(disp=True)\n else:\n self._counter = None\n\n # run the optimization\n try:\n x_opt, f_opt, opt = fmin_l_bfgs_b(func=self._objective_grad, x0=x0,\\\n factr=factr, pgtol=pgtol, maxiter=max_iters, disp=messages)\n except (KeyboardInterrupt,IndexError):\n logger.info('Keyboard interrupt raised. Cleaning up...')\n if self._counter is not None and self._counter.backup is not None:\n self.parameters = self._counter.backup[1]\n logger.info('will return best parameter set with'\\\n + 'log-likelihood = %.4g' % self._counter.backup[0])\n else:\n logger.info('Function Evals: %d. Exit status: %s' % (f_opt, opt['warnflag']))\n # extract the optimal value and set the parameters to this\n transformed_parameters = self._previous_parameters \n transformed_parameters[free] = x_opt\n self.parameters = self._untransform_parameters(transformed_parameters)\n return opt","def poll(target, step, args=(), kwargs=None, timeout=None, max_tries=None, check_success=is_truthy,\n step_function=step_constant, ignore_exceptions=(), poll_forever=False, collect_values=None, *a, **k):\n\n logging.info('Starting Polling')\n\n assert (timeout is not None or max_tries is not None) or poll_forever, \\\n ('You did not specify a maximum number of tries or a timeout. Without either of these set, the polling '\n 'function will poll forever. If this is the behavior you want, pass \"poll_forever=True\"')\n\n assert not ((timeout is not None or max_tries is not None) and poll_forever), \\\n 'You cannot specify both the option to poll_forever and max_tries/timeout.'\n\n kwargs = kwargs or dict()\n values = collect_values or Queue()\n\n max_time = Time.time() + timeout if timeout else None\n tries = 0\n logging.debug('Max Time: ' + str(max_time))\n logging.debug('Max Tries: ' + str(max_tries))\n\n last_item = None\n while True:\n\n if max_tries is not None and tries >= max_tries:\n raise MaxCallException(values, last_item)\n\n try:\n logging.debug('Arguments: ' + str(args))\n val = target(*args, **kwargs)\n logging.debug('Results from Target running: ' + str(val))\n last_item = val\n logging.info('Try #:' + str(tries))\n DisplayMessage('Try #:' + str(tries))\n except ignore_exceptions as e:\n logging.error(str(e))\n last_item = e\n else:\n # Condition passes, this is the only \"successful\" exit from the polling function\n if check_target_success(val):\n return val\n\n logging.debug('last result from poll: ' + str(last_item))\n # Condition passes, this is the only \"successful\" exit from the polling function\n if check_target_success(val):\n return val\n else:\n values.put(last_item)\n tries += 1\n # Check the time after to make sure the poll function is called at least once\n if max_time is not None and Time.time() >= max_time:\n # raise TimeoutException(values, last_item)\n logging.info('Time out reached.')\n logging.info('Checking status of job: ' + val)\n logging.info('Job will now sleep for an additional: ' + step)\n logging.debug('Step value: ' + str(step))\n Time.sleep(step)\n step = step_function(step)","def optimise_fn(self, x):\n\n success = self._set_material_parameters(x)\n if not success:\n return self._bad_metric()\n\n # some iterations are repeated so cache the results to avoid unnecessary iterations\n cached_result_key = tuple(x)\n metric_value = self.cached_results.get(cached_result_key)\n\n if metric_value is None:\n print('--> Optimiser: {}'.format(self.material_model))\n\n sim_result = fs.run_simulation(stoma_cfg=self.stoma_cfg,\n from_optimiser=True)\n\n # when the simulation fails we want a non-constant measure for the optimiser to use\n metric_value = sim_result.metric_value if sim_result.success else self._bad_metric()\n\n self.cached_results[cached_result_key] = metric_value\n\n print('--> Optimiser: {} - metric={}'.format(self.material_model, metric_value))\n else:\n print('--> Optimiser: {} - metric={} (cached result)'.format(self.material_model, metric_value))\n\n return metric_value","def max_(*args, **kwargs):\n ...","def test_maximax():\n f = np.asarray([\n [0.99, 1.0, 0.5],\n [0.69, 0.6, 0.6]])\n R = common_metrics.maximax(f, maximise=True)\n expected = np.asarray(\n [1.0, 0.69])\n assert np.allclose(R, expected)\n R = common_metrics.maximax(f, maximise=False)\n expected = np.asarray(\n [-0.5, -0.6])\n assert np.allclose(R, expected)","def adaptive_scan(detectors, target_field, motor, start, stop,\n min_step, max_step, target_delta, backstep,\n threshold=0.8, *, md=None):\n _md = {'detectors': [det.name for det in detectors],\n 'motors': [motor.name],\n 'plan_args': {'detectors': list(map(repr, detectors)),\n 'motor': repr(motor),\n 'start': start,\n 'stop': stop,\n 'min_step': min_step,\n 'max_step': max_step,\n 'target_delta': target_delta,\n 'backstep': backstep,\n 'threshold': threshold},\n 'plan_name': 'adaptive_scan',\n }\n _md.update(md or {})\n\n @stage_decorator(list(detectors) + [motor])\n @run_decorator(md=_md)\n def adaptive_core():\n next_pos = start\n step = (max_step - min_step) / 2\n past_I = None\n cur_I = None\n cur_det = {}\n while next_pos < stop:\n yield Msg('checkpoint')\n yield Msg('set', motor, next_pos, group='A')\n yield Msg('wait', None, 'A')\n yield Msg('create', None, name='primary')\n for det in detectors:\n yield Msg('trigger', det, group='B')\n yield Msg('wait', None, 'B')\n for det in separate_devices(detectors + [motor]):\n cur_det = yield Msg('read', det)\n if cur_det is not None and target_field in cur_det:\n cur_I = cur_det[target_field]['value']\n yield Msg('save')\n\n # special case first first loop\n if past_I is None:\n past_I = cur_I\n next_pos += step\n continue\n\n dI = np.abs(cur_I - past_I)\n\n slope = dI / step\n if slope:\n new_step = np.clip(target_delta / slope, min_step, max_step)\n else:\n new_step = np.min([step * 1.1, max_step])\n\n # if we over stepped, go back and try again\n if backstep and (new_step < step * threshold):\n next_pos -= step\n step = new_step\n else:\n past_I = cur_I\n step = 0.2 * new_step + 0.8 * step\n next_pos += step\n\n return (yield from adaptive_core())","def optimize(self, iterations=1000):\r\n prev = None\r\n finalx = None\r\n finaly = None\r\n while iterations:\r\n maxei, eis = self.acquisition()\r\n new_y = self.f(maxei)\r\n if maxei == prev:\r\n break\r\n self.gp.update(maxei, new_y)\r\n pycodehack = finaly is None or self.minimize and finaly > new_y\r\n if ((pycodehack or not self.minimize and finaly < new_y)):\r\n finaly = new_y\r\n finalx = maxei\r\n prev = maxei\r\n iterations -= 1\r\n return finalx, finaly","def test_minimax_regret():\n f = np.asarray([\n [0.99, 1.0, 0.5],\n [0.69, 0.6, 0.6]])\n R = common_metrics.minimax_regret(f, maximise=True)\n expected = np.asarray(\n [-0.1, -0.4])\n assert np.allclose(R, expected)\n R = common_metrics.minimax_regret(f, maximise=False)\n expected = np.asarray(\n [-0.4, -0.1])\n assert np.allclose(R, expected)","def annealing(self, precision=None, print_steps=True):\n if self.max_temp is None:\n self.get_max_temp()\n state = self.individuals[0]\n self._temp = self.max_temp\n generation = 0\n mins = []\n while self.evaluations < self.eval_limit:\n equilibrium = False\n while not equilibrium:\n solution = self.get_neighbour(state.solution)\n value = self.get_solutions_value(solution)\n fitness = self.get_fitness(value)\n if self.acceptance_probability(state.value, value, self._temp) > np.random.random():\n equilibrium = True\n if self.evaluations % 100 == 0:\n mins += [self.best_individual.value]\n if self.evaluations > self.eval_limit:\n break\n state.solution = solution\n state.value = value\n state.fitness = fitness\n self.update_temperature()\n if state.fitness > self.best_individual.fitness:\n self.best_individual = copy.deepcopy(state)\n if print_steps:\n print(\"Generation \", generation, \"; Evaluations: \", self.evaluations,\n \"; Temperature: \", self._temp, \"; \", state)\n if precision is not None and self.solution_precision(precision):\n break\n generation += 1\n return self.best_individual, mins","def optimization_step(self):\n \n if \"CSS\" in self.algorithm:\n \n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\n \n var_list = [self.x_tilda, self.minibatch_set]\n \n if (self.num_samples > 0) and (not self.mixture):\n \n if ((self.mf_steps > 0) and self.alpha >0) or\\\n self.gibbs_steps > 0: \n \n var_list.append(self.sampler_theta)\n \n elif \"CD\" in self.algorithm:\n \n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \n \n var_list = [self.minibatch_set]\n \n var_list.append(self.learning_rate)\n \n if self.use_momentum:\n \n var_list.append(self.momentum)\n \n output_vars = [self.pseudo_cost]\n \n if self.report_p_tilda:\n \n output_vars.append(self.p_tilda)\n \n else:\n \n output_vars.append(theano.shared(0))\n \n opt_step = theano.function(inputs = var_list,\n outputs = output_vars,\n updates = self.updates,\n givens = input_dict,\n on_unused_input='warn')\n \n return opt_step","def step(self, action):\n self.steps += 1\n in_var = self.state[:4]\n\n # Increase or decrease the 4 input values\n new_var = in_var+ action \n\n #If the agent tries to exceed the range of the mins & maxes, this sets them to the max. \n for i,temp_i in enumerate(new_var):\n if (temp_i <= self.mins[i]):\n new_var[i] = self.mins[i]\n elif (temp_i >= self.maxes[i]): \n new_var[i] = self.maxes[i]\n\n in_var = new_var\n\n # Get all the new outputs:\n self.ins = in_var\n out_flow = self.temp_func(var=self.O_CH4_flow_uniformity)\n out_frac = self.temp_func(var=self.O_CH4_mol_frac)\n out_temp = self.temp_func(var=self.O_t)\n\n #check that this is a viable output; if not, reject the action\n #is this temp change viable?\n \n MSE1 = (self.goals[0]-out_flow)**2\n MSE2 = (self.goals[1]-out_frac)**2\n MSE3 = (self.goals[2]-out_temp)**2\n\n MSE = MSE1 + MSE2 + MSE3\n\n # Update your state:\n state_new = np.append(self.ins,[out_flow,out_frac,out_temp] )\n self.state =np.append(state_new,self.goals)\n\n done = ((MSE1 <= self.MSE_thresh1) & (MSE2 <= self.MSE_thresh2) & (MSE3 <= self.MSE_thresh3))\n done = bool(done)\n\n # Get the corresponding reward:\n reward = 0\n if done:\n reward += self.rew_goal\n else: \n reward -= MSE *cfg['MSE_scale']\n\n self.reward = reward\n self.tot_rew += reward\n self.done = done\n\n return (self.state, reward, done, {'MSE thresh': self.MSE_thresh1})","def solve(self, example_name, max_iter = 100, is_check_stop = True, maximum_line_search = 10):\n logger.debug(\"[+ +] Initial Obj.Val.: %.5e\"%(self.get_obj_fun_value()))\n start_time = tm.time()\n for i in range(max_iter):\n if i == 1: # skip the compiling time \n start_time = tm.time()\n iter_start_time = tm.time()\n self.backward_pass()\n backward_time = tm.time()\n obj, isStop = self.forward_pass(max_line_search=maximum_line_search)\n forward_time = tm.time()\n logger.debug(\"[+ +] Iter.No.%3d BWTime:%.3e FWTime:%.3e Obj.Val.:%.5e\"%(\n i, backward_time-iter_start_time,forward_time-backward_time,obj))\n result_path = os.path.join(\"logs\", example_name, str(i) +\".mat\")\n io.savemat(result_path,{\"trajectory\": self.get_traj()})\n if isStop and is_check_stop:\n break\n end_time = tm.time()\n logger.debug(\"[+ +] Completed! All Time:%.5e\"%(end_time-start_time))","def optimize(self, X, y, *args):\n self.loss_function.set_space(X, y, *args)\n self.betas_ = fastgradalgo(\n self.loss_function,\n t_init=self.eta_init,\n max_iter=self.max_iter\n )\n return self.betas_","def _optimize(self,x0,type,method,**kwargs):\n from scipy.optimize import fmin,fmin_powell\n\n if type == 'min':\n g=lambda x:self(x)\n elif type == 'max':\n g=lambda xs:-1*self(x)\n elif type == 'root':\n g=lambda x:np.abs(self(x))\n elif type == 'val':\n val = kwargs.pop('valtofind')\n g=lambda x:np.abs(self(x)-val)\n elif type == 'saddle':\n raise NotImplementedError\n else:\n raise ValueError('Unrecognized optimization type')\n\n if method == 'fmin':\n res = fmin(g,x0,**kwargs)\n elif method == 'fmin_powell':\n res = fmin_powell(g,x0,**kwargs)\n else:\n raise ValueError('Unrecognized method')\n\n self.lastOpt = res\n return res[0]","def minimax(self, game, depth):\n if self.time_left() < self.TIMER_THRESHOLD:\n raise SearchTimeout()\n\n \"\"\"\n From AIMA psuedocode:\n\n function MINIMAX-DECISION(state) returns an action\n return arg max a is in ACTIONS(s) MIN-VALUE(RESULT(state, a))\n \"\"\"\n\n best_move = (-1,-1)\n best_score = float(\"-inf\")\n actions = game.get_legal_moves()\n\n if not actions:\n return best_move\n else:\n best_move = actions[randint(0, len(actions) - 1)]\n\n try:\n # The try/except block will automatically catch the exception\n # raised when the timer is about to expire.\n # return max(actions, key=lambda action: self._min_value(game.forecast_move(action), 1))\n for action in actions:\n score = self._min_value(game.forecast_move(action), 1)\n if score > best_score:\n best_score = score\n best_move = action\n\n except SearchTimeout:\n pass\n\n return best_move","def walk_single_walker(at, movement_args, Emax, KEmax):\n#DOC\n#DOC ``walk_single_walker``\n\n out = {}\n\n if movement_args['do_good_load_balance']:\n possible_moves = np.array( [ do_atom_walk,\n do_MC_cell_volume_step,\n do_MC_cell_shear_step,\n do_MC_cell_stretch_step,\n do_MC_swap_step,\n do_MC_semi_grand_step ] )\n nums = np.array( [ movement_args['n_atom_steps_n_calls'],\n movement_args['n_cell_volume_steps'],\n movement_args['n_cell_shear_steps'],\n movement_args['n_cell_stretch_steps'],\n movement_args['n_swap_steps'],\n movement_args['n_semi_grand_steps'] ] )\n costs = np.array( [ movement_args['atom_traj_len']*movement_args['atom_traj_len_cost_multiplier'],\n 1,\n 1,\n 1,\n 1,\n 1 ] )\n\n list = create_list(costs, nums, movement_args['n_model_calls'])\n for move_i in list:\n (t_n_model_calls, t_out) = possible_moves[move_i](at, movement_args, Emax, KEmax)\n accumulate_stats(out, t_out)\n\n else:\n #DOC \\item create list\n #DOC \\item do\\_atom\\_walk :math:`*` n\\_atom\\_step\\_n\\_calls\n possible_moves = ( [do_atom_walk] * movement_args['n_atom_steps_n_calls'] +\n #DOC \\item do\\_cell\\_volume\\_step :math:`*` n\\_cell\\_volume\\_steps\n [do_MC_cell_volume_step] * movement_args['n_cell_volume_steps'] + \n #DOC \\item do\\_cell\\_shear\\_step :math:`*` n\\_cell\\_shear\\_steps\n [do_MC_cell_shear_step] * movement_args['n_cell_shear_steps'] + \n #DOC \\item do\\_cell\\_stretch\\_step :math:`*` n\\_cell\\_stretch\\_steps\n [do_MC_cell_stretch_step] * movement_args['n_cell_stretch_steps'] + \n #DOC \\item do\\_swap\\_step :math:`*` n\\_swap\\_steps\n [do_MC_swap_step] * movement_args['n_swap_steps'] +\n #DOC \\item do\\_semi\\_grand\\_step :math:`*` n\\_semi\\_grand\\_steps\n [do_MC_semi_grand_step] * movement_args['n_semi_grand_steps'] )\n\n out = {}\n n_model_calls_used=0\n\n #DOC \\item loop while n\\_model\\_calls\\_used < n\\_model\\_calls\n while n_model_calls_used < movement_args['n_model_calls']:\n #DOC \\item pick random item from list\n move = possible_moves[rng.int_uniform(0,len(possible_moves))]\n #DOC \\item do move\n (t_n_model_calls, t_out) = move(at, movement_args, Emax, KEmax)\n n_model_calls_used += t_n_model_calls\n accumulate_stats(out, t_out)\n\n\n #DOC \\item perturb final energy by random\\_energy\\_perturbation\n # perturb final energy\n at.info['ns_energy'] = rand_perturb_energy(at.info['ns_energy'],ns_args['random_energy_perturbation'],Emax)\n\n #DEBUG print \"walk_single_walker end \", eval_energy(at, do_PE=False), eval_energy(at) #DEBUG\n\n return out","def run_qae_optimization(training_states, n_repetitions, exact=no_noise, noisy=gate_error):\n result_list = []\n def proxy(params, training_states, n_repetitions, exact=no_noise, noisy=gate_error):\n \"\"\"Embedded function version\n \"\"\"\n input_list = fix_list(params, all_param_array=all_param, var_param_array=var_param, fixed_vals_array=fixed_vals)\n fidelities = []\n for training_state in training_states:\n fid = cusp_stage2.compute_stage2_cost_function(*input_list, alpha=training_state, n_repetitions=n_repetitions,\n exact=exact, noisy=noisy)\n fidelities.append(fid)\n avg_fid = np.mean(fidelities)\n result_list.append(1-avg_fid)\n print(1-avg_fid)\n return 1. - avg_fid\n\n \n # Initialize parameters\n half_turn_min = 0\n half_turn_max = 2\n init_params = np.random.uniform(low=half_turn_min, high=half_turn_max,\n size=num_param)\n\n # Optimization using Nelder-Mead.\n h2_qae_wrap = lambda params: proxy(params, training_states=training_states,\n n_repetitions=n_repetitions, exact=exact, noisy=noisy)\n \n if noisy:\n maxiter = 60\n else:\n maxiter = None\n \n res = minimize(h2_qae_wrap, init_params, args=(),\n method='Nelder-Mead', tol=None, \n options={'disp': False, 'maxiter': maxiter, 'xatol': 0.001,\n 'return_all': False, 'fatol': 0.001})\n np.savetxt('stage2_data.csv',result_list, delimiter=',')\n return res.x","def minimax(self, gameState, depth, index):\n ultimateMove = None # The best move the agent can use\n if depth == 0 or gameState.isWin() or gameState.isLose():\n # if leaf node return value.\n return [self.evaluationFunction(gameState), ultimateMove]\n else:\n if index == 0: # if pacman => agent is max agent\n value = -math.inf\n maxValue = value\n # iterates through max agent w/index=0 moves\n for action in gameState.getLegalActions(0):\n depthIndex = agentCounter(gameState, index+1, depth)\n successorState = gameState.generateSuccessor(\n index, action) # generates the next state when move is done\n value = max(value, minimax(\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return max of saved value and recursive function\n if maxValue != value: # If value has changed update values\n ultimateMove = action\n maxValue = value\n return [value, ultimateMove]\n else: # is ghost => agent is min agent\n value = math.inf\n minValue = value\n # Iterate through the moves of a min agent w/index not 0\n for action in gameState.getLegalActions(index):\n depthIndex = agentCounter(gameState, index+1, depth)\n successorState = gameState.generateSuccessor(\n index, action)\n value = min(value, minimax(\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return min of saved value and recursive function\n if minValue != value: # If value has changed update values\n ultimateMove = action\n minValue = value\n return [value, ultimateMove]","def evaluate(Agent, rules, wrappers, params_path=None, steps=1024):\n\n score = 0.0\n\n agent = Agent()\n\n if params_path is not None:\n agent.load_state_dict(params_path)\n\n env = CARLE()\n\n\n for wrapper in wrappers:\n env = wrapper[0](env)\n env.reward_scale = wrapper[1]\n\n env.batch_size = steps*len(rules)\n\n if wrapper[2] is not None:\n env.load_state_dict(torch.load(wrapper[2]))\n\n env.eval()\n\n #env.set_no_grad()\n\n total_steps = 0\n score_trace = []\n for ruleset in rules:\n\n env.inner_env.birth = ruleset[0]\n env.inner_env.survive = ruleset[0]\n\n obs = env.reset()\n\n for step in range(steps):\n\n action = agent(obs)\n\n obs, reward, done, info = env.step(action)\n\n score += reward.detach().sum().cpu().numpy()\n score_trace.append(reward.detach().sum().cpu().numpy())\n\n total_steps += 1\n\n print(\"cumulative score = {:.3e} at total steps = {}, rulset = {}\".format(\\\n score, total_steps, ruleset))\n\n score /= total_steps\n \n return score, score_trace","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n # AlphaBetaAgent.callsCount = 0\n # If the game state is lost or win then just return the evaluation value\n if gameState.isLose() or gameState.isWin():\n return self.evaluationFunction(gameState)\n\n # This part is almost the same with MinimaxAgent other than two additional parameters of alpha and beta values\n # by recursion calls in MiniMax tree to make a decision\n # alpha = the best choice of the highest values we have found so far along the path for MAX.\n # (initializes -9999999)\n # beta = the best choice of the lowest values we have found so far along the path for MIN.\n # (initializes +9999999)\n\n finalDirection = self.maxValueAlphaBeta(gameState, self.depth * gameState.getNumAgents(), gameState.getNumAgents(), 0, -9999999, 9999999)\n # print(\"Number of Calls: \", AlphaBetaAgent.callsCount)\n return finalDirection[1]\n\n # The helper function to remove STOP action to improve efficiency\n def removeStop(self, legalMoves):\n stopDirection = Directions.STOP\n if stopDirection in legalMoves:\n legalMoves.remove(stopDirection)\n\n # The maxValue method for PacMan whose agent index is zero\n def maxValueAlphaBeta(self, gameState, depth, numOfAgents, agentIndex, alpha, beta):\n # AlphaBetaAgent.callsCount += 1\n legalMoves = gameState.getLegalActions(agentIndex)\n self.removeStop(legalMoves)\n # The next states, either passed in to getAction or generated via GameState.generateSuccessor\n nextStates = [gameState.generateSuccessor(agentIndex, action) for action in legalMoves]\n if depth == 0 or len(nextStates) == 0:\n return (self.evaluationFunction(gameState), Directions.STOP)\n\n maxValue = -9999999\n action = legalMoves[0]\n moveIndex = 0\n chooseMax = []\n\n # There are only one case to call minValue from Pacman perspective\n for nextState in nextStates:\n res = self.minValueAlphaBeta(nextState, depth-1, numOfAgents-2, numOfAgents, (agentIndex+1)%numOfAgents, alpha, beta)\n chooseMax.append(res)\n if res > maxValue:\n maxValue = res\n action = legalMoves[moveIndex]\n # Check \"cut-off\" condition\n if res > alpha: # If alpha is smaller than the current Max value\n alpha = res # Then replace alpha with the current Max value\n if alpha >= beta: # When alpha value is larger than beta value\n return (alpha, action) # beta cut-off\n moveIndex = moveIndex + 1\n return (maxValue, action)","def optimize(start, stop, step):\n #Go through every angle\n rot_angle_list = np.arange(start, stop, step)\n fitness_list = []\n best_angles_list = []\n for (i, rot_angle) in enumerate(rot_angle_list):\n (fitness, best_angles) = self._angle_fitness(rot_angle, initial_R, ending_vec, starting_vec)\n fitness_list.append(fitness)\n best_angles_list.append(best_angles)\n #Find the best result\n best_index = np.argmin(fitness_list)\n best_rot_angle = rot_angle_list[best_index]\n best_angles = best_angles_list[best_index]\n return (best_rot_angle, best_angles)","def step_func_cat(X, args, Y, info, Ytarget, err, tols, iter, maxIter):\n [XF, ZF, L, EA, W, CB, WL, WEA, L_EA, CB_EA] = args[\"cat\"]\n\n # if abs( err[1] + ZF ) < 0.0001:\n # breakpoint()\n\n [alpha_min, alpha0, alphaR] = args[\n \"step\"\n ] # get minimum alpha, initial alpha, and alpha reduction rate from passed arguments\n\n # J = info['jacobian']\n # dX = -np.matmul(np.linalg.inv(J), err)\n dX = -np.matmul(info[\"stiffnessB\"], err)\n\n # ! Reduce dHF by factor (between 1 at I = 1 and 0 at I = MaxIter) that reduces linearly with iteration count\n # to ensure that we converge on a solution even in the case were we obtain a nonconvergent cycle about the\n # correct solution (this happens, for example, if we jump to quickly between a taut and slack catenary)\n\n alpha = 1.0 # M<<<<<<<< np.max([alpha_min, alpha0*(1.0 - alphaR*iter/maxIter)])\n\n # exponential approach alpha = alpha0 * np.exp( iter/maxIter * np.log(alpha_min/alpha0 ) )\n\n dX[0] = dX[0] * alpha # dHF*( 1.0 - Tol*I )\n dX[1] = dX[1] * alpha # dVF*( 1.0 - Tol*I )\n\n # To avoid an ill-conditioned situation, make sure HF does not go less than or equal to zero by having a lower limit of Tol*HF\n # [NOTE: the value of dHF = ( Tol - 1.0 )*HF comes from: HF = HF + dHF = Tol*HF when dHF = ( Tol - 1.0 )*HF]\n # dX[0] = max( dX[0], ( tol - 1.0 )*info['HF']);\n\n # To avoid an ill-conditioned situation, make sure HF does not get too close to zero, by forcing HF >= tols[0]\n # if info['HF'] + dX[0] <= tol*abs(info['VF']+dX[1]):\n # if info['HF'] + dX[0] <= tols[0]\n if X[0] + dX[0] <= tols[0]:\n # dX[0] = tol*abs(info['VF']+dX[1]) - info['HF']\n # dX[0] = tols[0] - info['HF']\n dX[0] = tols[0] - X[0]\n\n # To avoid an ill-conditioned situation where the line is nearly all on the seabed but the solver gets stuck,\n # if np.abs(err[1] + ZF)/ZF < tol:\n # breakpoint()\n # deltaHFVF = info['HF'] - info['VF']\n # dX[0] = dX[0] - 0.5*deltaHFVF\n # dX[1] = dX[1] + 0.5*deltaHFVF\n\n # prevent silly situation where a line with weight and positive ZF considers a negative VF\n if info[\"ProfileType\"] == 2:\n if X[1] + dX[1] <= tols[1]: # if vertical force is within tolerance of being zero/negative\n VFtarget = (L - info[\"LBot\"]) * W # set next VF value to be the weight of portion of line that's suspended\n dX[1] = VFtarget - X[1]\n\n return dX # returns dX (step to make)","def optimizing(theta, data = data, target = target):\n # num = (sin(individual[0] - individual[1] / 8))**2 + (sin(individual[1] + individual[0] / 8))**2\n # denum = ((individual[0] - 8.6998)**2 + (individual[1] - 6.7665)**2)**0.5 + 1\n learner = MLPClassifier(hidden_layer_sizes=theta[0], learning_rate_init=theta[1], alpha=theta[2], verbose=True, early_stopping=True, n_iter_no_change=6)\n\n model = learner.fit(data, target)\n return model.best_loss_ # return the best error/residual (best error is cloes to zero) The error of a model is the difference between your predicted outcome and the real observed outcome and therefore 0 is desired\n\n # individual as a factor containing x, y = to tetha which ","def heuristics(e, z, z0, direction):\n\n from sympy.calculus.util import AccumBounds\n rv = None\n if abs(z0) is S.Infinity:\n rv = limit(e.subs(z, 1 / z), z, S.Zero, 1 if z0 is S.Infinity else -1)\n if isinstance(rv, Limit):\n return\n elif e.is_Mul or e.is_Add or e.is_Pow or e.is_Function:\n r = []\n for a in e.args:\n l = limit(a, z, z0, direction)\n if l.has(S.Infinity) and l.is_finite is None:\n if isinstance(e, Add):\n m = factor_terms(e)\n if not isinstance(m, Mul): # try together\n m = together(m)\n if not isinstance(m, Mul): # try factor if the previous methods failed\n m = factor(e)\n if isinstance(m, Mul):\n return heuristics(m, z, z0, direction)\n return\n return\n elif isinstance(l, Limit):\n return\n elif l is S.NaN:\n return\n else:\n r.append(l)\n if r:\n rv = e.func(*r)\n if rv is S.NaN and e.is_Mul and any(isinstance(rr, AccumBounds) for rr in r):\n r2 = []\n e2 = []\n for ii in range(len(r)):\n if isinstance(r[ii], AccumBounds):\n r2.append(r[ii])\n else:\n e2.append(e.args[ii])\n\n if len(e2) > 0:\n from sympy import simplify\n e3 = simplify(Mul(*e2))\n l = limit(e3, z, z0, direction)\n rv = l * Mul(*r2)\n\n if rv is S.NaN:\n try:\n rat_e = ratsimp(e)\n except PolynomialError:\n return\n if rat_e is S.NaN or rat_e == e:\n return\n return limit(rat_e, z, z0, direction)\n return rv","def mod_space_opt(\n *,\n space,\n dryness_method,\n fuel_build_up_method,\n include_temperature,\n discrete_params,\n defaults=None,\n basinhopping_options=None,\n minimizer_options=None,\n mode=\"basinhopping\",\n x0=None,\n):\n to_optimise = gen_to_optimise(\n fail_func=fail_func,\n success_func=success_func,\n # Init (data) params.\n dryness_method=dryness_method,\n fuel_build_up_method=fuel_build_up_method,\n include_temperature=include_temperature,\n _uncached_data=False,\n **discrete_params,\n )\n\n defaults_dict = defaults if defaults is not None else {}\n\n def to_optimise_with_discrete(x):\n return to_optimise(\n **space.inv_map_float_to_0_1(dict(zip(space.continuous_param_names, x))),\n **defaults_dict,\n )\n\n def basinhopping_callback(x, f, accept):\n # NOTE: Parameters recorded here are authoritative, since hyperopt will not\n # properly report values modified as in e.g. `mod_quniform`.\n values = {\n **space.inv_map_float_to_0_1(dict(zip(space.continuous_param_names, x))),\n **discrete_params,\n **defaults_dict,\n }\n values[\"dryness_method\"] = dryness_method\n values[\"fuel_build_up_method\"] = fuel_build_up_method\n values[\"include_temperature\"] = include_temperature\n\n minimizer_options_dict = minimizer_options if minimizer_options is not None else {}\n basinhopping_options_dict = (\n basinhopping_options if basinhopping_options is not None else {}\n )\n\n if x0 is None:\n x0 = space.continuous_x0_mid\n\n if mode == \"basinhopping\":\n res = basinhopping(\n to_optimise_with_discrete,\n x0=x0,\n seed=0,\n callback=basinhopping_callback,\n take_step=BoundedSteps(\n stepsize=0.3, rng=np.random.default_rng(0), verbose=True\n ),\n **{\n \"disp\": True,\n \"minimizer_kwargs\": dict(\n method=\"L-BFGS-B\",\n jac=None,\n bounds=[(0, 1)] * len(space.continuous_param_names),\n options={\n \"maxiter\": 60,\n \"ftol\": 1e-5,\n \"eps\": 1e-3,\n **minimizer_options_dict,\n },\n ),\n \"T\": 0.05,\n \"niter\": 100,\n \"niter_success\": 15,\n **basinhopping_options_dict,\n },\n )\n elif mode == \"minimize\":\n res = minimize(\n to_optimise_with_discrete,\n x0=x0,\n method=\"L-BFGS-B\",\n jac=None,\n bounds=[(0, 1)] * len(space.continuous_param_names),\n options={\n \"maxiter\": 60,\n \"ftol\": 1e-5,\n \"eps\": 1e-3,\n **minimizer_options_dict,\n },\n )\n else:\n raise ValueError\n\n return res","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n\n def MaxValue(gameState, currentDepth, agentNumber):\n \n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\n \n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\n return (self.evaluationFunction(gameState), Directions.NORTH)\n #print 'depth ',currentDepth\n \n largestValue = float(\"-inf\")\n bestAction = Directions.NORTH\n for action in gameState.getLegalActions(agentNumber):\n #print 'analyzing ',action,' for pacman ',agentNumber\n successor = gameState.generateSuccessor(agentNumber, action)\n successorValue = MinValue(successor, currentDepth, (agentNumber + 1) % gameState.getNumAgents())[0]\n if(successorValue > largestValue):\n largestValue = successorValue\n bestAction = action\n return (largestValue, bestAction)\n \n def MinValue(gameState, currentDepth, agentNumber):\n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\n return (self.evaluationFunction(gameState), Directions.NORTH)\n \n #print 'depth ',currentDepth\n \n smallestValue = float(\"inf\")\n bestAction = Directions.NORTH \n for action in gameState.getLegalActions(agentNumber):\n #print 'analyzing ',action,' for ghost ',agentNumber\n successor = gameState.generateSuccessor(agentNumber, action)\n nextAgentNumber = (agentNumber + 1) % gameState.getNumAgents()\n if nextAgentNumber is 0:\n successorValue = MaxValue(successor, currentDepth + 1, nextAgentNumber)[0]\n else:\n successorValue = MinValue(successor, currentDepth, nextAgentNumber)[0]\n if(successorValue < smallestValue):\n smallestValue = successorValue\n bestAction = action\n return (smallestValue, bestAction)\n\n result = MaxValue(gameState, 0, 0)\n resultActionToTake = result[1]\n #print 'Minimax value for depth ', self.depth,' ',result[0]\n #import time\n #time.sleep(1000000)\n return resultActionToTake","def best_metric(\n self, return_step: bool = False\n ) -> Union[\n None,\n float,\n Tuple[float, int],\n Tuple[None, None],\n Dict[str, Union[float, None]],\n Tuple[Dict[str, Union[float, None]], Dict[str, Union[int, None]]],\n ]:\n res = self.compute_all()\n if isinstance(res, list):\n rank_zero_warn(\n \"Encounted nested structure. You are probably using a metric collection inside a metric collection, or\"\n \" a metric wrapper inside a metric collection, which is not supported by `.best_metric()` method.\"\n \"Returning `None` instead. Please consider \"\n )\n if return_step:\n return None, None\n return None\n\n if isinstance(self._base_metric, Metric):\n fn = torch.max if self.maximize else torch.min\n try:\n value, idx = fn(res, 0)\n if return_step:\n return value.item(), idx.item()\n return value.item()\n except (ValueError, RuntimeError) as error:\n rank_zero_warn(\n f\"Encountered the following error when trying to get the best metric: {error}\"\n \"this is probably due to the 'best' not being defined for this metric.\"\n \"Returning `None` instead.\",\n UserWarning,\n )\n if return_step:\n return None, None\n return None\n\n else: # this is a metric collection\n maximize = self.maximize if isinstance(self.maximize, list) else len(res) * [self.maximize]\n value, idx = {}, {}\n for i, (k, v) in enumerate(res.items()):\n try:\n fn = torch.max if maximize[i] else torch.min\n out = fn(v, 0)\n value[k], idx[k] = out[0].item(), out[1].item()\n except (ValueError, RuntimeError) as error: # noqa: PERF203 # todo\n rank_zero_warn(\n f\"Encountered the following error when trying to get the best metric for metric {k}:\"\n f\"{error} this is probably due to the 'best' not being defined for this metric.\"\n \"Returning `None` instead.\",\n UserWarning,\n )\n value[k], idx[k] = None, None\n\n if return_step:\n return value, idx\n return value","def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\r\n\r\n\t\r\n\tif grad == 'NO':\r\n\t\tif method == 'Powell' :\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'Nelder-Mead':\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t options = {'ftol': 0.0001})\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'default':\r\n\t\t\tres = opt.minimize(Ulike,init_par, \r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\r\n\telif grad == 'YES':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \r\n \t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\r\n\t\treturn res.x, res.nit \r\n\t\t\t\r\n\t\t\r\n\telif grad == 'HESS':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\r\n\t\t\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \r\n\t\treturn res.x, res.nit","def maxlikelihood(self):\n\n chi2 = lambda *args: -2 * lnlikelihood.lnlike(*args) \n # print('***DEBUGGING*** chi2 = ', chi2)\n # print('***DEBUGGING*** self.theta_guess = ', self.theta_guess)\n # print('***DEBUGGING*** self.transinfo = ', self.transinfo)\n # print('***DEBUGGING*** self.wave_b = ', self.wave_b)\n # print('***DEBUGGING*** self.flux_b = ', self.flux_b)\n # print('***DEBUGGING*** self.err_b = ', self.err_b)\n # print('***DEBUGGING*** self.wave_r = ', self.wave_r)\n # print('***DEBUGGING*** self.flux_r = ', self.flux_r)\n # print('***DEBUGGING*** self.err_r = ', self.err_r)\n # print('***DEBUGGING*** self.velres = ', self.velres)\n result = op.minimize(chi2, self.theta_guess,\n args=(self.transinfo, self.wave_b, self.flux_b, self.err_b,\n self.wave_r, self.flux_r, self.err_r, self.velres))\n\n self.theta_ml = result[\"x\"]","def minimize_nelder_mead(\n objective_func, parameter_guess, verbose=False, which_vars=None, **kwargs\n):\n # Specify a temporary \"modified objective function\" that restricts parameters to be estimated\n if which_vars is None:\n which_vars = np.ones(len(parameter_guess), dtype=bool)\n\n def objective_func_mod(params):\n params_full = np.copy(parameter_guess)\n params_full[which_vars] = params\n out = objective_func(params_full)\n return out\n\n # convert parameter guess to np array to slice it with boolean array\n parameter_guess_mod = np.array(parameter_guess)[which_vars]\n\n # Execute the minimization, starting from the given parameter guess\n t0 = time() # Time the process\n OUTPUT = fmin(\n objective_func_mod, parameter_guess_mod, full_output=1, disp=verbose, **kwargs\n )\n t1 = time()\n\n # Extract values from optimization output:\n xopt = OUTPUT[0] # Parameters that minimize function.\n fopt = OUTPUT[1] # Value of function at minimum: ``fopt = func(xopt)``.\n optiter = OUTPUT[2] # Number of iterations performed.\n funcalls = OUTPUT[3] # Number of function calls made.\n warnflag = OUTPUT[4] # warnflag : int\n # 1 : Maximum number of function evaluations made.\n # 2 : Maximum number of iterations reached.\n # Check that optimization succeeded:\n if warnflag != 0:\n warnings.warn(\n \"Minimization failed! xopt=\"\n + str(xopt)\n + \", fopt=\"\n + str(fopt)\n + \", optiter=\"\n + str(optiter)\n + \", funcalls=\"\n + str(funcalls)\n + \", warnflag=\"\n + str(warnflag)\n )\n xopt_full = np.copy(parameter_guess)\n xopt_full[which_vars] = xopt\n\n # Display and return the results:\n if verbose:\n print(\"Time to estimate is \" + str(t1 - t0) + \" seconds.\")\n return xopt_full","def optimize(maxiter: int = 1000,\n tol = None,\n save_steps: int = 1,\n c0: float = 0.62,\n c1: float = 0.1,\n c2: float = 0.602,\n c3: float = 0.101,\n c4: float = 0):\n _spsa_vars = [c0, c1, c2, c3, c4]\n theta = self.vectorizer.vector\n nb_params = len(theta)\n use_exact_grads = 'grads' in self._method\n \n if save_steps:\n theta_vec = [theta]\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\n \n \n pbar = tqdm(total=maxiter, disable=not self.progbar)\n def callback(_):\n pbar.clear()\n pbar.update()\n val = round(self.loss, 5)\n pbar.set_description(str(val))\n\n if self.loss_target is not None:\n if self.loss < self.loss_target:\n # returning True doesn't terminate optimization\n pbar.close()\n raise KeyboardInterrupt\n \n for ii in range(maxiter):\n \n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\n delta = 2 * randint(0, 2, size=nb_params) - 1\n # plus and minus directions\n \n if use_exact_grads:\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\n else:\n theta_plus = theta + c_spsa * delta\n theta_minus = theta - c_spsa * delta\n\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\n # derivative estimate\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\n # updated theta\n theta = theta - a_spsa * g_spsa\n \n callback(ii)\n \n if tol is not None:\n if (cost_plus + cost_minus)/2 < tol:\n pbar.close()\n break\n \n if save_steps:\n theta_vec.append(theta)\n cost_vec.append(cost_plus/2+cost_minus/2)\n \n \n result_dict = {'hyper_parameters':_spsa_vars,\n 'maxiter':maxiter,\n 'theta_opt':theta,\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\n if save_steps:\n result_dict['theta_history'] = theta_vec\n result_dict['cost_history'] = cost_vec\n self.result_dict = result_dict\n pbar.close()\n\n return self.inject_res_vector_and_return_tn()","def optimize(opt, target, n_agents, n_variables, n_iterations, lb, ub, hyperparams):\n\n # Creating the SearchSpace\n space = SearchSpace(n_agents=n_agents, n_variables=n_variables,\n n_iterations=n_iterations, lower_bound=lb, upper_bound=ub)\n\n # Creating the Function\n function = Function(pointer=target)\n\n # Creating Optimizer\n if opt.__name__ is not 'BH':\n optimizer = opt(hyperparams=hyperparams)\n else:\n optimizer = opt()\n\n # Creating the optimization task\n task = Opytimizer(space=space, optimizer=optimizer, function=function)\n\n return task.start(store_best_only=True)","def estimate_motion(self, time, intensity_grid, max_u, max_v):\n ti = np.where(time == self.times)[0][0]\n mask_vals = np.where(self.masks[ti].ravel() == 1)\n i_vals = self.i[ti].ravel()[mask_vals]\n j_vals = self.j[ti].ravel()[mask_vals]\n obj_vals = self.timesteps[ti].ravel()[mask_vals]\n u_shifts = np.arange(-max_u, max_u + 1)\n v_shifts = np.arange(-max_v, max_v + 1)\n min_error = 99999999999.0\n best_u = 0\n best_v = 0\n for u in u_shifts:\n j_shift = j_vals - u\n for v in v_shifts:\n i_shift = i_vals - v\n if np.all((0 <= i_shift) & (i_shift < intensity_grid.shape[0]) &\n (0 <= j_shift) & (j_shift < intensity_grid.shape[1])):\n shift_vals = intensity_grid[i_shift, j_shift]\n else:\n shift_vals = np.zeros(i_shift.shape)\n # This isn't correlation; it is mean absolute error.\n error = np.abs(shift_vals - obj_vals).mean()\n if error < min_error:\n min_error = error\n best_u = u * self.dx\n best_v = v * self.dx\n # 60 seems arbitrarily high\n # if min_error > 60:\n # best_u = 0\n # best_v = 0\n self.u[ti] = best_u\n self.v[ti] = best_v\n return best_u, best_v, min_error","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n # Again, we use the fundamental foundation built in Q2 for Q4, however here we modify our minimizer function\n # to serve the purpose of finding the expected value\n actionList = gameState.getLegalActions(0)\n pacmanAgentIndex = 0\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\n count = util.Counter()\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\n def maximizer(curState, agentIndex, depth):\n\n ghostActions = curState.getLegalActions(agentIndex)\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\n weight = -99999999 # Worst case starting value to be changed in the code\n if depth == maxDepth: # If we are at a leaf node\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\n # Otherwise, we progress the tree until the above condition is reached\n if len(ghostActions) != 0:\n for x in ghostActions:\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth):\n weight = weight\n else:\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth)\n return weight\n else:\n # if there are no legal actions left then evaluate at the last known state\n return self.evaluationFunction(curState)\n\n def minimizer(curState, agentIndex, depth):\n ghostActions = curState.getLegalActions(agentIndex)\n weight = 0 # Starting value of zero to be incremented below\n if len(ghostActions) != 0:\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\n for x in ghostActions: # For each legal action in the current position\n temp = (float(1.0) / len(ghostActions))*maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, depth+1)\n weight = weight + temp\n else: # Otherwise, we continue to minimize\n for x in ghostActions: # For each legal action in the current position\n temp = (float(1.0) / len(ghostActions))*minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\n weight = weight + temp\n return weight\n else:\n # if there are no legal actions left then evaluate at the last known state\n return self.evaluationFunction(curState)\n\n # Executing the minimizer for all possible actions\n for x in actionList:\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\n count[x] = minimizer(tempState,1,0)\n # print('HELLO THERE')\n # print(count)\n return count.argMax()","def custom_method(*args, **kwargs):\n return objective_return","def custom_method(*args, **kwargs):\n return objective_return","def maximum(x, y):\r\n # see decorator for function body\r","def do_optimisation(self):\n\n print('--> Parameters for optimisation:')\n print('--> Using measurements : {}'.format(self.stoma_cfg.comparison_helper.optimisation_keys))\n print('')\n\n x0 = self.initial_guess()\n\n tol, eps = 1e-4, 0.001\n\n print('--> Using SLSQP with tol={} and eps={}'.format(tol, eps))\n\n soln = opt.minimize(fun=self.optimise_fn,\n x0=x0,\n method='SLSQP',\n tol=tol,\n options={'eps': eps})\n\n print('*' * 120)\n print('--> Optimisation procedure has finished...')\n print(soln)\n print('*' * 120)\n\n if soln.success:\n print('--> Optimisation succeeded. Result is...')\n self._set_material_parameters(soln.x)\n print('--> {}'.format(self.material_model))\n else:\n print('--> The optimisation failed!')\n\n print('*' * 120)\n\n return soln","def solve(self, topology, algorithm=\"SLSQP\", grad=\"AD\", step_size=1e-6, iters=100, eps=1e-6, kappa=1e-8, tmax=100, eta=1e-6, verbose=False):\n if verbose:\n print(\"----------\")\n print(\"Optimization with {} started!\".format(algorithm))\n print(f\"# Parameters: {self.number_of_parameters()}, # Constraints {self.number_of_constraints()}\")\n\n # test for bad stuff before going any further\n self.check_optimization_sanity()\n\n # compose gradient and objective functions\n if grad not in (\"AD\", \"FD\"):\n raise ValueError(f\"Gradient method {grad} is not supported!\")\n if grad == \"AD\":\n if verbose:\n print(\"Computing gradients using automatic differentiation!\")\n x_func = partial(self._optimize_form, topology=topology.copy(), tmax=tmax, eta=eta)\n grad_func = partial(grad_autograd, grad_func=agrad(x_func)) # x, grad, x_func\n\n elif grad == \"FD\":\n if verbose:\n print(f\"Warning: Calculating gradients using finite differences with step size {step_size}. This may take a while...\")\n grad_func = self.gradient_func(grad_finite_differences, topology.copy(), tmax, eta, step_size)\n\n # grad_func = self.gradient_func(grad_func, topology.copy(), tmax, eta, step_size)\n obj_func = self.objective_func(topology, grad_func, tmax, eta)\n\n # generate optimization variables\n x = self.optimization_parameters(topology)\n\n # extract the lower and upper bounds to optimization variables\n bounds_low, bounds_up = self.optimization_bounds(topology)\n\n # stack keyword arguments\n hyper_parameters = {\"f\": obj_func,\n \"algorithm\": algorithm,\n \"dims\": self.number_of_parameters(),\n \"bounds_low\": bounds_low,\n \"bounds_up\": bounds_up,\n \"iters\": iters,\n \"eps\": eps,\n \"ftol\": kappa}\n\n # assemble optimization solver\n solver = nlopt_solver(**hyper_parameters)\n\n # solve optimization problem\n x_opt = None\n start = time()\n try:\n x_opt = solver.optimize(x)\n if verbose:\n print(\"Optimization ended correctly!\")\n except RoundoffLimited:\n print(\"Optimization was halted because roundoff errors limited progress\")\n print(\"Results may still be useful though!\")\n x_opt = self.optimization_parameters(topology)\n except RuntimeError:\n print(\"Optimization failed due to a runtime error!\")\n print(f\"Optimization total runtime: {round(time() - start, 4)} seconds\")\n return static_equilibrium(topology)\n\n # fetch last optimum value of loss function\n time_opt = time() - start\n loss_opt = solver.last_optimum_value()\n evals = solver.get_numevals()\n status = nlopt_status(solver.last_optimize_result())\n\n # set optimizer attributes\n self.time_opt = time_opt\n self.x_opt = x_opt\n self.penalty = loss_opt\n self.evals = evals\n self.status = status\n\n # set norm of the gradient\n # NOTE: np.zeros is a dummy array (signature requirement set by nlopt)\n self.gradient = grad_func(x_opt, np.zeros(x_opt.size))\n self.gradient_norm = np.linalg.norm(self.gradient)\n\n if verbose:\n print(f\"Optimization total runtime: {round(time_opt, 6)} seconds\")\n print(\"Number of evaluations incurred: {}\".format(evals))\n print(f\"Final value of the objective function: {round(loss_opt, 6)}\")\n print(f\"Norm of the gradient of the objective function: {round(self.gradient_norm, 6)}\")\n print(f\"Optimization status: {status}\".format(status))\n print(\"----------\")\n\n # exit like a champion\n return static_equilibrium(topology)","def max_hybrid(func: Callable[[Tuple], np.ndarray], over: Tuple[Tuple],\\\n state: Tuple[Union[int, float]], cont: Tuple[bool],\\\n actions: Iterable[Tuple]) -> Tuple[float, Tuple[Union[int, float]], None]:\n best = -np.inf\n bestarg = None\n funcarg = lambda x: -func(np.asarray(x).reshape(1, -1))[0, 0]\n statebounds = tuple(zip(state, state))\n for act in actions:\n actbounds = [b if c else (a, a) for a, c, b in zip(act, cont, over)]\n init = tuple([*state, *np.random.uniform(*zip(*over))])\n res = minimize(funcarg, x0=init, bounds=(*statebounds, *actbounds))\n val = -funcarg(res.x)\n if val > best:\n best = val\n bestarg = res.x\n return (best, tuple([float(v) if c else int(v) for v, c in \\\n zip(bestarg[len(state):], cont)]), None)","def fit(self, start_params=None, method='newton', maxiter=100,\n full_output=True, disp=True, fargs=(), callback=None, retall=False,\n skip_hessian=False, **kwargs):\n Hinv = None # JP error if full_output=0, Hinv not defined\n\n start_params = self._get_start_params(start_params)\n\n # TODO: separate args from nonarg taking score and hessian, ie.,\n # user-supplied and numerically evaluated estimate frprime doesn't take\n # args in most (any?) of the optimize function\n\n nobs = self.endog.shape[0]\n # f = lambda params, *args: -self.loglike(params, *args) / nobs\n\n def f(params, *args):\n return -self.loglike(params, *args) / nobs\n\n if method == 'newton':\n # TODO: why are score and hess positive?\n def score(params, *args):\n return self.score(params, *args) / nobs\n\n def hess(params, *args):\n return self.hessian(params, *args) / nobs\n else:\n def score(params, *args):\n return -self.score(params, *args) / nobs\n\n def hess(params, *args):\n return -self.hessian(params, *args) / nobs\n\n warn_convergence = kwargs.pop('warn_convergence', True)\n optimizer = Optimizer()\n xopt, retvals, optim_settings = optimizer._fit(f, score, start_params,\n fargs, kwargs,\n hessian=hess,\n method=method,\n disp=disp,\n maxiter=maxiter,\n callback=callback,\n retall=retall,\n full_output=full_output)\n\n # NOTE: this is for fit_regularized and should be generalized\n cov_params_func = kwargs.setdefault('cov_params_func', None)\n if cov_params_func:\n Hinv = cov_params_func(self, xopt, retvals)\n elif method == 'newton' and full_output:\n Hinv = np.linalg.inv(-retvals['Hessian']) / nobs\n # TODO: try/except for non-invertible hessian?\n elif not skip_hessian:\n H = -1 * self.hessian(xopt)\n invertible = False\n if np.all(np.isfinite(H)):\n eigvals, eigvecs = np.linalg.eigh(H)\n if np.min(eigvals) > 0:\n invertible = True\n\n if invertible:\n Hinv = eigvecs.dot(np.diag(1.0 / eigvals)).dot(eigvecs.T)\n Hinv = np.asfortranarray((Hinv + Hinv.T) / 2.0)\n else:\n warnings.warn('Inverting hessian failed, no bse or cov_params '\n 'available', HessianInversionWarning)\n Hinv = None\n\n if 'cov_type' in kwargs:\n cov_kwds = kwargs.get('cov_kwds', {})\n kwds = {'cov_type': kwargs['cov_type'], 'cov_kwds': cov_kwds}\n else:\n kwds = {}\n if 'use_t' in kwargs:\n kwds['use_t'] = kwargs['use_t']\n # TODO: add Hessian approximation and change the above if needed\n mlefit = LikelihoodModelResults(self, xopt, Hinv, scale=1., **kwds)\n\n # TODO: hardcode scale?\n if isinstance(retvals, dict):\n mlefit.mle_retvals = retvals\n if warn_convergence and not retvals['converged']:\n warnings.warn(\"Maximum Likelihood optimization failed to \"\n \"converge. Check mle_retvals\",\n ConvergenceWarning)\n\n mlefit.mle_settings = optim_settings\n return mlefit","def optimize(\n # trials,\n random_state=SEED):\n\n space = {\n 'max_depth': scope.int(hp.uniform('max_depth', 5, 15)),\n 'subsample': hp.uniform('subsample', 0.03, 1),\n 'learning_rate' : hp.loguniform('learning_rate', np.log(0.005), np.log(0.5)) - 0.0001,\n 'colsample_bytree': hp.uniform('colsample_bytree', 0.3, 1),\n 'reg_alpha': hp.loguniform('reg_alpha', np.log(0.005), np.log(5)) - 0.0001,\n 'reg_lambda': hp.loguniform('reg_lambda', np.log(1), np.log(5)),\n 'bagging_freq': hp.choice('bagging_freq', [0, 1]),\n 'num_leaves': scope.int(hp.uniform('num_leaves', 10, 128)),\n 'n_estimators': 1000,\n 'boosting': 'gbdt',\n 'objective': 'multiclass',\n 'num_class': 12,\n 'metric': 'None',\n 'is_unbalance': 'true',\n # 'min_data_per_group': 1000,\n 'verbose': -1,\n 'random_seed': 42,\n \n }\n\n # Use the fmin function from Hyperopt to find the best hyperparameters\n best = fmin(score_model, space, algo=tpe.suggest,\n # trials=trials,\n max_evals=hyperopt_niters)\n return best","def _maximize(self, board, possible_actions, depth_limit, alpha, beta):\r\n pass","def work(params) -> Union[None, float]:\n try:\n # either HTTP or bindings\n if host:\n path = action if action == \"route\" else \"sources_to_targets\"\n params_str = delimit_tuple(\n tuple((delimit_tuple(x) for x in params)), delimiter=\";\"\n )\n route = requests.get(f\"{host}/{path}/v1/driving/{params_str}\")\n else:\n route = router.route(params) if action == \"route\" else None\n except (RuntimeError, requests.exceptions.BaseHTTPError):\n return None\n\n if (\n random() > 0.95\n ): # assume that large number of routes will be tested, only print sample in debug mode\n LOGGER.debug(f\"Calculated route between {params[0]} and {params[1]}\")\n\n if report:\n result = route.json()\n if action == \"route\":\n try:\n dist = sum([x[\"distance\"] for x in result[\"routes\"]])\n except KeyError:\n LOGGER.critical(\n f\"No route was found from {params[0]} to {params[1]}. \"\n f\"Try regenerating the locations or specify a more narrow bounding box.\"\n )\n return None\n else:\n dists = [\n inner[\"distance\"]\n for outer in route[\"sources_to_targets\"]\n for inner in outer\n ]\n dist: float = mean(filter(lambda x: x is not None, dists))\n\n return dist","def checkgrad(self, target_param = None, verbose=False, step=1e-6, tolerance = 1e-3):\n\n x = self._get_params_transformed().copy()\n\n if not verbose:\n #just check the global ratio\n dx = step*np.sign(np.random.uniform(-1,1,x.size))\n\n #evaulate around the point x\n f1, g1 = self.objective_and_gradients(x+dx)\n f2, g2 = self.objective_and_gradients(x-dx)\n gradient = self.objective_function_gradients(x)\n\n numerical_gradient = (f1-f2)/(2*dx)\n global_ratio = (f1-f2)/(2*np.dot(dx,gradient))\n\n if (np.abs(1.-global_ratio)<tolerance) and not np.isnan(global_ratio):\n return True\n else:\n return False\n else:\n #check the gradient of each parameter individually, and do some pretty printing\n try:\n names = self._get_param_names_transformed()\n except NotImplementedError:\n names = ['Variable %i'%i for i in range(len(x))]\n\n # Prepare for pretty-printing\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\n float_len = 10\n cols = [max_names]\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\n cols = np.array(cols) + 5\n header_string = [\"{h:^{col}}\".format(h = header[i], col = cols[i]) for i in range(len(cols))]\n header_string = map(lambda x: '|'.join(x), [header_string])\n separator = '-'*len(header_string[0])\n print '\\n'.join([header_string[0], separator])\n\n if target_param is None:\n param_list = range(len(x))\n else:\n param_list = self.grep_param_names(target_param)\n\n for i in param_list:\n xx = x.copy()\n xx[i] += step\n f1, g1 = self.objective_and_gradients(xx)\n xx[i] -= 2.*step\n f2, g2 = self.objective_and_gradients(xx)\n gradient = self.objective_function_gradients(x)[i]\n\n numerical_gradient = (f1-f2)/(2*step)\n ratio = (f1-f2)/(2*step*gradient)\n difference = np.abs((f1-f2)/2/step - gradient)\n\n if (np.abs(ratio-1)<tolerance):\n formatted_name = \"\\033[92m {0} \\033[0m\".format(names[i])\n else:\n formatted_name = \"\\033[91m {0} \\033[0m\".format(names[i])\n r = '%.6f' % float(ratio)\n d = '%.6f' % float(difference)\n g = '%.6f' % gradient\n ng = '%.6f' % float(numerical_gradient)\n grad_string = \"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\".format(formatted_name,r,d,g, ng, c0 = cols[0]+9, c1 = cols[1], c2 = cols[2], c3 = cols[3], c4 = cols[4])\n print grad_string","def step(self, closure=None, found_inf: Tensor = None):\n if found_inf is None:\n return super(AdamW, self).step(closure=closure)\n\n if found_inf.shape:\n raise ValueError(\"The found_inf tensor has to be scalar type\")\n\n loss = None\n if closure is not None:\n with torch.enable_grad():\n loss = closure()\n\n for group in self.param_groups:\n params_with_grad = []\n grads = []\n exp_avgs = []\n exp_avg_sqs = []\n max_exp_avg_sqs = []\n state_steps = []\n beta1, beta2 = group['betas']\n\n for p in group['params']:\n if p.grad is not None:\n params_with_grad.append(p)\n if p.grad.is_sparse:\n raise RuntimeError('AdamW does not support sparse gradients')\n grads.append(p.grad)\n\n state = self.state[p]\n\n # Lazy state initialization\n if not state:\n state['step'] = torch.zeros_like(found_inf)\n # Exponential moving average of gradient values\n state['exp_avg'] = torch.zeros_like(\n p, memory_format=torch.preserve_format)\n # Exponential moving average of squared gradient values\n state['exp_avg_sq'] = torch.zeros_like(\n p, memory_format=torch.preserve_format)\n # Maintains max of all exp. moving avg. of sq. grad. values\n state['max_exp_avg_sq'] = torch.zeros_like(\n p, memory_format=torch.preserve_format)\n\n exp_avgs.append(state['exp_avg'])\n exp_avg_sqs.append(state['exp_avg_sq'])\n max_exp_avg_sqs.append(state['max_exp_avg_sq'])\n\n state_steps.append(state['step'])\n\n F.adam_step(\n found_inf,\n state_steps,\n params_with_grad,\n grads,\n exp_avgs,\n exp_avg_sqs,\n max_exp_avg_sqs,\n amsgrad=group['amsgrad'],\n beta1=beta1,\n beta2=beta2,\n lr=group['lr'],\n weight_decay=group['weight_decay'],\n eps=group['eps'],\n maximize=group['maximize'],\n use_adamw=True)\n\n return loss","def maxValue(gameState, depth, a, b):\n ultimateMove = None # The best move the agent can do\n if gameState.isWin() or gameState.isLose(): # if terminal node return gamescore\n return self.evaluationFunction(gameState)\n bestValue = -math.inf\n # for all of max agents moves\n for action in gameState.getLegalActions(0):\n value = minValue(gameState.generateSuccessor(\n 0, action), depth, 1, a, b) # save value from call to minimizing agent\n if value > bestValue: # if value has increased, update parametres\n bestValue = value\n ultimateMove = action\n a = max(a, bestValue) # updates a=alpha if bestvalue > alpha\n if bestValue > b: # if value is greater than connected branch, do prune\n return bestValue\n if depth == self.depth: # if top node, return the best move\n return ultimateMove\n else:\n # if not top node (and no pruning) return best value\n return bestValue","def run_agent(self):\n '''\n The child class is created in order to override the value method which will take into account\n previous states of the agent. The reward function is made exponential rather than linear, which\n decreases the probability of agent visiting the state which was already visited.\n '''\n\n class GraphProblemSpecialised(GraphProblem):\n def __init__(self, initial, goal, graph, reward_dict, already_visited_reward):\n GraphProblem.__init__(self, initial, goal, graph)\n self.rewards = reward_dict\n self.already_visited_reward = already_visited_reward\n\n def value(self, state, history):\n if state in history.keys():\n return self.rewards[state] - (self.already_visited_reward ** history[state])\n return self.rewards[state]\n\n # -- Load and init mission --#\n print('Generate and load the ' + self.mission_type + ' mission with seed ' + str(\n self.mission_seed) + ' allowing ' + self.AGENT_MOVEMENT_TYPE + ' movements')\n mission_xml = init_mission(self.agent_host, self.agent_port, self.AGENT_NAME, self.mission_type,\n self.mission_seed, self.AGENT_MOVEMENT_TYPE)\n self.solution_report.setMissionXML(mission_xml)\n self.solution_report.start()\n\n # -- Get the state of the world along with internal state... --#\n state_t = self.agent_host.getWorldState()\n\n # -- Main loop: --#\n while state_t.is_mission_running:\n state_t = self.agent_host.getWorldState()\n\n # -- Check if anything went wrong along the way --#\n for error in state_t.errors:\n print(\"Error:\", error.text)\n\n # -- Oracle and Internal Sensors--#\n if state_t.number_of_observations_since_last_state > 0: # Has any Oracle-like and/or internal sensor observations come in?\n msg = state_t.observations[-1].text # Get the details for the last observed state\n oracle_and_internal = json.loads(msg) # Parse the Oracle JSON\n # print oracle_and_internal\n # -- Oracle sensor --#\n grid = oracle_and_internal.get(u'grid', 0) # Demo only, string with the\n # -- GPS-like sensor --#\n xpos = oracle_and_internal.get(u'XPos', 0) # Demo only, position in 2D plane, 1st axis\n zpos = oracle_and_internal.get(u'ZPos', 0) # Demo only, position in 2D plane, 2nd axis (yes Z!)\n ypos = oracle_and_internal.get(u'YPos', 0) # Demo only, height as measured from surface! (yes Y!)\n\n current_location_id = self._get_current_location_id((xpos, zpos))\n\n if self.history.get(current_location_id):\n self.history[current_location_id] += 1\n else:\n self.history[current_location_id] = 1\n\n if self.first_time_flag:\n start_location = current_location_id\n\n # Gets the possible actions and checks for goal block\n state_space_actions, state_space_locations, reached_goal = self._get_local_state_space_actions(grid,\n [xpos,\n zpos])\n\n if reached_goal:\n break\n\n self.rewards_by_location_id, self.previous_rewards_total = self._get_rewards(\n self.rewards_by_location_id,\n state_space_actions,\n state_space_locations,\n oracle_and_internal,\n self.previous_rewards_total)\n\n # Creates a graph for local (neighbourhood) actions\n local_map = UndirectedGraph(state_space_actions)\n local_problem = GraphProblemSpecialised(initial=start_location, goal=None, graph=local_map,\n reward_dict=self.rewards_by_location_id,\n already_visited_reward=self.already_visited_reward)\n # Looks for most optimal next step\n next_step = self.hill_climbing(local_problem, self.history)\n\n # If the next step is already in history the reward will be exponentially increased (but is negated)\n if next_step in self.history.keys():\n print \"You already visited that so will be punished!\"\n self.rewards_by_location_id[next_step] -= self.already_visited_reward ** self.history[next_step]\n self.history[next_step] += 1\n\n next_x, next_z = state_space_locations[next_step]\n self.agent_host.sendCommand(\"tp \" + str(next_x) + \" \" + str(217) + \" \" + str(next_z))\n time.sleep(0.1)\n\n # -- Collect the number of rewards and add to reward_cumulative --#\n # -- Note: Since we only observe the sensors and environment every a number of rewards may have accumulated in the buffer --#\n for reward_t in state_t.rewards:\n print(\"Reward_t:\", reward_t.getValue())\n self.solution_report.addReward(reward_t.getValue(), datetime.datetime.now())\n\n # -- Check if anything went wrong along the way --#\n for error in state_t.errors:\n print(\"Error:\", error.text)\n\n print(\"Mission has ended.either because time has passed or you reached the goal.\")\n return","def instability_bf(funcs, step = 10, maximum = 300, guess = 0, tolerance=0.01):\n if guess < maximum:\n s = 1 # to increase\n else:\n s = -1 # to decrease\n step = s*abs(step) # correct step\n # offset to ensure that data moves to maximum even if actual data is stable\n offset = [f(maximum) for f in funcs]\n val_prev = np.array([f(guess-step) for f in funcs]+offset) # first y values with offset\n acc = 0 # accumulator to interchange when to add offset and when not\n while s*(maximum-guess)>0: # check approximation to maximum\n val = [f(guess) for f in funcs] # get y values\n if acc%2: # interchange\n val = np.array(val+offset) # values with offset\n else:\n val = np.array(val+val) # just values\n # np.repeat(np.mean(val),val.size)\n # check minimization\n if np.allclose(val, val_prev, tolerance, tolerance): # it means instability\n return True, guess # success!\n guess += step # updata step\n acc += 1 # update accumulator\n val_prev = val # update previous data\n return False, guess # not found or limit reached","def optimize_svr(data, targets):\r\n def svc_crossval(C,epsilon,loss_n):\r\n\r\n return svc_cv(C=C, epsilon=epsilon,loss_n=loss_n, data=data, targets=targets)\r\n\r\n optimizer = BayesianOptimization(\r\n f=svc_crossval,\r\n pbounds={\"C\": (0.0001, 1000), \"epsilon\": (0, 0.2),'loss_n':(0,1)},\r\n random_state=1234,\r\n verbose=2\r\n )\r\n logger=JSONLogger(path=\"./linsvrlogs.json\")\r\n optimizer.subscribe(Events.OPTMIZATION_STEP,logger)\r\n optimizer.maximize(init_points=50,n_iter=300)\r\n with open('./linsvrlogs.json','a',encoding='utf-8')as f:\r\n f.write(str(optimizer.max))","def MidpointFnBuilder(max_speed = 26.8, gain = 0.1, beta = 0.5, duration = 500, bias = 1.0, ratio = 0.5):\n\n def MidpointFn((idx, car), sim, step):\n \"\"\"\n :param idx:\n :param car:\n :param sim:\n :param step:\n :return:\n \"\"\"\n vehID = car[\"id\"]\n\n try:\n [back_car, front_car] = sim.getCars(idx, numBack=1, numForward=1, lane=car[\"lane\"])\n except ValueError:\n # Not enough cars on lane\n return\n\n front_dist = (front_car[\"x\"] - car[\"x\"]) % sim.length\n back_dist = (car[\"x\"] - back_car[\"x\"]) % sim.length\n\n curr_speed = car[\"v\"]\n front_speed = front_car[\"v\"]\n follow_dist = (front_dist + back_dist) * ratio\n delta = front_dist - follow_dist\n # print delta, curr_speed, front_speed, curr_speed-front_speed\n if follow_dist < front_dist and curr_speed < max_speed:\n # speed up\n new_speed = min(curr_speed + beta * (front_speed-curr_speed) + gain * delta + bias, max_speed)\n traci.vehicle.slowDown(vehID, new_speed, duration) # 2.5 sec\n # print \"t=%d, FASTER, %0.1f -> %0.1f (%0.1f) | d=%0.2f = %0.2f vs %0.2f\" % \\\n # (step, curr_speed, new_speed, front_speed, delta, front_dist, follow_dist)\n elif follow_dist > front_dist:\n # slow down\n new_speed = max(curr_speed + beta * (front_speed-curr_speed) + gain * delta + bias, 0)\n traci.vehicle.slowDown(vehID, new_speed, duration) # 2.5 sec\n # print \"t=%d, SLOWER, %0.1f -> %0.1f (%0.1f) | d=%0.2f = %0.2f vs %0.2f\" % \\\n # (step, curr_speed, new_speed, front_speed, delta, front_dist, follow_dist)\n\n return MidpointFn","def _fit_amoeba(self, kwargs, verbose):\n\n args_init = self._param_class.kwargs_to_args(kwargs)\n\n options = {\n \"adaptive\": True,\n \"fatol\": self._tol_simplex_func,\n \"maxiter\": self._simplex_n_iterations * len(args_init),\n }\n\n method = \"Nelder-Mead\"\n\n if verbose:\n print(\"starting amoeba... \")\n\n opt = minimize(\n self.fast_rayshooting.chi_square,\n x0=args_init,\n method=method,\n options=options,\n )\n\n kwargs = self._param_class.args_to_kwargs(opt[\"x\"])\n source_penalty = opt[\"fun\"]\n\n return kwargs, source_penalty","def minimize(fun, \n bounds = None, \n value_limit = math.inf,\n num_retries = 1000,\n logger = None,\n workers = mp.cpu_count(),\n popsize = 31, \n max_evaluations = 50000, \n capacity = 500,\n stop_fittness = None,\n optimizer = None,\n ):\n\n if optimizer is None:\n optimizer = de_cma(max_evaluations, popsize, stop_fittness) \n store = Store(bounds, capacity = capacity, logger = logger)\n return retry(fun, store, optimizer.minimize, num_retries, value_limit, workers)","def motion_correct(mov, max_iters=5, shift_threshold=1., reslice=slice(None,None), in_place=True, verbose=True, compute_kwargs={}, apply_kwargs={}):\n if not in_place:\n mov = mov.copy()\n mov = mov[reslice]\n \n all_vals = []\n for it in range(max_iters):\n if verbose:\n print('Iteration {}'.format(it)); sys.stdout.flush()\n template,vals = compute_motion(mov, **compute_kwargs)\n mov = apply_motion_correction(mov, vals, **apply_kwargs)\n maxshifts = np.abs(vals[:,[0,1]]).max(axis=0)\n all_vals.append(vals)\n if verbose:\n print('Shifts: {}'.format(str(maxshifts))); sys.stdout.flush()\n if np.all(maxshifts < shift_threshold):\n break\n\n # combine values from iterations\n all_vals = np.array(all_vals)\n return_vals = np.empty([all_vals.shape[1],all_vals.shape[2]])\n return_vals[:,[0,1]] = all_vals[:,:,[0,1]].sum(axis=0)\n return_vals[:,2] = all_vals[-1,:,2]\n\n return mov,template,return_vals","def optimize(self, num_restarts=1, max_iters=100, max_f_eval=300.0, method='Anneal'):\n dic = DictVectorizer()\n # flatten the parameters\n init_params,bounds=dic.fit_transform(self.params)\n #we minimise minus the marginal likelihood\n def objective(params_flatten):\n self.params=dic.inverse_transform(params_flatten,bounds)\n val = -self.log_marginal_likelihood()\n return val# we want to maximize it\n \n \n #run ptimisation with multiple restarts\n optml=np.inf\n for i in range(num_restarts):\n #minimise function\n if method=='Anneal':\n res=dual_annealing(objective,bounds, maxiter=max_iters, maxfun=max_f_eval, x0=init_params)\n else:\n \n res = minimize(objective, init_params, \n bounds=bounds, method=method,options={'maxiter': max_iters, 'disp': False})\n #print(\"Iteration \"+str(i)+\" \",-res.fun)\n if res.fun<optml:\n params_best=res.x #init_params \n optml=res.fun\n init_params=bounds[:,0]+(bounds[:,1]-bounds[:,0])*np.random.rand(len(bounds[:,0]))\n print(\"Iteration \"+str(i)+\" \",-res.fun)\n #params_best=res.x\n #optml=res.fun\n self.params=dic.inverse_transform(params_best,bounds)\n return -optml","def optimize(self): \n if self.model == 'ARD':\n estimate = minimize(\n fun=optim_func,\n x0=np.array([self.alpha, self.beta]),\n args=(self,),\n method='L-BFGS-B',\n bounds=((0, 50), (0, 50)),\n )\n # logger.info(estimate)\n\n # organize into a dict\n result = {\n \"alpha\": estimate.x[0],\n \"beta\": estimate.x[1],\n \"Lik\": estimate.fun,\n \"negLogLik\": -np.log(-estimate.fun),\n \"convergence\": estimate.success,\n }\n logger.debug(result)\n\n elif self.model == 'ER':\n estimate = minimize(\n fun=optim_func,\n x0=np.array([self.alpha]),\n args=(self,),\n method='L-BFGS-B',\n bounds=[(0, 50)],\n )\n\n result = {\n \"alpha\": estimate.x[0],\n \"Lik\": estimate.fun, \n \"negLogLik\": -np.log(-estimate.fun),\n \"convergence\": estimate.success,\n }\n logger.debug(result)\n\n else:\n raise Exception('model must be specified as either ARD or ER')\n\n # get scaled likelihood values\n self.log_lik = result[\"negLogLik\"]\n self.tree = self.tree.set_node_values(\n 'likelihood',\n values={\n node.idx: np.array(node.likelihood) / sum(node.likelihood)\n for node in self.tree.idx_dict.values()\n }\n )","def hyperopt_fmin(\n fn,\n space,\n algo,\n max_evals=sys.maxsize,\n timeout=None,\n loss_threshold=None,\n trials=None,\n rstate=None,\n allow_trials_fmin=True,\n pass_expr_memo_ctrl=None,\n catch_eval_exceptions=False,\n verbose=True,\n return_argmin=True,\n points_to_evaluate=None,\n max_queue_len=1,\n show_progressbar=True,\n # early_stop_fn=None,\n):\n if rstate is None:\n env_rseed = os.environ.get(\"HYPEROPT_FMIN_SEED\", \"\")\n if env_rseed:\n rstate = np.random.RandomState(int(env_rseed))\n else:\n rstate = np.random.RandomState()\n\n validate_timeout(timeout)\n validate_loss_threshold(loss_threshold)\n\n if allow_trials_fmin and hasattr(trials, \"fmin\"):\n assert False\n # return trials.fmin(\n # fn,\n # space,\n # algo=algo,\n # max_evals=max_evals,\n # timeout=timeout,\n # loss_threshold=loss_threshold,\n # max_queue_len=max_queue_len,\n # rstate=rstate,\n # pass_expr_memo_ctrl=pass_expr_memo_ctrl,\n # verbose=verbose,\n # catch_eval_exceptions=catch_eval_exceptions,\n # return_argmin=return_argmin,\n # show_progressbar=show_progressbar,\n # early_stop_fn=early_stop_fn,\n # )\n\n if trials is None:\n if points_to_evaluate is None:\n trials = base.Trials()\n else:\n assert type(points_to_evaluate) == list\n trials = generate_trials_to_calculate(points_to_evaluate)\n\n domain = base.Domain(fn, space, pass_expr_memo_ctrl=pass_expr_memo_ctrl)\n\n rval = FMinIter(\n algo,\n domain,\n trials,\n max_evals=max_evals,\n timeout=timeout,\n loss_threshold=loss_threshold,\n rstate=rstate,\n verbose=verbose,\n max_queue_len=max_queue_len,\n show_progressbar=show_progressbar,\n # early_stop_fn=early_stop_fn,\n )\n rval.catch_eval_exceptions = catch_eval_exceptions\n\n # next line is where the fmin is actually executed\n rval.exhaust()\n\n if len(trials.trials) == 0:\n raise Exception(\n \"There are no evaluation tasks, cannot return argmin of task losses.\"\n )\n return trials","def _generic_minimize(method, loss, x0,\n verbose=False,\n num_iters=1000,\n tol=1e-4,\n state=None,\n full_output=False,\n suppress_warnings=False,\n **kwargs):\n # Flatten the loss\n _x0, unflatten = flatten(x0)\n _objective = lambda x_flat, itr: loss(unflatten(x_flat), itr)\n\n if verbose:\n print(\"Fitting with {}.\".format(method))\n\n # Specify callback for fitting\n itr = [0]\n def callback(x_flat):\n itr[0] += 1\n print(\"Iteration {} loss: {:.3f}\".format(itr[0], loss(unflatten(x_flat), -1)))\n\n # Wrap the gradient to avoid NaNs\n def safe_grad(x, itr):\n g = grad(_objective)(x, itr)\n g[~np.isfinite(g)] = 1e8\n return g\n\n # Call the optimizer. Pass in -1 as the iteration since it is unused.\n result = minimize(_objective, _x0, args=(-1,),\n jac=safe_grad,\n method=method,\n callback=callback if verbose else None,\n options=dict(maxiter=num_iters, disp=verbose),\n tol=tol,\n **kwargs)\n if verbose:\n print(\"{} completed with message: \\n{}\".format(method, result.message))\n\n if not suppress_warnings and not result.success:\n warn(\"{} failed with message:\\n{}\".format(method, result.message))\n\n if full_output:\n return unflatten(result.x), result\n else:\n return unflatten(result.x)","def downhill(F, xStart, args=None, side=0.1, ftol=1.0e-6, xtol=1.0e-6, maxiter=1000, maxfunc=1000, maxiternochange=10):\n # TODO: check the types of the input ???\n\n # print \"Entering downhill\"\n n = len(xStart)\n x = np.zeros((n+1, n), dtype=float) #point null matrix, n+1 rows, n columns\n f = np.zeros(n+1, dtype=float) # null vector, n+1 columns\n p_count = 0 # counter for detecting a plateau\n f_count = 0 # counter for the number of function call\n f_best_count = 0 # counter for the number of iterations in which the best solution does not change\n f_best_prev = 0.0 # holds the best value from the previous iteration\n epsilon = 0.001 # tolerance for considering two values as equal\n # max_iter_no_change = 10 # maximum number of accepted iterations with no change in the optimal solution\n precision = 2\n round_map = partial(round, ndigits=precision) # partial function for rounding purposes\n\n # initial simplex\n x[0] = xStart\n for i in xrange(1, n+1):\n x[i] = xStart\n x[i,i-1] = xStart[i-1] + side\n\n # print \"Evaluate the starting points\"\n # compute the value of F at the vertices of the simplex\n for i in xrange(n+1):\n f[i] = F(x[i], args)\n # p_count += 1\n\n # main loop\n # print \"Start iterating\"\n for k in xrange(maxiter):\n\n # check the number of function calls\n if f_count > maxfunc:\n print \"Stopping criteria: maximum number of function calls\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXFUNCALL'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXFUNCALL'}\n\n # find the best and worst vertex (consider a minimization problem)\n iLo = np.argmin(f) # best vertex\n iHi = np.argmax(f) # worst vertex\n\n # print k,\" \", f[iLo]\n #\n # if f[iLo] < -0.310000:\n # print f[iLo]\n # print x[iLo]\n # print x\n # sys.exit(1)\n # print \"k: \", k, \" f_best_prev: \", f_best_prev, \" f[iLo]: \", f[iLo], \" f_best_count: \", f_best_count\n # print \"Beginning of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\n # print \"x: \", x, \" f: \", f\n # print \"=========================================================================================\"\n # check if the solution has changed from the previous iterations\n if f[iLo] < f_best_prev:\n f_best_prev = f[iLo]\n f_best_count = 0\n else:\n f_best_count += 1\n\n if f_best_count > maxiternochange:\n print \"Stopping criteria: maximum number of iterations with no improvement in the best solution\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'NOIMPROVEMENT'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'NOIMPROVEMENT'}\n\n if abs(f[iLo] - f[iHi]) < ftol: # If difference between highest and lowest is smaller than ftol, return\n print \"Stopping criteria: difference between highest and lowest points is smaller than tolerance\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXTOLERANCE'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXTOLERANCE'}\n # compute the move vector d\n d = (-(n+1) * x[iHi] + np.sum(x, axis=0)) / n\n # print \"d: \", d\n\n # check for convergence\n if sqrt(np.dot(d, d)/n) < xtol: # length of the vector d\n print \"Stopping criteria: length of step d smaller than tolerance\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'SMALLSTEP'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'SMALLSTEP'}\n # try reflection\n xNew = np.array(map(round_map, x[iHi] + 2 * d))\n fNew = F(xNew, args)\n f_count += 1\n # print \"Reflected point: \", xNew, \" value: \", fNew\n\n # check for no improvement over the worst point\n # and for plateau condition\n if f[iHi] - epsilon <= fNew <= f[iHi] + epsilon:\n p_count += 1\n # print \"No improvement here\"\n\n if p_count == n+2: # we reflected all vertices with no improvement\n print \"Stopping criteria: Probably we landed on a plateau... exiting\" # TODO: restart instead of exiting\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'PLATEAU'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'PLATEAU'}\n\n\n else:\n p_count = 0\n\n\n if fNew <= f[iLo]: # if the new value is better than the best so far,\n x[iHi] = xNew # substitute the worst vertex with the new one\n f[iHi] = fNew\n\n # try to expand the reflection\n xNew = np.array(map(round_map, x[iHi] + d))\n fNew = F(xNew, args)\n f_count += 1\n # print \"Expanded point: \", xNew, \" value: \", fNew\n\n if fNew <= f[iHi]: # in the original source version it is f[iLo] (?)\n x[iHi] = xNew\n f[iHi] = fNew\n else:\n # try reflection again\n if fNew <= f[iHi]:\n x[iHi] = xNew\n f[iHi] = fNew\n else:\n # try contraction\n xNew = np.array(map(round_map, x[iHi] + 0.5 * d))\n fNew = F(xNew, args)\n f_count += 1\n # print \"Contracted point: \", xNew, \" value: \", fNew\n\n if fNew <= f[iHi]: # accept contraction\n x[iHi] = xNew\n f[iHi] = fNew\n else:\n # shrink\n for i in xrange(len(x)):\n if i != iLo:\n x[i] = np.array(map(round_map, x[i] - x[iLo] * 0.5))\n f[i] = F(x[i], args)\n f_count += 1\n\n # print \"End of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\n # print \"x: \", x, \" f: \", f\n # print \"*\"*50\n # print \"\"\n\n\n\n print \"Stopping criteria: maximum number of iterations\"\n print \"Best solution so far: \", x[iLo], \" value: \", f[iLo], \" at iteration:\", k\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXITERATION'}\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXITERATION'}","def checkgrad(self, target_param=None, verbose=False, step=1e-6, tolerance=1e-3):\r\n\r\n x = self._get_params_transformed().copy()\r\n\r\n if not verbose:\r\n # just check the global ratio\r\n\r\n #choose a random direction to find the linear approximation in\r\n if x.size==2:\r\n dx = step * np.ones(2) # random direction for 2 parameters can fail dure to symmetry\r\n else:\r\n dx = step * np.sign(np.random.uniform(-1, 1, x.size))\r\n\r\n # evaulate around the point x\r\n f1, g1 = self.objective_and_gradients(x + dx)\r\n f2, g2 = self.objective_and_gradients(x - dx)\r\n gradient = self.objective_function_gradients(x)\r\n\r\n numerical_gradient = (f1 - f2) / (2 * dx)\r\n global_ratio = (f1 - f2) / (2 * np.dot(dx, np.where(gradient==0, 1e-32, gradient)))\r\n\r\n return (np.abs(1. - global_ratio) < tolerance) or (np.abs(gradient - numerical_gradient).mean() < tolerance)\r\n else:\r\n # check the gradient of each parameter individually, and do some pretty printing\r\n try:\r\n names = self._get_param_names_transformed()\r\n except NotImplementedError:\r\n names = ['Variable %i' % i for i in range(len(x))]\r\n\r\n # Prepare for pretty-printing\r\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\r\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\r\n float_len = 10\r\n cols = [max_names]\r\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\r\n cols = np.array(cols) + 5\r\n header_string = [\"{h:^{col}}\".format(h=header[i], col=cols[i]) for i in range(len(cols))]\r\n header_string = map(lambda x: '|'.join(x), [header_string])\r\n separator = '-' * len(header_string[0])\r\n print '\\n'.join([header_string[0], separator])\r\n\r\n if target_param is None:\r\n param_list = range(len(x))\r\n else:\r\n param_list = self.grep_param_names(target_param, transformed=True, search=True)\r\n if not np.any(param_list):\r\n print \"No free parameters to check\"\r\n return\r\n\r\n\r\n for i in param_list:\r\n xx = x.copy()\r\n xx[i] += step\r\n f1, g1 = self.objective_and_gradients(xx)\r\n xx[i] -= 2.*step\r\n f2, g2 = self.objective_and_gradients(xx)\r\n gradient = self.objective_function_gradients(x)[i]\r\n\r\n numerical_gradient = (f1 - f2) / (2 * step)\r\n ratio = (f1 - f2) / (2 * step * np.where(gradient==0, 1e-312, gradient))\r\n difference = np.abs((f1 - f2) / 2 / step - gradient)\r\n\r\n if (np.abs(1. - ratio) < tolerance) or np.abs(difference) < tolerance:\r\n formatted_name = \"\\033[92m {0} \\033[0m\".format(names[i])\r\n else:\r\n formatted_name = \"\\033[91m {0} \\033[0m\".format(names[i])\r\n r = '%.6f' % float(ratio)\r\n d = '%.6f' % float(difference)\r\n g = '%.6f' % gradient\r\n ng = '%.6f' % float(numerical_gradient)\r\n grad_string = \"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\".format(formatted_name, r, d, g, ng, c0=cols[0] + 9, c1=cols[1], c2=cols[2], c3=cols[3], c4=cols[4])\r\n print grad_string","def _autolag(mod, endog, exog, startlag, maxlag, method, modargs=(),\n fitargs=(), regresults=True):\n if not regresults: # pragma: no cover\n # TODO: update docstring\n raise NotImplementedError(\"option `regresults=False` not ported \"\n \"from upstream. _autolag always returns \"\n \"a tuple (icbest, bestlag, results)\")\n\n # TODO: can tcol be replaced by maxlag + 2?\n # TODO: This could be changed to laggedRHS and exog keyword arguments if\n # this will be more general.\n\n results = {}\n method = method.lower()\n for lag in range(startlag, startlag + maxlag + 1):\n mod_instance = mod(endog, exog[:, :lag], *modargs)\n results[lag] = mod_instance.fit()\n\n if method == \"aic\":\n icbest, bestlag = min((v.aic, k) for k, v in results.items())\n elif method == \"bic\":\n icbest, bestlag = min((v.bic, k) for k, v in results.items())\n elif method == \"t-stat\":\n # stop = stats.norm.ppf(.95)\n stop = 1.6448536269514722\n for lag in range(startlag + maxlag, startlag - 1, -1):\n icbest = np.abs(results[lag].tvalues[-1])\n if np.abs(icbest) >= stop:\n bestlag = lag\n icbest = icbest\n break\n else: # pragma: no cover\n raise ValueError(\"Information Criterion %s not understood.\" % method)\n\n return icbest, bestlag, results","def optimiseOne(paramOption, row, extractdata, start, stop, step):\n stockname = row[0]\n exclAttribs = row[1]\n bestNu = row[2]\n\n tryParam = start\n bestParam = tryParam\n (trialError, trialCorrelation, trailAttrCsv) = common.lsCalcModel(\n stockname, exclAttribs, common.cv, extractdata, bestNu, \"{0} {1}\".format(paramOption, tryParam))\n\n print \"Starting correlation={0}, with param={1}\".format(trialCorrelation, bestParam)\n bestCorrelation = trialCorrelation\n\n tryParam = start + step\n while tryParam < stop:\n print \"Trial {0}={1}\".format(paramOption, tryParam)\n (trialError, trialCorrelation, trailAttrCsv) = common.lsCalcModel(\n stockname, exclAttribs, common.cv, extractdata, tryParam)\n print \"Result: correlation={0} for trial Nu={1} with current bestCorrelation={2}\".\\\n format(trialCorrelation, tryParam, bestCorrelation)\n if trialCorrelation >= bestCorrelation:\n bestCorrelation = trialCorrelation\n bestParam = tryParam\n print \"Found better or same correlation=\" + str(bestCorrelation) + \" with Nu={0}\".format(bestParam)\n else:\n print \"Not better. Best parameter value = {0} with correlation={1}\".format(bestParam, bestCorrelation)\n break\n\n tryParam = tryParam + step\n\n return (bestParam, bestCorrelation)","def tune_parameters(self, parameters, search_alg, num_trials=5, metric=\"f1\", direction=\"maximize\", train_ratio=0.7, num_times=1, export_metrics=True):\n self._clear_cache()\n model_id = self.model_id\n if self.comet_key != None:\n exp = init_experiment(self.comet_key, \"model-performance\", \"covid-vaccine\")\n exp.log_parameters({\n \"model_id\":model_id,\n \"model_type\":self.embedding_type,\n \"multiclass\":self.class_label,\n \"train_ratio\":train_ratio,\n \"num_samples\":num_trials,\n \"metric\":metric,\n \"direction\":direction,\n \"search_alg\":search_alg\n })\n log_fixed_params(parameters, exp)\n exp.add_tag(\"multi\" if self.class_label == \"Multiclass\" else \"binary\")\n start = time.time()\n tr_text, tr_label, self.tr_meta, te_text, te_label, self.te_meta, _ = get_train_test_data(self.seed_fp, self.label_fp, train_ratio=train_ratio, meta_cols=self.meta_cols, drop_irrelevant=self.drop_irrelevant, visualize=False, verbose=self.verbose)\n self._transform_labels(tr_label, te_label)\n print(\"data loading:\", time.time() - start, \"seconds\\n\")\n start = time.time()\n self._prepare_feature_components(tr_text, te_text, parameters)\n print(\"total preprocessing:\", time.time() - start, \"seconds\\n\")\n metric_df_parts = []\n def objective(trial):\n config = suggest_config(parameters, trial)\n instances = []\n for _ in range(num_times):\n instance_df = self._run_single_config(train_ratio, config)\n instance_df = instance_df[instance_df[\"part\"] == \"test\"]\n instances.append(instance_df)\n tmp_df = pd.concat(instances, axis=0)\n print(\"metrics 1\", tmp_df.shape)\n group_cols = list(tmp_df.drop(\"score\", axis=1).columns)\n print(group_cols)\n tmp_df = tmp_df.groupby(group_cols)[\"score\"].agg([\"mean\",\"std\"]).reset_index()\n print(\"metrics 2\", tmp_df.shape)\n metric_df_parts.append(tmp_df)\n metrics = dict(zip(tmp_df[\"metric\"],tmp_df[\"mean\"]))\n return metrics[metric]\n if search_alg == \"GRID\":\n algo = GridSampler(extract_grid(parameters))\n elif search_alg == \"RND\":\n algo = RandomSampler()\n elif search_alg == \"TPE\":\n algo = TPESampler(n_startup_trials=int(num_trials*0.3))\n else:#default optuna setting\n algo = None\n study = optuna.create_study(direction=\"maximize\", sampler=algo)\n study.optimize(objective, n_trials=num_trials, n_jobs=1)\n metrics_df = pd.concat(metric_df_parts)\n best_config = study.best_params\n print(\"Best config: \", best_config)\n if export_metrics:\n result_dir = os.path.join(self.model_dir, \"results\")\n if not os.path.exists(result_dir):\n os.makedirs(result_dir)\n study_fp = os.path.join(result_dir, \"%s.pkl\" % model_id)\n print(\"Study file:\", study_fp)\n joblib.dump(study, study_fp)\n result_fp = os.path.join(result_dir, \"%s.csv\" % model_id)\n print(\"Output file:\", result_fp)\n metrics_df.to_csv(result_fp, index=False)\n if self.comet_key != None:\n exp.log_parameters(best_config)\n exp.log_metrics({\n \"train_size\":len(tr_text),\n \"test_size\":len(te_text)\n })\n best_results = dict(metrics_df.groupby(\"metric\")[\"mean\"].max()[[\"f1\",\"acc\",\"auc\"]])\n exp.log_metrics(best_results)\n exp.end()\n return best_config","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n \n def miniMaxAgent(state, depth, agentIndex):\n \n #return evaluation function if game is won or lost or the depth is reached\n if state.isLose() or state.isWin() or depth == self.depth:\n return self.evaluationFunction(state)\n \n #if agent index is 0 that is pacman so get the maximum value\n if agentIndex == 0:\n maximum = float(\"-inf\")\n actions = state.getLegalActions(agentIndex) #pacmans legal actions\n \n #get successor from all actions and set maximum as the largest value found\n for action in actions:\n successor = state.generateSuccessor(agentIndex, action)\n maximum = max(maximum, miniMaxAgent(successor, depth, 1)) #pass agent index as 1 to move onto the ghosts (min)\n \n return maximum\n \n #if agent index is greater than 0 it is a ghost so get the minimum value\n else:\n minimum = float(\"inf\")\n actions = state.getLegalActions(agentIndex)\n \n #get successor from all actions and set the minimum to the smallest value found\n for action in actions:\n successor = state.generateSuccessor(agentIndex, action) #ghosts legal actions\n \n #if all ghosts have found a min, increase depth and set agent back to pacman (max)\n if state.getNumAgents() -1 == agentIndex:\n minimum = min(minimum, miniMaxAgent(successor, depth + 1, 0))\n \n #increase agent index to get the next ghost\n else:\n minimum = min(minimum, miniMaxAgent(successor, depth, agentIndex + 1))\n return minimum\n \n score = float(\"-inf\")\n direction = None\n \n #get all the legal actions in the game state\n legalActions = gameState.getLegalActions()\n \n #get successor from each action in the game\n for action in legalActions:\n successor = gameState.generateSuccessor(0, action)\n \n #start at depth 0 and agent index 1\n value = miniMaxAgent(successor, 0, 1)\n \n #find the largest value and set direction to the action that returned that value\n if score < value:\n score = value\n direction = action\n \n return direction\n util.raiseNotDefined()","def do_MD_atom_walk(at, movement_args, Emax, KEmax):\n#DOC\n#DOC ``do_MD_atom_walk``\n orig_E = at.info['ns_energy']\n if orig_E >= Emax:\n print print_prefix, \": WARNING: orig_E =\",orig_E,\" >= Emax =\",Emax\n\n #DOC \\item if MD\\_atom\\_velo\\_pre\\_perturb, call do\\_MC\\_atom\\_velo\\_walk() for magnitude and rotation\n if movement_args['MD_atom_velo_pre_perturb']:\n do_MC_atom_velo_walk(at, movement_args, Emax, KEmax)\n\n pre_MD_pos = at.get_positions()\n pre_MD_velo = at.get_velocities()\n if ns_args['n_extra_data'] > 0:\n pre_MD_extra_data = at.arrays['ns_extra_data'].copy()\n\n pre_MD_E = at.info['ns_energy']\n\n #DOC \\item propagate in time atom\\_traj\\_len time steps of length MD\\_atom\\_timestep\n if movement_args['python_MD']:\n forces = eval_forces(at)\n final_E = None\n timestep = movement_args['MD_atom_timestep']\n for i in range(movement_args['atom_traj_len']):\n at.set_momenta(at.get_momenta()+forces*0.5*timestep)\n at.set_positions(at.get_positions()+at.get_momenta()*timestep)\n try:\n forces = eval_forces(at)\n except:\n final_E = 2.0*abs(Emax)\n break\n at.set_momenta(at.get_momenta()+forces*0.5*timestep)\n if final_E is None: # didn't abort due to exception in eval_forces()\n final_E = eval_energy(at)\n else:\n if do_calc_quip:\n propagate_NVE_quippy(at, dt=movement_args['MD_atom_timestep'], n_steps=movement_args['atom_traj_len'])\n final_E = eval_energy(at)\n elif do_calc_lammps:\n if propagate_lammps(at, dt=movement_args['MD_atom_timestep'], n_steps=movement_args['atom_traj_len'], algo='NVE'):\n final_E = pot.results['energy'] + eval_energy(at, do_PE=False)\n else: # propagate returned success == False\n final_E = 2.0*abs(Emax)\n ## print \"error in propagate_lammps NVE, setting final_E = 2*abs(Emax) =\" , final_E\n elif do_calc_fortran:\n final_E = f_MC_MD.MD_atom_NVE_walk(at, n_steps=movement_args['atom_traj_len'], timestep=movement_args['MD_atom_timestep'], debug=ns_args['debug'])\n final_E += eval_energy(at, do_PE=False, do_KE=False)\n else:\n exit_error(\"Need some non-quippy, non-fortran, non-lammps way of doing MD\\n\",3)\n\n reject_fuzz = False\n final_KE = eval_energy_KE(at)\n #DOC \\item If MD\\_atom\\_reject\\_energy\\_violation is set, accept/reject entire move on E deviating by less than MD\\_atom\\_energy\\_fuzz times kinetic energy\n if abs(final_E-pre_MD_E) > movement_args['MD_atom_energy_fuzz']*final_KE:\n if movement_args['MD_atom_reject_energy_violation']:\n reject_fuzz = True\n # else:\n # print print_prefix, \": WARNING: MD energy deviation > fuzz*final_KE. Pre-MD, post-MD, difference, final_KE \", pre_MD_E, final_E, final_E-pre_MD_E, final_KE\n\n #DOC \\item accept/reject entire move on E < Emax and KE < KEmax\n reject_Emax = (final_E >= Emax)\n reject_KEmax = (KEmax > 0.0 and final_KE >= KEmax)\n\n #DOC \\item if reject\n if reject_fuzz or reject_Emax or reject_KEmax: # reject\n #DOC \\item set positions, velocities, energy back to value before perturbation (maybe should be after?)\n # print print_prefix, \": WARNING: reject MD traj Emax \", Emax, \" initial E \", orig_E, \" velo perturbed E \", pre_MD_E, \" final E \",final_E, \" KEmax \", KEmax, \" KE \", final_KE\n at.set_positions(pre_MD_pos)\n if movement_args['MD_atom_velo_flip_accept']:\n at.set_velocities(pre_MD_velo)\n else:\n at.set_velocities(-pre_MD_velo)\n if ns_args['n_extra_data'] > 0:\n at.arrays['ns_extra_data'][...] = pre_MD_extra_data\n at.info['ns_energy'] = pre_MD_E\n n_accept = 0\n #DOC \\item else\n else: # accept\n #DOC \\item flip velocities if MD\\_atom\\_velo\\_flip\\_accept\n # remember to reverse velocities on acceptance to preserve detailed balance, since velocity is (sometimes) being perturbed, not completely randomized\n if movement_args['MD_atom_velo_flip_accept']:\n at.set_velocities(-at.get_velocities()) # is there a faster way of doing this in ASE? Can you do at.velocities?\n at.info['ns_energy'] = final_E\n n_accept = 1\n\n #DOC \\item if MD\\_atom\\_velo\\_post\\_perturb, call do\\_MC\\_atom\\_velo\\_walk() for magnitude and rotation\n if movement_args['MD_atom_velo_post_perturb']:\n do_MC_atom_velo_walk(at, movement_args, Emax, KEmax)\n\n return {'MD_atom' : (1, n_accept) }","def fit(args):\n\n config_file = args.setupfn\n conf_base = os.path.basename(config_file).split('.')[0]\n print(\"Performing maximum a posteriori fitting for {}\".format(conf_base))\n\n P, post = radvel.utils.initialize_posterior(config_file, decorr=args.decorr)\n\n post = radvel.fitting.maxlike_fitting(post, verbose=True)\n\n postfile = os.path.join(args.outputdir,\n '{}_post_obj.pkl'.format(conf_base))\n post.writeto(postfile)\n\n savestate = {'run': True,\n 'postfile': os.path.relpath(postfile)}\n save_status(os.path.join(args.outputdir,\n '{}_radvel.stat'.format(conf_base)),\n 'fit', savestate)","def progressive_deepening(state, heuristic_fn=always_zero, depth_limit=INF,\n maximize=True) :\n anytime_value = AnytimeValue() # TA Note: Use this to store values.\n depth = 0\n while depth<=depth_limit-1:\n depth+=1\n best_option=minimax_search_alphabeta(state,-INF,INF, heuristic_fn=heuristic_fn,depth_limit=depth, maximize=True)\n anytime_value.set_value(best_option)\n return anytime_value","def optim_func(params, model):\n if model.model == 'ARD':\n model.alpha, model.beta = params\n lik = model.pruning_algorithm()\n\n else:\n model.alpha = params[0]\n lik = model.pruning_algorithm()\n \n return -lik","def __max_step(self, batch):\n\n # short hand and optimizer\n policy = self.mc.get('policy', target=False)\n policy_parameters = list(policy.parameters())\n opt_outer = optim.Adam(policy_parameters, lr=self.outer_lr)\n\n # optimize\n opt_outer.zero_grad()\n obj = -self.obj(batch)\n obj.backward()\n opt_outer.step()","def _objective(self, trial, X, y, weights=None, split=None):\n\n # Generate even weights if none\n if weights is None:\n weights = pd.Series(np.ones(len(y)), index=y.index)\n else:\n weights = pd.Series(weights, index=y.index)\n\n # Execute trial function\n try:\n res = eval(self.function)\n except:\n raise RuntimeError(f\"Optuna execution error: {self.function}\")\n\n # If indicator result is tuple, select the one of interest\n if isinstance(res, tuple):\n res = res[self.idx]\n\n # Ensure result is a dataframe with same index as X\n res = pd.DataFrame(res, index=X.index)\n\n # If indicator result is dataframe, select the one of interest\n if len(res.columns) > 1:\n res = pd.DataFrame(res.iloc[:, self.idx])\n\n # y may be a subset of X, so reduce result to y and convert to series\n res_y = res.reindex(y.index).iloc[:, 0].replace([np.inf, -np.inf], np.nan)\n\n # Save all trial results for pruning and reporting\n # Only the best trial will eventually be saved to limit storage requirements\n self.res_y.append(res_y) # Save results\n\n # Indicator result may be all NANs based on parameter set\n # Return FALSE and alert\n if np.isnan(res_y).sum() / len(res_y) > .95: # Most or all NANs\n self.res_y_corr.append(np.zeros(len(y)))\n if split is not None:\n return tuple([False] * (len(split) - 1))\n else:\n return False\n\n # Obtain correlation for entire dataset\n if self.spearman:\n corr = _weighted_spearman(np.array(y), np.array(res_y), np.array(weights))\n else:\n corr = _weighted_pearson(np.array(y), np.array(res_y), np.array(weights))\n\n # Save correlation for res_y\n self.res_y_corr.append(corr)\n\n # Multi-objective optimization\n # Obtain correlation to target for each split for Optuna to maximize\n if split is not None:\n mo = []\n for i, e in enumerate(split):\n if i == 0:\n s = e\n continue\n\n # y could be a subset of X, use index of X to filter y\n idx = X[s:e].index\n\n # Filter y based on X split\n y_se = np.array(y[y.index.isin(idx)]).astype('float64')\n\n # Filter y predictions based on X split\n res_y_se = np.array(res_y[res_y.index.isin(idx)]).astype('float64')\n\n # Filter weights based on X split\n weights_se = np.array(weights[weights.index.isin(idx)]).astype('float64')\n\n if np.isnan(res_y_se).sum() / len(res_y_se) > .95:\n return tuple([False]*(len(split)-1))\n\n if self.spearman:\n mo.append(_weighted_spearman(y_se, res_y_se, weights_se))\n else:\n mo.append(_weighted_pearson(y_se, res_y_se, weights_se))\n s = e\n return tuple(mo)\n\n # Single objective optimization return corr for entire dataset\n else:\n return corr","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n\n def agentCounter(gameState, index, depth):\n \"\"\"When index is out of bounds return pacmans index and\n reduce depth by 1\"\"\"\n if index == gameState.getNumAgents():\n return [depth-1, 0]\n else:\n return [depth, index]\n\n def minimax(self, gameState, depth, index):\n \"\"\"Implement minimax function for pacman game. \n return an array with score and best move\"\"\"\n ultimateMove = None # The best move the agent can use\n if depth == 0 or gameState.isWin() or gameState.isLose():\n # if leaf node return value.\n return [self.evaluationFunction(gameState), ultimateMove]\n else:\n if index == 0: # if pacman => agent is max agent\n value = -math.inf\n maxValue = value\n # iterates through max agent w/index=0 moves\n for action in gameState.getLegalActions(0):\n depthIndex = agentCounter(gameState, index+1, depth)\n successorState = gameState.generateSuccessor(\n index, action) # generates the next state when move is done\n value = max(value, minimax(\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return max of saved value and recursive function\n if maxValue != value: # If value has changed update values\n ultimateMove = action\n maxValue = value\n return [value, ultimateMove]\n else: # is ghost => agent is min agent\n value = math.inf\n minValue = value\n # Iterate through the moves of a min agent w/index not 0\n for action in gameState.getLegalActions(index):\n depthIndex = agentCounter(gameState, index+1, depth)\n successorState = gameState.generateSuccessor(\n index, action)\n value = min(value, minimax(\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return min of saved value and recursive function\n if minValue != value: # If value has changed update values\n ultimateMove = action\n minValue = value\n return [value, ultimateMove]\n\n best = minimax(self, gameState, self.depth, self.index)\n #print(\"Move: \", best[1], \" | Score: \", best[0])\n return best[1]","def example():\n Optimizer = BFGS(f, g)\n startPoint = 100 * numpy.ones(2);\n res = Optimizer.optimize(startPoint,\n epsilon=1e-5,\n maxIterations=10)\n print res\n pass","def compute_optimalReward(task):\n\n\tT = 15.0\n\tweights = 0\n\tif task == TABLE_TASK or task == COFFEE_TASK:\n\t\tweights = 1\n\telif task == LAPTOP_TASK:\n\t\tweights = 10\n\n\t# initialize start/goal based on task \n\tif task == COFFEE_TASK or task == HUMAN_TASK:\n\t\tpick = pick_shelf\n\telse:\n\t\tpick = pick_basic\n\n\tif task == LAPTOP_TASK:\n\t\tplace = place_higher\n\telse:\n\t\tplace = place_lower\n\t\t\n\tstartRad = np.array(pick)*(math.pi/180.0)\n\tgoalRad = np.array(place)*(math.pi/180.0)\n\tstart = startRad\n\tgoal = goalRad\n\n\tplan = Planner(task)\t\n\tfilename = None\n\tif task == 1:\n\t\tfilename = \"task1.csv\"\n\telif task == 2:\n\t\tfilename = \"task2.csv\"\n\telif task == 3:\n\t\tfilename = \"task3.csv\"\n\t\t\n\t# get optimal waypts from file\n\twaypts = get_opt_waypts(filename)\n\tr = plan.featurize(waypts)\n\tRvel = r[0]\n\tRfeat = np.sum(r[1])\n\n\tplan.kill_planner()\n\treturn (Rvel, Rfeat)","def optimize(\n self, n, tol=None, jac=True, hessp=False, optlib=\"scipy\", **options\n ):\n return {\"scipy\": self.optimize_scipy, \"nlopt\": self.optimize_nlopt,}[\n optlib\n ](n=n, tol=tol, jac=jac, hessp=hessp, **options)","def __init__(self, direction, max_momentum, current_momentum=None, max_speed=2, current_speed=0, rowing=False):\n self.direction = direction\n self.max_momentum = max_momentum\n if current_momentum is None:\n self.current_momentum = self.max_momentum\n else:\n self.current_momentum = current_momentum\n self.max_speed = max_speed\n self.current_speed = current_speed\n self.rowing = rowing"],"string":"[\n \"def optimize_library_descent(self, target, direction='max', steps=100,\\n multiprocessing=False, ret_info=False,\\n args=None):\\n # get the target function to call\\n target_function = getattr(self, target)\\n if args is not None:\\n target_function = functools.partial(target_function, **args)\\n\\n # initialize the optimizer\\n value = target_function()\\n value_best, state_best = value, self.sens_mat.copy()\\n \\n if ret_info:\\n # store extra information\\n start_time = time.time()\\n info = {'values': {}}\\n values_count = self.parameters['optimizer_values_count']\\n values_step = max(1, steps // values_count)\\n \\n if multiprocessing:\\n # run the calculations in multiple processes\\n pool_size = self.get_number_of_cores()\\n pool = mp.Pool(processes=pool_size)\\n if ret_info:\\n values_step = max(1, values_step // pool_size)\\n \\n # iterate for given number of steps\\n for step in range(int(steps) // pool_size):\\n joblist = []\\n init_arguments = self.init_arguments\\n for _ in range(pool_size):\\n # modify the current state and add it to the job list\\n i = random.randrange(self.sens_mat.size)\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n params = init_arguments['parameters'] \\n params['sensitivity_matrix'] = self.sens_mat\\n params['initialize_state']['sensitivity'] = 'exact'\\n \\n joblist.append((copy.deepcopy(init_arguments), target))\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n # run all the jobs\\n results = pool.map(_run_job, joblist)\\n \\n # find the best result \\n if direction == 'max':\\n res_best = np.argmax(results)\\n if results[res_best] > value_best:\\n value_best = results[res_best]\\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\\n # use the best state as a basis for the next iteration\\n self.sens_mat = state_best\\n \\n elif direction == 'min':\\n res_best = np.argmin(results)\\n if results[res_best] < value_best:\\n value_best = results[res_best]\\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\\n # use the best state as a basis for the next iteration\\n self.sens_mat = state_best\\n \\n else:\\n raise ValueError('Unsupported direction `%s`' % direction)\\n \\n if ret_info and step % values_step == 0:\\n info['values'][step * pool_size] = results[res_best]\\n \\n else:\\n # run the calculations in this process\\n for step in range(int(steps)):\\n # modify the current state\\n i = random.randrange(self.sens_mat.size)\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n # get the value of the new state\\n value = target_function()\\n \\n improved = ((direction == 'max' and value > value_best) or\\n (direction == 'min' and value < value_best))\\n if improved:\\n # save the state as the new best value\\n value_best, state_best = value, self.sens_mat.copy()\\n else:\\n # undo last change\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n if ret_info and step % values_step == 0:\\n info['values'][step] = value_best\\n\\n # sort the best state and store it in the current object\\n state_best = self.sort_sensitivity_matrix(state_best)\\n self.sens_mat = state_best.copy()\\n\\n if ret_info:\\n info['total_time'] = time.time() - start_time \\n info['states_considered'] = steps\\n info['performance'] = steps / info['total_time']\\n return value_best, state_best, info\\n else:\\n return value_best, state_best\",\n \"def optimize_library_descent_multiple(self, target, direction='max',\\n trials=4, multiprocessing=False,\\n ret_error=False, **kwargs):\\n \\n # pass some parameters down to the optimization function to call\\n kwargs['target'] = target\\n kwargs['direction'] = direction\\n \\n # initialize the list of jobs with an optimization job starting from the\\n # current interaction matrix\\n joblist = [(self.init_arguments, 'optimize_library_descent', kwargs)]\\n sens_mat = self.sens_mat #< store matrix to restore it later\\n\\n # set the ensemble of sensitivity matrices to try\\n self.choose_sensitivity_matrix(density='auto')\\n self.parameters['initialize_state']['sensitivity'] = 'ensemble'\\n\\n # add additional jobs with random initial interaction matrices\\n init_arguments = self.init_arguments\\n for _ in range(trials - 1):\\n joblist.append((copy.deepcopy(init_arguments),\\n 'optimize_library_descent', kwargs))\\n \\n # restore interaction matrix of this object\\n self.sens_mat = sens_mat\\n \\n if multiprocessing:\\n # calculate all results in parallel\\n pool = mp.Pool(processes=self.get_number_of_cores())\\n result_iter = pool.imap_unordered(_run_job, joblist)\\n \\n else:\\n # create a generator over which we iterate later\\n result_iter = (_run_job(job) for job in joblist)\\n \\n # find the best result by iterating over all results\\n result_best, values = None, []\\n for result in result_iter:\\n values.append(result[0])\\n # check whether this run improved the result\\n if result_best is None:\\n result_best = result\\n elif ((direction == 'max' and result[0] > result_best[0]) or\\n (direction == 'min' and result[0] < result_best[0])):\\n result_best = result\\n \\n # sort the best state and store it in the current object\\n state = self.sort_sensitivity_matrix(result_best[1])\\n self.sens_mat = state.copy()\\n\\n if ret_error:\\n # replace the best value by a tuple of the best value and its error\\n value_best = result_best[0]\\n value_err = np.abs(value_best - np.median(values))\\n result_best = ((value_best, value_err), ) + result_best[1:]\\n return result_best\",\n \"def optimize_library(self, target, method='descent', direction='max',\\n **kwargs):\\n if method == 'descent':\\n return self.optimize_library_descent(target, direction, **kwargs)\\n elif method == 'descent_multiple' or method == 'descent-multiple':\\n return self.optimize_library_descent_multiple(target, direction,\\n **kwargs)\\n elif method == 'anneal':\\n return self.optimize_library_anneal(target, direction, **kwargs)\\n \\n else:\\n raise ValueError('Unknown optimization method `%s`' % method)\",\n \"def Optimise(LogLikelihood,par,func_args,fixed=None,type='max',method='NM',maxiter=10000, maxfun=10000, verbose=True):\\n \\n if fixed==None:\\n var_par = np.copy(par)\\n #otherwise construct the parameter vector from var_par and fixed_par_val\\n else:\\n par = np.array(par)\\n fixed = np.array(fixed) #ensure fixed is a np array\\n #assign parameters to normal param vector\\n fixed_par = par[np.where(fixed==True)]\\n var_par = par[np.where(fixed!=True)]\\n \\n #set the algorithm to use - CG and P not working (at least not well)\\n add_kwords = {'verbose':verbose}\\n if method == 'NM':\\n Algorithm = NelderMead\\n add_kwords = {'maxiter':maxiter, 'maxfun':maxfun,'verbose':verbose}\\n elif method == 'CG':\\n print \\\"warning: CG method didn't work properly during testing\\\"\\n Algorithm = ConjugateGradient\\n elif method == 'P':\\n print \\\"warning: Powell algorithm didn't work properly during testing\\\"\\n Algorithm = Powell\\n else:\\n print \\\"error: optimisation function not found\\\"\\n return par\\n \\n #set the optimisation function to pos or neg for the fmin funcitons\\n if type == 'max': OptFunc = NegFixedPar_func\\n elif type == 'min': OptFunc = FixedPar_func\\n else:\\n print \\\"error: %s not a valid option\\\" % type\\n return par\\n \\n #call the optimser with the appropriate function\\n fitted_par = Algorithm(OptFunc, var_par, (LogLikelihood,func_args,fixed,fixed_par), \\\\\\n **add_kwords)\\n \\n #now return the params in the correct order...\\n if fixed==None:\\n return_par = fitted_par\\n else:\\n return_par = np.copy(par) \\n return_par[np.where(fixed!=True)] = fitted_par\\n \\n return return_par\",\n \"def simulatedAnnealing(problem, maxSteps, userInteraction, beQuiet):\\n\\n import random\\n from math import exp\\n\\n currentState = problem.state\\n steps = 0\\n bestYet = currentState\\n # for visualization\\n problem.hVals.append(problem.getObjValue(currentState))\\n\\n while steps<maxSteps:\\n if problem.isGlobalOptimum(currentState):\\n return steps, bestYet\\n temperature = tempSchedule(steps, maxSteps)\\n # print(temperature)\\n if temperature == 0:\\n return currentState\\n neighbour = problem.getRandomNeighbour(currentState)\\n changeInObj = problem.getObjValue(neighbour) - \\\\\\n problem.getObjValue(currentState)\\n if changeInObj > 0:\\n # if the neighbour is better, jump\\n currentState = neighbour\\n if not beQuiet:\\n if userInteraction:\\n input(\\\"Press enter to continue \\\")\\n print(\\\"Greedy step taken.\\\")\\n problem.visualize(currentState)\\n steps+=1\\n\\n currentVal = problem.getObjValue(currentState)\\n bestYetVal = problem.getObjValue(bestYet)\\n if problem.isBetter(currentVal, bestYetVal):\\n bestYet = currentState\\n\\n # for visualization later on\\n problem.hVals.append(problem.getObjValue(currentState))\\n\\n else:\\n # if the neighbour is worse, jump with some probability\\n if random.random() < exp(-1*changeInObj/temperature):\\n \\n currentState = neighbour\\n if not beQuiet:\\n if userInteraction:\\n input(\\\"Press enter to continue \\\")\\n print(\\\"Step in a worse direction taken.\\\")\\n problem.visualize(currentState)\\n steps+=1\\n\\n currentVal = problem.getObjValue(currentState)\\n bestYetVal = problem.getObjValue(bestYet)\\n if problem.isBetter(currentVal, bestYetVal):\\n bestYet = currentState\\n\\n # for visualization later on\\n problem.hVals.append(problem.getObjValue(currentState))\\n return steps, bestYet\",\n \"def process_solve_kwargs(**kwargs):\\n\\n tol = kwargs.get('tol', DEFAULT_TOL)\\n maxiter = kwargs.get('maxiter', MAX_ITER)\\n Ainv = kwargs.get('Ainv', None)\\n verbose = kwargs.get('verbose', False)\\n\\n if VERBOSE:\\n print(\\\"tol:\\\", tol)\\n print(\\\"maxiter:\\\", maxiter)\\n print(\\\"Ainv:\\\", Ainv)\\n\\n return tol, int(maxiter), Ainv, verbose\",\n \"def __call__(self, origin, state, **kwargs):\\n fun = kwargs['function']\\n d = state['direction']/np.linalg.norm(state['direction'])\\n # filter directions that are too large\\n if self.filter:\\n ndabs_log = -np.log10(np.abs(d))\\n mean_log = np.mean(ndabs_log)\\n #print \\\"\\\\n ** MEAN =\\\", mean_log\\n direction = (ndabs_log > mean_log-1.5).astype(int)*d\\n else:\\n direction = d\\n state['direction'] = direction\\n## for pos, d in enumerate(direction):\\n## use_dir = self.use_dirs[pos]\\n## if use_dir * d < 0:\\n## # directions don't match so don't move in this direction\\n## direction[pos] = 0\\n maxStepSize = self.maxStepSize\\n if np.isscalar(maxStepSize):\\n stepSize = maxStepSize\\n else:\\n stepfacs = np.zeros(self.dim)\\n for d in range(self.dim):\\n # explicit loop so as to catch any ZeroDivisionErrors\\n try:\\n stepfacs[d] = abs(maxStepSize[d] / direction[d])\\n except ZeroDivisionError:\\n # Direction is orthogonal to this parameter direction,\\n # so ensure won't choose this as the minimum step size\\n stepfacs[d] = Inf\\n # Stop stepping with giant sizes if direction vector has strong\\n # separation of scales\\n stepSize = min(stepfacs)\\n# print \\\"direction = \\\", direction\\n# print \\\"step = \\\", step\\n i = 1\\n old_value = state['old_value']\\n not_done = True\\n# print \\\"** TEMP: Hardwiring step size to be 0.0005\\\"\\n# stepSize = 0.0005\\n init_step = stepSize\\n while not_done:\\n print(\\\"\\\\nLinestep: i =\\\", i, \\\"step size =\\\", stepSize, \\\"direction =\\\\n\\\", end='')\\n print(direction)\\n p = origin + i * stepSize * direction\\n print(\\\"Testing p = \\\", p)\\n new_value = fun(p)\\n if new_value < old_value:\\n i += 1\\n old_value = new_value\\n else:\\n if i == 1:\\n # don't shrink step size to be less than 1/maxReduceFac of initial\\n if stepSize*self.maxReduceFac < init_step:\\n not_done = False\\n p = origin + (i-1) * stepSize * direction\\n else:\\n stepSize /= self.stepMod\\n else:\\n # had found a working step but it's no longer stepping to lower residuals\\n not_done = False\\n p = origin + (i-1) * stepSize * direction\\n state['alpha_step'] = stepSize\\n return p\",\n \"def opt_wrapper(m, **kwargs):\\r\\n m.optimize(**kwargs)\\r\\n return m.optimization_runs[-1]\",\n \"def opt_wrapper(m, **kwargs):\\n m.optimize(**kwargs)\\n return m.optimization_runs[-1]\",\n \"def MAXED(N, sigma2, R, f_def, params):\\n\\n # pull out algorithm-specific parameters\\n Omega = params['Omega']\\n\\n # create the function that we will maximize, Z\\n def Z(lam, N, sigma2, R, f_def, Omega):\\n \\\"\\\"\\\"A function, the maximization of which is equivalent to the\\n maximization of \\\"\\\"\\\"\\n\\n A = - np.sum(f_def * np.exp(- np.sum((lam * R.T).T, axis=0)))\\n B = - (Omega * np.sum(lam**2 * sigma2))**(0.5)\\n C = - np.sum(N * lam)\\n\\n # negate because it's a minimization\\n return - (A + B + C)\\n\\n # create a lambda\\n lam = np.ones(len(N))\\n\\n # apply the simulated annealing to the Z\\n mk = {'args': (N, sigma2, R, f_def, Omega)}\\n lam = basinhopping(Z, lam, minimizer_kwargs=mk).x\\n\\n # back out the spectrum values from the lam\\n return f_def * np.exp(-np.sum((lam * R.T).T, axis=0))\",\n \"def test_optimalagentfinder () :\\n def valNetwork (s) : \\n s = s.float()\\n v = reduce(model.withReluDropout, model.v[:-1], s)\\n v = model.v[-1](v)\\n return v\\n acrobotBases = acrobotRewardBases(np.pi / 8, np.pi / 8)\\n fn = random.sample(acrobotBases, k=1).pop()\\n agent = findOptimalAgent(fn)\\n model = agent.model\\n toExternal = lambda x, y : toExternalStateRep([x, y, 0, 0])\\n valFn = reduce(compose, [float, valNetwork, torch.tensor, toExternal])\\n RFn = compose(fn, toExternal)\\n xRange = np.arange(-np.pi, np.pi, 0.1)\\n yRange = np.arange(-np.pi, np.pi, 0.1)\\n plotFunction(RFn, xRange, yRange, 'theta1', 'theta2', 'R')\\n plotFunction(valFn, xRange, yRange, 'theta1', 'theta2', 'V')\",\n \"def Optimization(*args, **kwargs):\\n from warnings import warn\\n\\n warn(\\n \\\"Optimization has been renamed to OptimizationResult and will be removed as soon as v0.13.0\\\", DeprecationWarning\\n )\\n return OptimizationResult(*args, **kwargs)\",\n \"def optimize(self):\\n \\n if self.verbose:\\n print('Starting grid search with bounds: [' + \\\\\\n ';'.join(['%5g to %5g']*len(self.steps))%tuple([(self.steps[i][0], self.steps[i][-1]) for i in range(len(self.steps))]) +']')\\n\\n for params in self._get_next_point():\\n self.transform.set_params(params)\\n\\n v, _ = self.measure.value_and_derivatives(self.transform)\\n\\n if v < self.best_value:\\n self.best_value = v\\n self.best_params = params\\n# print('New best value %2.4f at ('%v, ', '.join(['%8.3f']*len(params))%tuple(params), ')')\\n\\n self.value_history.append(v)\\n self.last_value = v\\n self.iteration += 1\\n\\n if self.report_freq > 0 and (self.iteration % self.report_freq == 0) and self.report_func is not None:\\n self.report_func(self)\\n\\n # Set the best transform\\n self.transform.set_params(self.best_params)\\n self.last_value = self.best_value\\n return self.best_value\",\n \"def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\\n return x_best, -y_best\",\n \"def nn_ga_optimise_from_args(func_caller, worker_manager, max_capital, mode, mutation_op,\\n crossover_op=None, options=None, reporter='default'):\\n if options is None:\\n reporter = get_reporter(reporter)\\n options = load_options(ga_opt_args, reporter=reporter)\\n options.mode = mode\\n return (NNGAOptimiser(func_caller, worker_manager, mutation_op, crossover_op,\\n options, reporter)).optimise(max_capital)\",\n \"def produce_max(self, *args, **kwargs):\\n raise NotImplementedError('This interaction has no produce_max method yet!')\",\n \"def run_step_blackbox_optimizer(config,\\n current_input,\\n blackbox_optimizer,\\n proposed_perturbations,\\n finished_dnas,\\n results,\\n logging_data=None):\\n core_hyperparameters = blackbox_optimizer.get_hyperparameters()\\n function_values = [0.0] * len(proposed_perturbations)\\n rewards_for_controller = []\\n perturbations = proposed_perturbations\\n evaluation_stats = []\\n current_value_exact = 0.0\\n current_value_exact_counter = 0\\n\\n for i in range(len(results)):\\n rewards_for_controller.append(results[i]['function_value'])\\n tag = results[i]['tag']\\n index = 0\\n if tag > 0:\\n if config.est_type == 'antithetic':\\n index = (tag - 1) * 2\\n function_values[index] += results[i]['function_value']\\n else:\\n index = tag - 1\\n function_values[index] += results[i]['function_value']\\n if tag < 0:\\n index = (-tag - 1) * 2 + 1\\n function_values[index] += results[i]['function_value']\\n if tag == 0:\\n current_value_exact += results[i]['function_value']\\n current_value_exact_counter += 1\\n current_value_exact /= float(current_value_exact_counter)\\n\\n for result in results:\\n evaluation_stat = list(result['evaluation_stat'])\\n evaluation_stats.append(evaluation_stat)\\n\\n function_values_reshaped = np.array(function_values)\\n perturbations_reshaped = np.array(perturbations)\\n\\n logging.info('LIST OF FUNCTION VALUES')\\n logging.info(function_values_reshaped)\\n\\n logging.info('MAX VALUE SEEN CURRENTLY')\\n logging.info(np.max(function_values_reshaped))\\n\\n logging.info('MEAN OF VALUES')\\n logging.info(np.mean(function_values_reshaped))\\n\\n if logging_data is not None:\\n iteration = logging_data['iteration']\\n best_value = logging_data['best_value']\\n iteration = logging_data['iteration']\\n best_input = logging_data['best_input']\\n best_core_hyperparameters = logging_data['best_core_hyperparameters']\\n optimizer_state = blackbox_optimizer.get_state()\\n\\n if current_value_exact > best_value[0]:\\n best_value[0] = current_value_exact\\n best_input = current_input\\n best_core_hyperparameters = core_hyperparameters\\n\\n # Writing logs.\\n if iteration % config.log_frequency == 0:\\n util.log_row(config.params_file, current_input)\\n util.log_row(config.best_params_file, best_input)\\n util.log_row(config.best_core_hyperparameters_file,\\n best_core_hyperparameters)\\n util.log_row(config.best_value_file, best_value)\\n util.log_row(config.optimizer_internal_state_file, optimizer_state)\\n util.log_row(config.current_values_list_file, [current_value_exact])\\n util.log_row(config.best_values_list_file, [best_value[0]])\\n util.log_row(config.fvalues_file, function_values_reshaped)\\n util.log_row(config.iteration_file, [iteration])\\n\\n print('Current exact value estimate:')\\n print(current_value_exact)\\n sys.stdout.flush()\\n\\n new_current_input = blackbox_optimizer.run_step(perturbations_reshaped,\\n function_values_reshaped,\\n current_input,\\n current_value_exact)\\n config.controller.collect_rewards_and_train(rewards_for_controller,\\n finished_dnas)\\n\\n evaluation_stats_reduced = [sum(x) for x in zip(*evaluation_stats)]\\n blackbox_optimizer.update_state(evaluation_stats_reduced)\\n\\n return [True, new_current_input]\",\n \"def run_migrad(self, fitarg, **kwargs):\\n self.fitarg = fitarg\\n kwargs['up'] = 1.\\n\\n\\n logging.debug(self._par_names)\\n logging.debug(self.__wrap_likelihood(list(fitarg['pinit'].values())))\\n\\n if kwargs['scipy']:\\n self._res = op.minimize(self.__wrap_likelihood,\\n list(fitarg['pinit'].values()),\\n bounds=list(fitarg['limits'].values()),\\n method='TNC',\\n #method='Powell',\\n options={'maxiter': kwargs['ncall']} #'xtol': 1e-20, 'eps' : 1e-20, 'disp': True}\\n #tol=None, callback=None,\\n #options={'disp': False, 'minfev': 0, 'scale': None,\\n #'rescale': -1, 'offset': None, 'gtol': -1,\\n #'eps': 1e-08, 'eta': -1, 'maxiter': kwargs['ncall'],\\n #'maxCGit': -1, 'mesg_num': None, 'ftol': -1, 'xtol': -1, 'stepmx': 0,\\n #'accuracy': 0}\\n )\\n logging.info(self._res)\\n for i, k in enumerate(self._par_names):\\n fitarg[k] = self._res.x[i]\\n\\n logging.debug(fitarg)\\n\\n cmd_string = \\\"lambda {0}: self.__calcLikelihood({0})\\\".format(\\n (\\\", \\\".join(self._par_names), \\\", \\\".join(self._par_names)))\\n\\n string_args = \\\", \\\".join(self._par_names)\\n global f # needs to be global for eval to find it\\n f = lambda *args: self.__calc_likelihood(*args)\\n\\n cmd_string = \\\"lambda %s: f(%s)\\\" % (string_args, string_args)\\n logging.debug(cmd_string)\\n\\n # work around so that the parameters get names for minuit\\n self._minimize_f = eval(cmd_string, globals(), locals())\\n self._minimize_f.errordef = minuit.Minuit.LEAST_SQUARES\\n\\n self._m = minuit.Minuit(self._minimize_f,\\n #list(fitarg['pinit'].values()),\\n **fitarg['pinit'],\\n #names=self._par_names\\n )\\n# print_level=kwargs['verbosity'],\\n# errordef=kwargs['up'],\\n# pedantic=kwargs['pedantic'],\\n #**fitarg)\\n\\n for p in self._par_names:\\n self._m.fixed[p] = fitarg['fix'][p]\\n self._m.limits[p] = fitarg['limits'][p]\\n self._m.errors[p] = fitarg['error'][p]\\n\\n self._m.tol = kwargs['tol']\\n self._m.strategy = kwargs['strategy']\\n\\n logging.debug(\\\"tol {0:.2e}, strategy: {1:n}\\\".format(\\n self._m.tol, self._m.strategy.strategy))\\n\\n self._m.migrad(ncall=kwargs['ncall']) #, precision = kwargs['precision'])\",\n \"def solve(self, **kwargs) -> OptimizationResult:\\n raise NotImplementedError\",\n \"def optimize(self, objective_sense=None, **kwargs):\\n\\n if objective_sense:\\n self.objective.direction = objective_sense\\n\\n try:\\n # self._hidden_optimize_call(kwargs)\\n Model.optimize(self, **kwargs)\\n solution = self.get_solution()\\n self.solution = solution\\n return solution\\n except SolverError as SE:\\n status = self.solver.status\\n self.logger.error(SE)\\n self.logger.warning('Solver status: {}'.format(status))\\n raise (SE)\",\n \"def getMaximum(self, arguments, maximum):\\n\\n self.sequence.append({\\\"type\\\": \\\"findingMaximum\\\", \\\"coords\\\": arguments})\\n\\n self.sequence.append({\\\"type\\\": \\\"foundMaximum\\\", \\\"coord\\\": maximum})\",\n \"def maximize(self,x0,method='fmin',**kwargs):\\n return self._optimize(x0,'max',method,**kwargs)\",\n \"def _random_max_wrap(*args):\\n _, opt_pt = random_maximise(*args)\\n return opt_pt\",\n \"def minimize_neldermead(func, x0, args=(), callback=None,\\n maxiter=None, maxfev=None, disp=False,\\n return_all=False, initial_simplex=None,\\n xatol=1e-4, fatol=1e-4, **unknown_options):\\n maxfun = maxfev\\n retall = return_all\\n\\n rho = 1\\n chi = 2\\n psi = 0.5\\n sigma = 0.5\\n nonzdelt = 0.05\\n zdelt = 0.00025\\n\\n if initial_simplex is None:\\n N = len(x0)\\n\\n sim = numpy.zeros((N + 1, N), dtype=x0.dtype)\\n sim[0] = x0\\n for k in range(N):\\n y = numpy.array(x0, copy=True)\\n if y[k] != 0:\\n y[k] = (1 + nonzdelt) * y[k]\\n else:\\n y[k] = zdelt\\n sim[k + 1] = y\\n\\n maxiter = 10\\n maxfun = 10\\n\\n one2np1 = list(range(1, N + 1))\\n fsim = numpy.zeros((N + 1,), float)\\n\\n for k in range(N + 1):\\n fsim[k] = func(sim[k])\\n\\n ind = numpy.argsort(fsim)\\n fsim = numpy.take(fsim, ind, 0)\\n # sort so sim[0,:] has the lowest function value\\n sim = numpy.take(sim, ind, 0)\\n raise Exception()\\n print('aaaaffaaaaaa')\\n\\n iterations = 1\\n\\n while iterations < maxiter:\\n if (numpy.max(numpy.ravel(numpy.abs(sim[1:] - sim[0]))) <= xatol and\\n numpy.max(numpy.abs(fsim[0] - fsim[1:])) <= fatol):\\n break\\n logger.debug('itr: %s' % iterations)\\n print('aaaaaaaaaa')\\n xbar = numpy.add.reduce(sim[:-1], 0) / N\\n xr = (1 + rho) * xbar - rho * sim[-1]\\n fxr = func(xr)\\n doshrink = 0\\n\\n if fxr < fsim[0]:\\n xe = (1 + rho * chi) * xbar - rho * chi * sim[-1]\\n fxe = func(xe)\\n\\n if fxe < fxr:\\n sim[-1] = xe\\n fsim[-1] = fxe\\n else:\\n sim[-1] = xr\\n fsim[-1] = fxr\\n else: # fsim[0] <= fxr\\n if fxr < fsim[-2]:\\n sim[-1] = xr\\n fsim[-1] = fxr\\n else: # fxr >= fsim[-2]\\n # Perform contraction\\n if fxr < fsim[-1]:\\n xc = (1 + psi * rho) * xbar - psi * rho * sim[-1]\\n fxc = func(xc)\\n\\n if fxc <= fxr:\\n sim[-1] = xc\\n fsim[-1] = fxc\\n else:\\n doshrink = 1\\n else:\\n # Perform an inside contraction\\n xcc = (1 - psi) * xbar + psi * sim[-1]\\n fxcc = func(xcc)\\n\\n if fxcc < fsim[-1]:\\n sim[-1] = xcc\\n fsim[-1] = fxcc\\n else:\\n doshrink = 1\\n\\n if doshrink:\\n for j in one2np1:\\n sim[j] = sim[0] + sigma * (sim[j] - sim[0])\\n fsim[j] = func(sim[j])\\n\\n ind = numpy.argsort(fsim)\\n sim = numpy.take(sim, ind, 0)\\n fsim = numpy.take(fsim, ind, 0)\\n if callback is not None:\\n callback(sim[0])\\n iterations += 1\\n\\n x = sim[0]\\n fval = numpy.min(fsim)\\n warnflag = 0\\n\\n result = OptimizeResult(fun=fval, nit=iterations, nfev=0,\\n status=warnflag, success=(warnflag == 0),\\n message=None, x=x, final_simplex=(sim, fsim))\\n return result\",\n \"def expectimax_move(game, method='score'):\\n\\n if method == 'score':\\n def val(g):\\n return g[1]\\n elif method == 'empty':\\n val = empty_squares\\n elif method == 'gradient':\\n val = gradient_value\\n else:\\n print('Invalid method given to expectimax function')\\n exit(1)\\n\\n _, move = expectimax(game, 2, val)\\n return move\",\n \"def optimize(self, max_iters=1e3, messages=False, use_counter=False,\\\\\\n factr=1e7, pgtol=1e-05):\\n logger.debug('Beginning MLE to optimize hyperparams. grad_method=%s'\\\\\\n % self.grad_method)\\n\\n # setup the optimization\\n try:\\n x0 = self._transform_parameters(self.parameters)\\n assert np.all(np.isfinite(x0))\\n except:\\n logger.error('Transformation failed for initial values. '\\\\\\n + 'Ensure constraints are met or the value is not too small.')\\n raise\\n\\n # filter out the fixed parameters\\n free = np.logical_not(self._fixed_indicies)\\n x0 = x0[free]\\n\\n # setup the counter\\n if use_counter:\\n self._counter = solver_counter(disp=True)\\n else:\\n self._counter = None\\n\\n # run the optimization\\n try:\\n x_opt, f_opt, opt = fmin_l_bfgs_b(func=self._objective_grad, x0=x0,\\\\\\n factr=factr, pgtol=pgtol, maxiter=max_iters, disp=messages)\\n except (KeyboardInterrupt,IndexError):\\n logger.info('Keyboard interrupt raised. Cleaning up...')\\n if self._counter is not None and self._counter.backup is not None:\\n self.parameters = self._counter.backup[1]\\n logger.info('will return best parameter set with'\\\\\\n + 'log-likelihood = %.4g' % self._counter.backup[0])\\n else:\\n logger.info('Function Evals: %d. Exit status: %s' % (f_opt, opt['warnflag']))\\n # extract the optimal value and set the parameters to this\\n transformed_parameters = self._previous_parameters \\n transformed_parameters[free] = x_opt\\n self.parameters = self._untransform_parameters(transformed_parameters)\\n return opt\",\n \"def poll(target, step, args=(), kwargs=None, timeout=None, max_tries=None, check_success=is_truthy,\\n step_function=step_constant, ignore_exceptions=(), poll_forever=False, collect_values=None, *a, **k):\\n\\n logging.info('Starting Polling')\\n\\n assert (timeout is not None or max_tries is not None) or poll_forever, \\\\\\n ('You did not specify a maximum number of tries or a timeout. Without either of these set, the polling '\\n 'function will poll forever. If this is the behavior you want, pass \\\"poll_forever=True\\\"')\\n\\n assert not ((timeout is not None or max_tries is not None) and poll_forever), \\\\\\n 'You cannot specify both the option to poll_forever and max_tries/timeout.'\\n\\n kwargs = kwargs or dict()\\n values = collect_values or Queue()\\n\\n max_time = Time.time() + timeout if timeout else None\\n tries = 0\\n logging.debug('Max Time: ' + str(max_time))\\n logging.debug('Max Tries: ' + str(max_tries))\\n\\n last_item = None\\n while True:\\n\\n if max_tries is not None and tries >= max_tries:\\n raise MaxCallException(values, last_item)\\n\\n try:\\n logging.debug('Arguments: ' + str(args))\\n val = target(*args, **kwargs)\\n logging.debug('Results from Target running: ' + str(val))\\n last_item = val\\n logging.info('Try #:' + str(tries))\\n DisplayMessage('Try #:' + str(tries))\\n except ignore_exceptions as e:\\n logging.error(str(e))\\n last_item = e\\n else:\\n # Condition passes, this is the only \\\"successful\\\" exit from the polling function\\n if check_target_success(val):\\n return val\\n\\n logging.debug('last result from poll: ' + str(last_item))\\n # Condition passes, this is the only \\\"successful\\\" exit from the polling function\\n if check_target_success(val):\\n return val\\n else:\\n values.put(last_item)\\n tries += 1\\n # Check the time after to make sure the poll function is called at least once\\n if max_time is not None and Time.time() >= max_time:\\n # raise TimeoutException(values, last_item)\\n logging.info('Time out reached.')\\n logging.info('Checking status of job: ' + val)\\n logging.info('Job will now sleep for an additional: ' + step)\\n logging.debug('Step value: ' + str(step))\\n Time.sleep(step)\\n step = step_function(step)\",\n \"def optimise_fn(self, x):\\n\\n success = self._set_material_parameters(x)\\n if not success:\\n return self._bad_metric()\\n\\n # some iterations are repeated so cache the results to avoid unnecessary iterations\\n cached_result_key = tuple(x)\\n metric_value = self.cached_results.get(cached_result_key)\\n\\n if metric_value is None:\\n print('--> Optimiser: {}'.format(self.material_model))\\n\\n sim_result = fs.run_simulation(stoma_cfg=self.stoma_cfg,\\n from_optimiser=True)\\n\\n # when the simulation fails we want a non-constant measure for the optimiser to use\\n metric_value = sim_result.metric_value if sim_result.success else self._bad_metric()\\n\\n self.cached_results[cached_result_key] = metric_value\\n\\n print('--> Optimiser: {} - metric={}'.format(self.material_model, metric_value))\\n else:\\n print('--> Optimiser: {} - metric={} (cached result)'.format(self.material_model, metric_value))\\n\\n return metric_value\",\n \"def max_(*args, **kwargs):\\n ...\",\n \"def test_maximax():\\n f = np.asarray([\\n [0.99, 1.0, 0.5],\\n [0.69, 0.6, 0.6]])\\n R = common_metrics.maximax(f, maximise=True)\\n expected = np.asarray(\\n [1.0, 0.69])\\n assert np.allclose(R, expected)\\n R = common_metrics.maximax(f, maximise=False)\\n expected = np.asarray(\\n [-0.5, -0.6])\\n assert np.allclose(R, expected)\",\n \"def adaptive_scan(detectors, target_field, motor, start, stop,\\n min_step, max_step, target_delta, backstep,\\n threshold=0.8, *, md=None):\\n _md = {'detectors': [det.name for det in detectors],\\n 'motors': [motor.name],\\n 'plan_args': {'detectors': list(map(repr, detectors)),\\n 'motor': repr(motor),\\n 'start': start,\\n 'stop': stop,\\n 'min_step': min_step,\\n 'max_step': max_step,\\n 'target_delta': target_delta,\\n 'backstep': backstep,\\n 'threshold': threshold},\\n 'plan_name': 'adaptive_scan',\\n }\\n _md.update(md or {})\\n\\n @stage_decorator(list(detectors) + [motor])\\n @run_decorator(md=_md)\\n def adaptive_core():\\n next_pos = start\\n step = (max_step - min_step) / 2\\n past_I = None\\n cur_I = None\\n cur_det = {}\\n while next_pos < stop:\\n yield Msg('checkpoint')\\n yield Msg('set', motor, next_pos, group='A')\\n yield Msg('wait', None, 'A')\\n yield Msg('create', None, name='primary')\\n for det in detectors:\\n yield Msg('trigger', det, group='B')\\n yield Msg('wait', None, 'B')\\n for det in separate_devices(detectors + [motor]):\\n cur_det = yield Msg('read', det)\\n if cur_det is not None and target_field in cur_det:\\n cur_I = cur_det[target_field]['value']\\n yield Msg('save')\\n\\n # special case first first loop\\n if past_I is None:\\n past_I = cur_I\\n next_pos += step\\n continue\\n\\n dI = np.abs(cur_I - past_I)\\n\\n slope = dI / step\\n if slope:\\n new_step = np.clip(target_delta / slope, min_step, max_step)\\n else:\\n new_step = np.min([step * 1.1, max_step])\\n\\n # if we over stepped, go back and try again\\n if backstep and (new_step < step * threshold):\\n next_pos -= step\\n step = new_step\\n else:\\n past_I = cur_I\\n step = 0.2 * new_step + 0.8 * step\\n next_pos += step\\n\\n return (yield from adaptive_core())\",\n \"def optimize(self, iterations=1000):\\r\\n prev = None\\r\\n finalx = None\\r\\n finaly = None\\r\\n while iterations:\\r\\n maxei, eis = self.acquisition()\\r\\n new_y = self.f(maxei)\\r\\n if maxei == prev:\\r\\n break\\r\\n self.gp.update(maxei, new_y)\\r\\n pycodehack = finaly is None or self.minimize and finaly > new_y\\r\\n if ((pycodehack or not self.minimize and finaly < new_y)):\\r\\n finaly = new_y\\r\\n finalx = maxei\\r\\n prev = maxei\\r\\n iterations -= 1\\r\\n return finalx, finaly\",\n \"def test_minimax_regret():\\n f = np.asarray([\\n [0.99, 1.0, 0.5],\\n [0.69, 0.6, 0.6]])\\n R = common_metrics.minimax_regret(f, maximise=True)\\n expected = np.asarray(\\n [-0.1, -0.4])\\n assert np.allclose(R, expected)\\n R = common_metrics.minimax_regret(f, maximise=False)\\n expected = np.asarray(\\n [-0.4, -0.1])\\n assert np.allclose(R, expected)\",\n \"def annealing(self, precision=None, print_steps=True):\\n if self.max_temp is None:\\n self.get_max_temp()\\n state = self.individuals[0]\\n self._temp = self.max_temp\\n generation = 0\\n mins = []\\n while self.evaluations < self.eval_limit:\\n equilibrium = False\\n while not equilibrium:\\n solution = self.get_neighbour(state.solution)\\n value = self.get_solutions_value(solution)\\n fitness = self.get_fitness(value)\\n if self.acceptance_probability(state.value, value, self._temp) > np.random.random():\\n equilibrium = True\\n if self.evaluations % 100 == 0:\\n mins += [self.best_individual.value]\\n if self.evaluations > self.eval_limit:\\n break\\n state.solution = solution\\n state.value = value\\n state.fitness = fitness\\n self.update_temperature()\\n if state.fitness > self.best_individual.fitness:\\n self.best_individual = copy.deepcopy(state)\\n if print_steps:\\n print(\\\"Generation \\\", generation, \\\"; Evaluations: \\\", self.evaluations,\\n \\\"; Temperature: \\\", self._temp, \\\"; \\\", state)\\n if precision is not None and self.solution_precision(precision):\\n break\\n generation += 1\\n return self.best_individual, mins\",\n \"def optimization_step(self):\\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\\n \\n var_list = [self.x_tilda, self.minibatch_set]\\n \\n if (self.num_samples > 0) and (not self.mixture):\\n \\n if ((self.mf_steps > 0) and self.alpha >0) or\\\\\\n self.gibbs_steps > 0: \\n \\n var_list.append(self.sampler_theta)\\n \\n elif \\\"CD\\\" in self.algorithm:\\n \\n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \\n \\n var_list = [self.minibatch_set]\\n \\n var_list.append(self.learning_rate)\\n \\n if self.use_momentum:\\n \\n var_list.append(self.momentum)\\n \\n output_vars = [self.pseudo_cost]\\n \\n if self.report_p_tilda:\\n \\n output_vars.append(self.p_tilda)\\n \\n else:\\n \\n output_vars.append(theano.shared(0))\\n \\n opt_step = theano.function(inputs = var_list,\\n outputs = output_vars,\\n updates = self.updates,\\n givens = input_dict,\\n on_unused_input='warn')\\n \\n return opt_step\",\n \"def step(self, action):\\n self.steps += 1\\n in_var = self.state[:4]\\n\\n # Increase or decrease the 4 input values\\n new_var = in_var+ action \\n\\n #If the agent tries to exceed the range of the mins & maxes, this sets them to the max. \\n for i,temp_i in enumerate(new_var):\\n if (temp_i <= self.mins[i]):\\n new_var[i] = self.mins[i]\\n elif (temp_i >= self.maxes[i]): \\n new_var[i] = self.maxes[i]\\n\\n in_var = new_var\\n\\n # Get all the new outputs:\\n self.ins = in_var\\n out_flow = self.temp_func(var=self.O_CH4_flow_uniformity)\\n out_frac = self.temp_func(var=self.O_CH4_mol_frac)\\n out_temp = self.temp_func(var=self.O_t)\\n\\n #check that this is a viable output; if not, reject the action\\n #is this temp change viable?\\n \\n MSE1 = (self.goals[0]-out_flow)**2\\n MSE2 = (self.goals[1]-out_frac)**2\\n MSE3 = (self.goals[2]-out_temp)**2\\n\\n MSE = MSE1 + MSE2 + MSE3\\n\\n # Update your state:\\n state_new = np.append(self.ins,[out_flow,out_frac,out_temp] )\\n self.state =np.append(state_new,self.goals)\\n\\n done = ((MSE1 <= self.MSE_thresh1) & (MSE2 <= self.MSE_thresh2) & (MSE3 <= self.MSE_thresh3))\\n done = bool(done)\\n\\n # Get the corresponding reward:\\n reward = 0\\n if done:\\n reward += self.rew_goal\\n else: \\n reward -= MSE *cfg['MSE_scale']\\n\\n self.reward = reward\\n self.tot_rew += reward\\n self.done = done\\n\\n return (self.state, reward, done, {'MSE thresh': self.MSE_thresh1})\",\n \"def solve(self, example_name, max_iter = 100, is_check_stop = True, maximum_line_search = 10):\\n logger.debug(\\\"[+ +] Initial Obj.Val.: %.5e\\\"%(self.get_obj_fun_value()))\\n start_time = tm.time()\\n for i in range(max_iter):\\n if i == 1: # skip the compiling time \\n start_time = tm.time()\\n iter_start_time = tm.time()\\n self.backward_pass()\\n backward_time = tm.time()\\n obj, isStop = self.forward_pass(max_line_search=maximum_line_search)\\n forward_time = tm.time()\\n logger.debug(\\\"[+ +] Iter.No.%3d BWTime:%.3e FWTime:%.3e Obj.Val.:%.5e\\\"%(\\n i, backward_time-iter_start_time,forward_time-backward_time,obj))\\n result_path = os.path.join(\\\"logs\\\", example_name, str(i) +\\\".mat\\\")\\n io.savemat(result_path,{\\\"trajectory\\\": self.get_traj()})\\n if isStop and is_check_stop:\\n break\\n end_time = tm.time()\\n logger.debug(\\\"[+ +] Completed! All Time:%.5e\\\"%(end_time-start_time))\",\n \"def optimize(self, X, y, *args):\\n self.loss_function.set_space(X, y, *args)\\n self.betas_ = fastgradalgo(\\n self.loss_function,\\n t_init=self.eta_init,\\n max_iter=self.max_iter\\n )\\n return self.betas_\",\n \"def _optimize(self,x0,type,method,**kwargs):\\n from scipy.optimize import fmin,fmin_powell\\n\\n if type == 'min':\\n g=lambda x:self(x)\\n elif type == 'max':\\n g=lambda xs:-1*self(x)\\n elif type == 'root':\\n g=lambda x:np.abs(self(x))\\n elif type == 'val':\\n val = kwargs.pop('valtofind')\\n g=lambda x:np.abs(self(x)-val)\\n elif type == 'saddle':\\n raise NotImplementedError\\n else:\\n raise ValueError('Unrecognized optimization type')\\n\\n if method == 'fmin':\\n res = fmin(g,x0,**kwargs)\\n elif method == 'fmin_powell':\\n res = fmin_powell(g,x0,**kwargs)\\n else:\\n raise ValueError('Unrecognized method')\\n\\n self.lastOpt = res\\n return res[0]\",\n \"def minimax(self, game, depth):\\n if self.time_left() < self.TIMER_THRESHOLD:\\n raise SearchTimeout()\\n\\n \\\"\\\"\\\"\\n From AIMA psuedocode:\\n\\n function MINIMAX-DECISION(state) returns an action\\n return arg max a is in ACTIONS(s) MIN-VALUE(RESULT(state, a))\\n \\\"\\\"\\\"\\n\\n best_move = (-1,-1)\\n best_score = float(\\\"-inf\\\")\\n actions = game.get_legal_moves()\\n\\n if not actions:\\n return best_move\\n else:\\n best_move = actions[randint(0, len(actions) - 1)]\\n\\n try:\\n # The try/except block will automatically catch the exception\\n # raised when the timer is about to expire.\\n # return max(actions, key=lambda action: self._min_value(game.forecast_move(action), 1))\\n for action in actions:\\n score = self._min_value(game.forecast_move(action), 1)\\n if score > best_score:\\n best_score = score\\n best_move = action\\n\\n except SearchTimeout:\\n pass\\n\\n return best_move\",\n \"def walk_single_walker(at, movement_args, Emax, KEmax):\\n#DOC\\n#DOC ``walk_single_walker``\\n\\n out = {}\\n\\n if movement_args['do_good_load_balance']:\\n possible_moves = np.array( [ do_atom_walk,\\n do_MC_cell_volume_step,\\n do_MC_cell_shear_step,\\n do_MC_cell_stretch_step,\\n do_MC_swap_step,\\n do_MC_semi_grand_step ] )\\n nums = np.array( [ movement_args['n_atom_steps_n_calls'],\\n movement_args['n_cell_volume_steps'],\\n movement_args['n_cell_shear_steps'],\\n movement_args['n_cell_stretch_steps'],\\n movement_args['n_swap_steps'],\\n movement_args['n_semi_grand_steps'] ] )\\n costs = np.array( [ movement_args['atom_traj_len']*movement_args['atom_traj_len_cost_multiplier'],\\n 1,\\n 1,\\n 1,\\n 1,\\n 1 ] )\\n\\n list = create_list(costs, nums, movement_args['n_model_calls'])\\n for move_i in list:\\n (t_n_model_calls, t_out) = possible_moves[move_i](at, movement_args, Emax, KEmax)\\n accumulate_stats(out, t_out)\\n\\n else:\\n #DOC \\\\item create list\\n #DOC \\\\item do\\\\_atom\\\\_walk :math:`*` n\\\\_atom\\\\_step\\\\_n\\\\_calls\\n possible_moves = ( [do_atom_walk] * movement_args['n_atom_steps_n_calls'] +\\n #DOC \\\\item do\\\\_cell\\\\_volume\\\\_step :math:`*` n\\\\_cell\\\\_volume\\\\_steps\\n [do_MC_cell_volume_step] * movement_args['n_cell_volume_steps'] + \\n #DOC \\\\item do\\\\_cell\\\\_shear\\\\_step :math:`*` n\\\\_cell\\\\_shear\\\\_steps\\n [do_MC_cell_shear_step] * movement_args['n_cell_shear_steps'] + \\n #DOC \\\\item do\\\\_cell\\\\_stretch\\\\_step :math:`*` n\\\\_cell\\\\_stretch\\\\_steps\\n [do_MC_cell_stretch_step] * movement_args['n_cell_stretch_steps'] + \\n #DOC \\\\item do\\\\_swap\\\\_step :math:`*` n\\\\_swap\\\\_steps\\n [do_MC_swap_step] * movement_args['n_swap_steps'] +\\n #DOC \\\\item do\\\\_semi\\\\_grand\\\\_step :math:`*` n\\\\_semi\\\\_grand\\\\_steps\\n [do_MC_semi_grand_step] * movement_args['n_semi_grand_steps'] )\\n\\n out = {}\\n n_model_calls_used=0\\n\\n #DOC \\\\item loop while n\\\\_model\\\\_calls\\\\_used < n\\\\_model\\\\_calls\\n while n_model_calls_used < movement_args['n_model_calls']:\\n #DOC \\\\item pick random item from list\\n move = possible_moves[rng.int_uniform(0,len(possible_moves))]\\n #DOC \\\\item do move\\n (t_n_model_calls, t_out) = move(at, movement_args, Emax, KEmax)\\n n_model_calls_used += t_n_model_calls\\n accumulate_stats(out, t_out)\\n\\n\\n #DOC \\\\item perturb final energy by random\\\\_energy\\\\_perturbation\\n # perturb final energy\\n at.info['ns_energy'] = rand_perturb_energy(at.info['ns_energy'],ns_args['random_energy_perturbation'],Emax)\\n\\n #DEBUG print \\\"walk_single_walker end \\\", eval_energy(at, do_PE=False), eval_energy(at) #DEBUG\\n\\n return out\",\n \"def run_qae_optimization(training_states, n_repetitions, exact=no_noise, noisy=gate_error):\\n result_list = []\\n def proxy(params, training_states, n_repetitions, exact=no_noise, noisy=gate_error):\\n \\\"\\\"\\\"Embedded function version\\n \\\"\\\"\\\"\\n input_list = fix_list(params, all_param_array=all_param, var_param_array=var_param, fixed_vals_array=fixed_vals)\\n fidelities = []\\n for training_state in training_states:\\n fid = cusp_stage2.compute_stage2_cost_function(*input_list, alpha=training_state, n_repetitions=n_repetitions,\\n exact=exact, noisy=noisy)\\n fidelities.append(fid)\\n avg_fid = np.mean(fidelities)\\n result_list.append(1-avg_fid)\\n print(1-avg_fid)\\n return 1. - avg_fid\\n\\n \\n # Initialize parameters\\n half_turn_min = 0\\n half_turn_max = 2\\n init_params = np.random.uniform(low=half_turn_min, high=half_turn_max,\\n size=num_param)\\n\\n # Optimization using Nelder-Mead.\\n h2_qae_wrap = lambda params: proxy(params, training_states=training_states,\\n n_repetitions=n_repetitions, exact=exact, noisy=noisy)\\n \\n if noisy:\\n maxiter = 60\\n else:\\n maxiter = None\\n \\n res = minimize(h2_qae_wrap, init_params, args=(),\\n method='Nelder-Mead', tol=None, \\n options={'disp': False, 'maxiter': maxiter, 'xatol': 0.001,\\n 'return_all': False, 'fatol': 0.001})\\n np.savetxt('stage2_data.csv',result_list, delimiter=',')\\n return res.x\",\n \"def minimax(self, gameState, depth, index):\\n ultimateMove = None # The best move the agent can use\\n if depth == 0 or gameState.isWin() or gameState.isLose():\\n # if leaf node return value.\\n return [self.evaluationFunction(gameState), ultimateMove]\\n else:\\n if index == 0: # if pacman => agent is max agent\\n value = -math.inf\\n maxValue = value\\n # iterates through max agent w/index=0 moves\\n for action in gameState.getLegalActions(0):\\n depthIndex = agentCounter(gameState, index+1, depth)\\n successorState = gameState.generateSuccessor(\\n index, action) # generates the next state when move is done\\n value = max(value, minimax(\\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return max of saved value and recursive function\\n if maxValue != value: # If value has changed update values\\n ultimateMove = action\\n maxValue = value\\n return [value, ultimateMove]\\n else: # is ghost => agent is min agent\\n value = math.inf\\n minValue = value\\n # Iterate through the moves of a min agent w/index not 0\\n for action in gameState.getLegalActions(index):\\n depthIndex = agentCounter(gameState, index+1, depth)\\n successorState = gameState.generateSuccessor(\\n index, action)\\n value = min(value, minimax(\\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return min of saved value and recursive function\\n if minValue != value: # If value has changed update values\\n ultimateMove = action\\n minValue = value\\n return [value, ultimateMove]\",\n \"def evaluate(Agent, rules, wrappers, params_path=None, steps=1024):\\n\\n score = 0.0\\n\\n agent = Agent()\\n\\n if params_path is not None:\\n agent.load_state_dict(params_path)\\n\\n env = CARLE()\\n\\n\\n for wrapper in wrappers:\\n env = wrapper[0](env)\\n env.reward_scale = wrapper[1]\\n\\n env.batch_size = steps*len(rules)\\n\\n if wrapper[2] is not None:\\n env.load_state_dict(torch.load(wrapper[2]))\\n\\n env.eval()\\n\\n #env.set_no_grad()\\n\\n total_steps = 0\\n score_trace = []\\n for ruleset in rules:\\n\\n env.inner_env.birth = ruleset[0]\\n env.inner_env.survive = ruleset[0]\\n\\n obs = env.reset()\\n\\n for step in range(steps):\\n\\n action = agent(obs)\\n\\n obs, reward, done, info = env.step(action)\\n\\n score += reward.detach().sum().cpu().numpy()\\n score_trace.append(reward.detach().sum().cpu().numpy())\\n\\n total_steps += 1\\n\\n print(\\\"cumulative score = {:.3e} at total steps = {}, rulset = {}\\\".format(\\\\\\n score, total_steps, ruleset))\\n\\n score /= total_steps\\n \\n return score, score_trace\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # AlphaBetaAgent.callsCount = 0\\n # If the game state is lost or win then just return the evaluation value\\n if gameState.isLose() or gameState.isWin():\\n return self.evaluationFunction(gameState)\\n\\n # This part is almost the same with MinimaxAgent other than two additional parameters of alpha and beta values\\n # by recursion calls in MiniMax tree to make a decision\\n # alpha = the best choice of the highest values we have found so far along the path for MAX.\\n # (initializes -9999999)\\n # beta = the best choice of the lowest values we have found so far along the path for MIN.\\n # (initializes +9999999)\\n\\n finalDirection = self.maxValueAlphaBeta(gameState, self.depth * gameState.getNumAgents(), gameState.getNumAgents(), 0, -9999999, 9999999)\\n # print(\\\"Number of Calls: \\\", AlphaBetaAgent.callsCount)\\n return finalDirection[1]\\n\\n # The helper function to remove STOP action to improve efficiency\\n def removeStop(self, legalMoves):\\n stopDirection = Directions.STOP\\n if stopDirection in legalMoves:\\n legalMoves.remove(stopDirection)\\n\\n # The maxValue method for PacMan whose agent index is zero\\n def maxValueAlphaBeta(self, gameState, depth, numOfAgents, agentIndex, alpha, beta):\\n # AlphaBetaAgent.callsCount += 1\\n legalMoves = gameState.getLegalActions(agentIndex)\\n self.removeStop(legalMoves)\\n # The next states, either passed in to getAction or generated via GameState.generateSuccessor\\n nextStates = [gameState.generateSuccessor(agentIndex, action) for action in legalMoves]\\n if depth == 0 or len(nextStates) == 0:\\n return (self.evaluationFunction(gameState), Directions.STOP)\\n\\n maxValue = -9999999\\n action = legalMoves[0]\\n moveIndex = 0\\n chooseMax = []\\n\\n # There are only one case to call minValue from Pacman perspective\\n for nextState in nextStates:\\n res = self.minValueAlphaBeta(nextState, depth-1, numOfAgents-2, numOfAgents, (agentIndex+1)%numOfAgents, alpha, beta)\\n chooseMax.append(res)\\n if res > maxValue:\\n maxValue = res\\n action = legalMoves[moveIndex]\\n # Check \\\"cut-off\\\" condition\\n if res > alpha: # If alpha is smaller than the current Max value\\n alpha = res # Then replace alpha with the current Max value\\n if alpha >= beta: # When alpha value is larger than beta value\\n return (alpha, action) # beta cut-off\\n moveIndex = moveIndex + 1\\n return (maxValue, action)\",\n \"def optimize(start, stop, step):\\n #Go through every angle\\n rot_angle_list = np.arange(start, stop, step)\\n fitness_list = []\\n best_angles_list = []\\n for (i, rot_angle) in enumerate(rot_angle_list):\\n (fitness, best_angles) = self._angle_fitness(rot_angle, initial_R, ending_vec, starting_vec)\\n fitness_list.append(fitness)\\n best_angles_list.append(best_angles)\\n #Find the best result\\n best_index = np.argmin(fitness_list)\\n best_rot_angle = rot_angle_list[best_index]\\n best_angles = best_angles_list[best_index]\\n return (best_rot_angle, best_angles)\",\n \"def step_func_cat(X, args, Y, info, Ytarget, err, tols, iter, maxIter):\\n [XF, ZF, L, EA, W, CB, WL, WEA, L_EA, CB_EA] = args[\\\"cat\\\"]\\n\\n # if abs( err[1] + ZF ) < 0.0001:\\n # breakpoint()\\n\\n [alpha_min, alpha0, alphaR] = args[\\n \\\"step\\\"\\n ] # get minimum alpha, initial alpha, and alpha reduction rate from passed arguments\\n\\n # J = info['jacobian']\\n # dX = -np.matmul(np.linalg.inv(J), err)\\n dX = -np.matmul(info[\\\"stiffnessB\\\"], err)\\n\\n # ! Reduce dHF by factor (between 1 at I = 1 and 0 at I = MaxIter) that reduces linearly with iteration count\\n # to ensure that we converge on a solution even in the case were we obtain a nonconvergent cycle about the\\n # correct solution (this happens, for example, if we jump to quickly between a taut and slack catenary)\\n\\n alpha = 1.0 # M<<<<<<<< np.max([alpha_min, alpha0*(1.0 - alphaR*iter/maxIter)])\\n\\n # exponential approach alpha = alpha0 * np.exp( iter/maxIter * np.log(alpha_min/alpha0 ) )\\n\\n dX[0] = dX[0] * alpha # dHF*( 1.0 - Tol*I )\\n dX[1] = dX[1] * alpha # dVF*( 1.0 - Tol*I )\\n\\n # To avoid an ill-conditioned situation, make sure HF does not go less than or equal to zero by having a lower limit of Tol*HF\\n # [NOTE: the value of dHF = ( Tol - 1.0 )*HF comes from: HF = HF + dHF = Tol*HF when dHF = ( Tol - 1.0 )*HF]\\n # dX[0] = max( dX[0], ( tol - 1.0 )*info['HF']);\\n\\n # To avoid an ill-conditioned situation, make sure HF does not get too close to zero, by forcing HF >= tols[0]\\n # if info['HF'] + dX[0] <= tol*abs(info['VF']+dX[1]):\\n # if info['HF'] + dX[0] <= tols[0]\\n if X[0] + dX[0] <= tols[0]:\\n # dX[0] = tol*abs(info['VF']+dX[1]) - info['HF']\\n # dX[0] = tols[0] - info['HF']\\n dX[0] = tols[0] - X[0]\\n\\n # To avoid an ill-conditioned situation where the line is nearly all on the seabed but the solver gets stuck,\\n # if np.abs(err[1] + ZF)/ZF < tol:\\n # breakpoint()\\n # deltaHFVF = info['HF'] - info['VF']\\n # dX[0] = dX[0] - 0.5*deltaHFVF\\n # dX[1] = dX[1] + 0.5*deltaHFVF\\n\\n # prevent silly situation where a line with weight and positive ZF considers a negative VF\\n if info[\\\"ProfileType\\\"] == 2:\\n if X[1] + dX[1] <= tols[1]: # if vertical force is within tolerance of being zero/negative\\n VFtarget = (L - info[\\\"LBot\\\"]) * W # set next VF value to be the weight of portion of line that's suspended\\n dX[1] = VFtarget - X[1]\\n\\n return dX # returns dX (step to make)\",\n \"def optimizing(theta, data = data, target = target):\\n # num = (sin(individual[0] - individual[1] / 8))**2 + (sin(individual[1] + individual[0] / 8))**2\\n # denum = ((individual[0] - 8.6998)**2 + (individual[1] - 6.7665)**2)**0.5 + 1\\n learner = MLPClassifier(hidden_layer_sizes=theta[0], learning_rate_init=theta[1], alpha=theta[2], verbose=True, early_stopping=True, n_iter_no_change=6)\\n\\n model = learner.fit(data, target)\\n return model.best_loss_ # return the best error/residual (best error is cloes to zero) The error of a model is the difference between your predicted outcome and the real observed outcome and therefore 0 is desired\\n\\n # individual as a factor containing x, y = to tetha which \",\n \"def heuristics(e, z, z0, direction):\\n\\n from sympy.calculus.util import AccumBounds\\n rv = None\\n if abs(z0) is S.Infinity:\\n rv = limit(e.subs(z, 1 / z), z, S.Zero, 1 if z0 is S.Infinity else -1)\\n if isinstance(rv, Limit):\\n return\\n elif e.is_Mul or e.is_Add or e.is_Pow or e.is_Function:\\n r = []\\n for a in e.args:\\n l = limit(a, z, z0, direction)\\n if l.has(S.Infinity) and l.is_finite is None:\\n if isinstance(e, Add):\\n m = factor_terms(e)\\n if not isinstance(m, Mul): # try together\\n m = together(m)\\n if not isinstance(m, Mul): # try factor if the previous methods failed\\n m = factor(e)\\n if isinstance(m, Mul):\\n return heuristics(m, z, z0, direction)\\n return\\n return\\n elif isinstance(l, Limit):\\n return\\n elif l is S.NaN:\\n return\\n else:\\n r.append(l)\\n if r:\\n rv = e.func(*r)\\n if rv is S.NaN and e.is_Mul and any(isinstance(rr, AccumBounds) for rr in r):\\n r2 = []\\n e2 = []\\n for ii in range(len(r)):\\n if isinstance(r[ii], AccumBounds):\\n r2.append(r[ii])\\n else:\\n e2.append(e.args[ii])\\n\\n if len(e2) > 0:\\n from sympy import simplify\\n e3 = simplify(Mul(*e2))\\n l = limit(e3, z, z0, direction)\\n rv = l * Mul(*r2)\\n\\n if rv is S.NaN:\\n try:\\n rat_e = ratsimp(e)\\n except PolynomialError:\\n return\\n if rat_e is S.NaN or rat_e == e:\\n return\\n return limit(rat_e, z, z0, direction)\\n return rv\",\n \"def mod_space_opt(\\n *,\\n space,\\n dryness_method,\\n fuel_build_up_method,\\n include_temperature,\\n discrete_params,\\n defaults=None,\\n basinhopping_options=None,\\n minimizer_options=None,\\n mode=\\\"basinhopping\\\",\\n x0=None,\\n):\\n to_optimise = gen_to_optimise(\\n fail_func=fail_func,\\n success_func=success_func,\\n # Init (data) params.\\n dryness_method=dryness_method,\\n fuel_build_up_method=fuel_build_up_method,\\n include_temperature=include_temperature,\\n _uncached_data=False,\\n **discrete_params,\\n )\\n\\n defaults_dict = defaults if defaults is not None else {}\\n\\n def to_optimise_with_discrete(x):\\n return to_optimise(\\n **space.inv_map_float_to_0_1(dict(zip(space.continuous_param_names, x))),\\n **defaults_dict,\\n )\\n\\n def basinhopping_callback(x, f, accept):\\n # NOTE: Parameters recorded here are authoritative, since hyperopt will not\\n # properly report values modified as in e.g. `mod_quniform`.\\n values = {\\n **space.inv_map_float_to_0_1(dict(zip(space.continuous_param_names, x))),\\n **discrete_params,\\n **defaults_dict,\\n }\\n values[\\\"dryness_method\\\"] = dryness_method\\n values[\\\"fuel_build_up_method\\\"] = fuel_build_up_method\\n values[\\\"include_temperature\\\"] = include_temperature\\n\\n minimizer_options_dict = minimizer_options if minimizer_options is not None else {}\\n basinhopping_options_dict = (\\n basinhopping_options if basinhopping_options is not None else {}\\n )\\n\\n if x0 is None:\\n x0 = space.continuous_x0_mid\\n\\n if mode == \\\"basinhopping\\\":\\n res = basinhopping(\\n to_optimise_with_discrete,\\n x0=x0,\\n seed=0,\\n callback=basinhopping_callback,\\n take_step=BoundedSteps(\\n stepsize=0.3, rng=np.random.default_rng(0), verbose=True\\n ),\\n **{\\n \\\"disp\\\": True,\\n \\\"minimizer_kwargs\\\": dict(\\n method=\\\"L-BFGS-B\\\",\\n jac=None,\\n bounds=[(0, 1)] * len(space.continuous_param_names),\\n options={\\n \\\"maxiter\\\": 60,\\n \\\"ftol\\\": 1e-5,\\n \\\"eps\\\": 1e-3,\\n **minimizer_options_dict,\\n },\\n ),\\n \\\"T\\\": 0.05,\\n \\\"niter\\\": 100,\\n \\\"niter_success\\\": 15,\\n **basinhopping_options_dict,\\n },\\n )\\n elif mode == \\\"minimize\\\":\\n res = minimize(\\n to_optimise_with_discrete,\\n x0=x0,\\n method=\\\"L-BFGS-B\\\",\\n jac=None,\\n bounds=[(0, 1)] * len(space.continuous_param_names),\\n options={\\n \\\"maxiter\\\": 60,\\n \\\"ftol\\\": 1e-5,\\n \\\"eps\\\": 1e-3,\\n **minimizer_options_dict,\\n },\\n )\\n else:\\n raise ValueError\\n\\n return res\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n def MaxValue(gameState, currentDepth, agentNumber):\\n \\n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\\n \\n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\\n return (self.evaluationFunction(gameState), Directions.NORTH)\\n #print 'depth ',currentDepth\\n \\n largestValue = float(\\\"-inf\\\")\\n bestAction = Directions.NORTH\\n for action in gameState.getLegalActions(agentNumber):\\n #print 'analyzing ',action,' for pacman ',agentNumber\\n successor = gameState.generateSuccessor(agentNumber, action)\\n successorValue = MinValue(successor, currentDepth, (agentNumber + 1) % gameState.getNumAgents())[0]\\n if(successorValue > largestValue):\\n largestValue = successorValue\\n bestAction = action\\n return (largestValue, bestAction)\\n \\n def MinValue(gameState, currentDepth, agentNumber):\\n if currentDepth is self.depth or gameState.isWin() or gameState.isLose():\\n #print 'evaluation function at leaf ',self.evaluationFunction(gameState)\\n return (self.evaluationFunction(gameState), Directions.NORTH)\\n \\n #print 'depth ',currentDepth\\n \\n smallestValue = float(\\\"inf\\\")\\n bestAction = Directions.NORTH \\n for action in gameState.getLegalActions(agentNumber):\\n #print 'analyzing ',action,' for ghost ',agentNumber\\n successor = gameState.generateSuccessor(agentNumber, action)\\n nextAgentNumber = (agentNumber + 1) % gameState.getNumAgents()\\n if nextAgentNumber is 0:\\n successorValue = MaxValue(successor, currentDepth + 1, nextAgentNumber)[0]\\n else:\\n successorValue = MinValue(successor, currentDepth, nextAgentNumber)[0]\\n if(successorValue < smallestValue):\\n smallestValue = successorValue\\n bestAction = action\\n return (smallestValue, bestAction)\\n\\n result = MaxValue(gameState, 0, 0)\\n resultActionToTake = result[1]\\n #print 'Minimax value for depth ', self.depth,' ',result[0]\\n #import time\\n #time.sleep(1000000)\\n return resultActionToTake\",\n \"def best_metric(\\n self, return_step: bool = False\\n ) -> Union[\\n None,\\n float,\\n Tuple[float, int],\\n Tuple[None, None],\\n Dict[str, Union[float, None]],\\n Tuple[Dict[str, Union[float, None]], Dict[str, Union[int, None]]],\\n ]:\\n res = self.compute_all()\\n if isinstance(res, list):\\n rank_zero_warn(\\n \\\"Encounted nested structure. You are probably using a metric collection inside a metric collection, or\\\"\\n \\\" a metric wrapper inside a metric collection, which is not supported by `.best_metric()` method.\\\"\\n \\\"Returning `None` instead. Please consider \\\"\\n )\\n if return_step:\\n return None, None\\n return None\\n\\n if isinstance(self._base_metric, Metric):\\n fn = torch.max if self.maximize else torch.min\\n try:\\n value, idx = fn(res, 0)\\n if return_step:\\n return value.item(), idx.item()\\n return value.item()\\n except (ValueError, RuntimeError) as error:\\n rank_zero_warn(\\n f\\\"Encountered the following error when trying to get the best metric: {error}\\\"\\n \\\"this is probably due to the 'best' not being defined for this metric.\\\"\\n \\\"Returning `None` instead.\\\",\\n UserWarning,\\n )\\n if return_step:\\n return None, None\\n return None\\n\\n else: # this is a metric collection\\n maximize = self.maximize if isinstance(self.maximize, list) else len(res) * [self.maximize]\\n value, idx = {}, {}\\n for i, (k, v) in enumerate(res.items()):\\n try:\\n fn = torch.max if maximize[i] else torch.min\\n out = fn(v, 0)\\n value[k], idx[k] = out[0].item(), out[1].item()\\n except (ValueError, RuntimeError) as error: # noqa: PERF203 # todo\\n rank_zero_warn(\\n f\\\"Encountered the following error when trying to get the best metric for metric {k}:\\\"\\n f\\\"{error} this is probably due to the 'best' not being defined for this metric.\\\"\\n \\\"Returning `None` instead.\\\",\\n UserWarning,\\n )\\n value[k], idx[k] = None, None\\n\\n if return_step:\\n return value, idx\\n return value\",\n \"def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\\r\\n\\r\\n\\t\\r\\n\\tif grad == 'NO':\\r\\n\\t\\tif method == 'Powell' :\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'Nelder-Mead':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t options = {'ftol': 0.0001})\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'default':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, \\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\r\\n\\telif grad == 'YES':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \\r\\n \\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\\r\\n\\t\\treturn res.x, res.nit \\r\\n\\t\\t\\t\\r\\n\\t\\t\\r\\n\\telif grad == 'HESS':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\\r\\n\\t\\t\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t\\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \\r\\n\\t\\treturn res.x, res.nit\",\n \"def maxlikelihood(self):\\n\\n chi2 = lambda *args: -2 * lnlikelihood.lnlike(*args) \\n # print('***DEBUGGING*** chi2 = ', chi2)\\n # print('***DEBUGGING*** self.theta_guess = ', self.theta_guess)\\n # print('***DEBUGGING*** self.transinfo = ', self.transinfo)\\n # print('***DEBUGGING*** self.wave_b = ', self.wave_b)\\n # print('***DEBUGGING*** self.flux_b = ', self.flux_b)\\n # print('***DEBUGGING*** self.err_b = ', self.err_b)\\n # print('***DEBUGGING*** self.wave_r = ', self.wave_r)\\n # print('***DEBUGGING*** self.flux_r = ', self.flux_r)\\n # print('***DEBUGGING*** self.err_r = ', self.err_r)\\n # print('***DEBUGGING*** self.velres = ', self.velres)\\n result = op.minimize(chi2, self.theta_guess,\\n args=(self.transinfo, self.wave_b, self.flux_b, self.err_b,\\n self.wave_r, self.flux_r, self.err_r, self.velres))\\n\\n self.theta_ml = result[\\\"x\\\"]\",\n \"def minimize_nelder_mead(\\n objective_func, parameter_guess, verbose=False, which_vars=None, **kwargs\\n):\\n # Specify a temporary \\\"modified objective function\\\" that restricts parameters to be estimated\\n if which_vars is None:\\n which_vars = np.ones(len(parameter_guess), dtype=bool)\\n\\n def objective_func_mod(params):\\n params_full = np.copy(parameter_guess)\\n params_full[which_vars] = params\\n out = objective_func(params_full)\\n return out\\n\\n # convert parameter guess to np array to slice it with boolean array\\n parameter_guess_mod = np.array(parameter_guess)[which_vars]\\n\\n # Execute the minimization, starting from the given parameter guess\\n t0 = time() # Time the process\\n OUTPUT = fmin(\\n objective_func_mod, parameter_guess_mod, full_output=1, disp=verbose, **kwargs\\n )\\n t1 = time()\\n\\n # Extract values from optimization output:\\n xopt = OUTPUT[0] # Parameters that minimize function.\\n fopt = OUTPUT[1] # Value of function at minimum: ``fopt = func(xopt)``.\\n optiter = OUTPUT[2] # Number of iterations performed.\\n funcalls = OUTPUT[3] # Number of function calls made.\\n warnflag = OUTPUT[4] # warnflag : int\\n # 1 : Maximum number of function evaluations made.\\n # 2 : Maximum number of iterations reached.\\n # Check that optimization succeeded:\\n if warnflag != 0:\\n warnings.warn(\\n \\\"Minimization failed! xopt=\\\"\\n + str(xopt)\\n + \\\", fopt=\\\"\\n + str(fopt)\\n + \\\", optiter=\\\"\\n + str(optiter)\\n + \\\", funcalls=\\\"\\n + str(funcalls)\\n + \\\", warnflag=\\\"\\n + str(warnflag)\\n )\\n xopt_full = np.copy(parameter_guess)\\n xopt_full[which_vars] = xopt\\n\\n # Display and return the results:\\n if verbose:\\n print(\\\"Time to estimate is \\\" + str(t1 - t0) + \\\" seconds.\\\")\\n return xopt_full\",\n \"def optimize(maxiter: int = 1000,\\n tol = None,\\n save_steps: int = 1,\\n c0: float = 0.62,\\n c1: float = 0.1,\\n c2: float = 0.602,\\n c3: float = 0.101,\\n c4: float = 0):\\n _spsa_vars = [c0, c1, c2, c3, c4]\\n theta = self.vectorizer.vector\\n nb_params = len(theta)\\n use_exact_grads = 'grads' in self._method\\n \\n if save_steps:\\n theta_vec = [theta]\\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\\n \\n \\n pbar = tqdm(total=maxiter, disable=not self.progbar)\\n def callback(_):\\n pbar.clear()\\n pbar.update()\\n val = round(self.loss, 5)\\n pbar.set_description(str(val))\\n\\n if self.loss_target is not None:\\n if self.loss < self.loss_target:\\n # returning True doesn't terminate optimization\\n pbar.close()\\n raise KeyboardInterrupt\\n \\n for ii in range(maxiter):\\n \\n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\\n delta = 2 * randint(0, 2, size=nb_params) - 1\\n # plus and minus directions\\n \\n if use_exact_grads:\\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\\n else:\\n theta_plus = theta + c_spsa * delta\\n theta_minus = theta - c_spsa * delta\\n\\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\\n # derivative estimate\\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\\n # updated theta\\n theta = theta - a_spsa * g_spsa\\n \\n callback(ii)\\n \\n if tol is not None:\\n if (cost_plus + cost_minus)/2 < tol:\\n pbar.close()\\n break\\n \\n if save_steps:\\n theta_vec.append(theta)\\n cost_vec.append(cost_plus/2+cost_minus/2)\\n \\n \\n result_dict = {'hyper_parameters':_spsa_vars,\\n 'maxiter':maxiter,\\n 'theta_opt':theta,\\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\\n if save_steps:\\n result_dict['theta_history'] = theta_vec\\n result_dict['cost_history'] = cost_vec\\n self.result_dict = result_dict\\n pbar.close()\\n\\n return self.inject_res_vector_and_return_tn()\",\n \"def optimize(opt, target, n_agents, n_variables, n_iterations, lb, ub, hyperparams):\\n\\n # Creating the SearchSpace\\n space = SearchSpace(n_agents=n_agents, n_variables=n_variables,\\n n_iterations=n_iterations, lower_bound=lb, upper_bound=ub)\\n\\n # Creating the Function\\n function = Function(pointer=target)\\n\\n # Creating Optimizer\\n if opt.__name__ is not 'BH':\\n optimizer = opt(hyperparams=hyperparams)\\n else:\\n optimizer = opt()\\n\\n # Creating the optimization task\\n task = Opytimizer(space=space, optimizer=optimizer, function=function)\\n\\n return task.start(store_best_only=True)\",\n \"def estimate_motion(self, time, intensity_grid, max_u, max_v):\\n ti = np.where(time == self.times)[0][0]\\n mask_vals = np.where(self.masks[ti].ravel() == 1)\\n i_vals = self.i[ti].ravel()[mask_vals]\\n j_vals = self.j[ti].ravel()[mask_vals]\\n obj_vals = self.timesteps[ti].ravel()[mask_vals]\\n u_shifts = np.arange(-max_u, max_u + 1)\\n v_shifts = np.arange(-max_v, max_v + 1)\\n min_error = 99999999999.0\\n best_u = 0\\n best_v = 0\\n for u in u_shifts:\\n j_shift = j_vals - u\\n for v in v_shifts:\\n i_shift = i_vals - v\\n if np.all((0 <= i_shift) & (i_shift < intensity_grid.shape[0]) &\\n (0 <= j_shift) & (j_shift < intensity_grid.shape[1])):\\n shift_vals = intensity_grid[i_shift, j_shift]\\n else:\\n shift_vals = np.zeros(i_shift.shape)\\n # This isn't correlation; it is mean absolute error.\\n error = np.abs(shift_vals - obj_vals).mean()\\n if error < min_error:\\n min_error = error\\n best_u = u * self.dx\\n best_v = v * self.dx\\n # 60 seems arbitrarily high\\n # if min_error > 60:\\n # best_u = 0\\n # best_v = 0\\n self.u[ti] = best_u\\n self.v[ti] = best_v\\n return best_u, best_v, min_error\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # Again, we use the fundamental foundation built in Q2 for Q4, however here we modify our minimizer function\\n # to serve the purpose of finding the expected value\\n actionList = gameState.getLegalActions(0)\\n pacmanAgentIndex = 0\\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\\n count = util.Counter()\\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\\n def maximizer(curState, agentIndex, depth):\\n\\n ghostActions = curState.getLegalActions(agentIndex)\\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\\n weight = -99999999 # Worst case starting value to be changed in the code\\n if depth == maxDepth: # If we are at a leaf node\\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\\n # Otherwise, we progress the tree until the above condition is reached\\n if len(ghostActions) != 0:\\n for x in ghostActions:\\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth):\\n weight = weight\\n else:\\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth)\\n return weight\\n else:\\n # if there are no legal actions left then evaluate at the last known state\\n return self.evaluationFunction(curState)\\n\\n def minimizer(curState, agentIndex, depth):\\n ghostActions = curState.getLegalActions(agentIndex)\\n weight = 0 # Starting value of zero to be incremented below\\n if len(ghostActions) != 0:\\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\\n for x in ghostActions: # For each legal action in the current position\\n temp = (float(1.0) / len(ghostActions))*maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, depth+1)\\n weight = weight + temp\\n else: # Otherwise, we continue to minimize\\n for x in ghostActions: # For each legal action in the current position\\n temp = (float(1.0) / len(ghostActions))*minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\\n weight = weight + temp\\n return weight\\n else:\\n # if there are no legal actions left then evaluate at the last known state\\n return self.evaluationFunction(curState)\\n\\n # Executing the minimizer for all possible actions\\n for x in actionList:\\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\\n count[x] = minimizer(tempState,1,0)\\n # print('HELLO THERE')\\n # print(count)\\n return count.argMax()\",\n \"def custom_method(*args, **kwargs):\\n return objective_return\",\n \"def custom_method(*args, **kwargs):\\n return objective_return\",\n \"def maximum(x, y):\\r\\n # see decorator for function body\\r\",\n \"def do_optimisation(self):\\n\\n print('--> Parameters for optimisation:')\\n print('--> Using measurements : {}'.format(self.stoma_cfg.comparison_helper.optimisation_keys))\\n print('')\\n\\n x0 = self.initial_guess()\\n\\n tol, eps = 1e-4, 0.001\\n\\n print('--> Using SLSQP with tol={} and eps={}'.format(tol, eps))\\n\\n soln = opt.minimize(fun=self.optimise_fn,\\n x0=x0,\\n method='SLSQP',\\n tol=tol,\\n options={'eps': eps})\\n\\n print('*' * 120)\\n print('--> Optimisation procedure has finished...')\\n print(soln)\\n print('*' * 120)\\n\\n if soln.success:\\n print('--> Optimisation succeeded. Result is...')\\n self._set_material_parameters(soln.x)\\n print('--> {}'.format(self.material_model))\\n else:\\n print('--> The optimisation failed!')\\n\\n print('*' * 120)\\n\\n return soln\",\n \"def solve(self, topology, algorithm=\\\"SLSQP\\\", grad=\\\"AD\\\", step_size=1e-6, iters=100, eps=1e-6, kappa=1e-8, tmax=100, eta=1e-6, verbose=False):\\n if verbose:\\n print(\\\"----------\\\")\\n print(\\\"Optimization with {} started!\\\".format(algorithm))\\n print(f\\\"# Parameters: {self.number_of_parameters()}, # Constraints {self.number_of_constraints()}\\\")\\n\\n # test for bad stuff before going any further\\n self.check_optimization_sanity()\\n\\n # compose gradient and objective functions\\n if grad not in (\\\"AD\\\", \\\"FD\\\"):\\n raise ValueError(f\\\"Gradient method {grad} is not supported!\\\")\\n if grad == \\\"AD\\\":\\n if verbose:\\n print(\\\"Computing gradients using automatic differentiation!\\\")\\n x_func = partial(self._optimize_form, topology=topology.copy(), tmax=tmax, eta=eta)\\n grad_func = partial(grad_autograd, grad_func=agrad(x_func)) # x, grad, x_func\\n\\n elif grad == \\\"FD\\\":\\n if verbose:\\n print(f\\\"Warning: Calculating gradients using finite differences with step size {step_size}. This may take a while...\\\")\\n grad_func = self.gradient_func(grad_finite_differences, topology.copy(), tmax, eta, step_size)\\n\\n # grad_func = self.gradient_func(grad_func, topology.copy(), tmax, eta, step_size)\\n obj_func = self.objective_func(topology, grad_func, tmax, eta)\\n\\n # generate optimization variables\\n x = self.optimization_parameters(topology)\\n\\n # extract the lower and upper bounds to optimization variables\\n bounds_low, bounds_up = self.optimization_bounds(topology)\\n\\n # stack keyword arguments\\n hyper_parameters = {\\\"f\\\": obj_func,\\n \\\"algorithm\\\": algorithm,\\n \\\"dims\\\": self.number_of_parameters(),\\n \\\"bounds_low\\\": bounds_low,\\n \\\"bounds_up\\\": bounds_up,\\n \\\"iters\\\": iters,\\n \\\"eps\\\": eps,\\n \\\"ftol\\\": kappa}\\n\\n # assemble optimization solver\\n solver = nlopt_solver(**hyper_parameters)\\n\\n # solve optimization problem\\n x_opt = None\\n start = time()\\n try:\\n x_opt = solver.optimize(x)\\n if verbose:\\n print(\\\"Optimization ended correctly!\\\")\\n except RoundoffLimited:\\n print(\\\"Optimization was halted because roundoff errors limited progress\\\")\\n print(\\\"Results may still be useful though!\\\")\\n x_opt = self.optimization_parameters(topology)\\n except RuntimeError:\\n print(\\\"Optimization failed due to a runtime error!\\\")\\n print(f\\\"Optimization total runtime: {round(time() - start, 4)} seconds\\\")\\n return static_equilibrium(topology)\\n\\n # fetch last optimum value of loss function\\n time_opt = time() - start\\n loss_opt = solver.last_optimum_value()\\n evals = solver.get_numevals()\\n status = nlopt_status(solver.last_optimize_result())\\n\\n # set optimizer attributes\\n self.time_opt = time_opt\\n self.x_opt = x_opt\\n self.penalty = loss_opt\\n self.evals = evals\\n self.status = status\\n\\n # set norm of the gradient\\n # NOTE: np.zeros is a dummy array (signature requirement set by nlopt)\\n self.gradient = grad_func(x_opt, np.zeros(x_opt.size))\\n self.gradient_norm = np.linalg.norm(self.gradient)\\n\\n if verbose:\\n print(f\\\"Optimization total runtime: {round(time_opt, 6)} seconds\\\")\\n print(\\\"Number of evaluations incurred: {}\\\".format(evals))\\n print(f\\\"Final value of the objective function: {round(loss_opt, 6)}\\\")\\n print(f\\\"Norm of the gradient of the objective function: {round(self.gradient_norm, 6)}\\\")\\n print(f\\\"Optimization status: {status}\\\".format(status))\\n print(\\\"----------\\\")\\n\\n # exit like a champion\\n return static_equilibrium(topology)\",\n \"def max_hybrid(func: Callable[[Tuple], np.ndarray], over: Tuple[Tuple],\\\\\\n state: Tuple[Union[int, float]], cont: Tuple[bool],\\\\\\n actions: Iterable[Tuple]) -> Tuple[float, Tuple[Union[int, float]], None]:\\n best = -np.inf\\n bestarg = None\\n funcarg = lambda x: -func(np.asarray(x).reshape(1, -1))[0, 0]\\n statebounds = tuple(zip(state, state))\\n for act in actions:\\n actbounds = [b if c else (a, a) for a, c, b in zip(act, cont, over)]\\n init = tuple([*state, *np.random.uniform(*zip(*over))])\\n res = minimize(funcarg, x0=init, bounds=(*statebounds, *actbounds))\\n val = -funcarg(res.x)\\n if val > best:\\n best = val\\n bestarg = res.x\\n return (best, tuple([float(v) if c else int(v) for v, c in \\\\\\n zip(bestarg[len(state):], cont)]), None)\",\n \"def fit(self, start_params=None, method='newton', maxiter=100,\\n full_output=True, disp=True, fargs=(), callback=None, retall=False,\\n skip_hessian=False, **kwargs):\\n Hinv = None # JP error if full_output=0, Hinv not defined\\n\\n start_params = self._get_start_params(start_params)\\n\\n # TODO: separate args from nonarg taking score and hessian, ie.,\\n # user-supplied and numerically evaluated estimate frprime doesn't take\\n # args in most (any?) of the optimize function\\n\\n nobs = self.endog.shape[0]\\n # f = lambda params, *args: -self.loglike(params, *args) / nobs\\n\\n def f(params, *args):\\n return -self.loglike(params, *args) / nobs\\n\\n if method == 'newton':\\n # TODO: why are score and hess positive?\\n def score(params, *args):\\n return self.score(params, *args) / nobs\\n\\n def hess(params, *args):\\n return self.hessian(params, *args) / nobs\\n else:\\n def score(params, *args):\\n return -self.score(params, *args) / nobs\\n\\n def hess(params, *args):\\n return -self.hessian(params, *args) / nobs\\n\\n warn_convergence = kwargs.pop('warn_convergence', True)\\n optimizer = Optimizer()\\n xopt, retvals, optim_settings = optimizer._fit(f, score, start_params,\\n fargs, kwargs,\\n hessian=hess,\\n method=method,\\n disp=disp,\\n maxiter=maxiter,\\n callback=callback,\\n retall=retall,\\n full_output=full_output)\\n\\n # NOTE: this is for fit_regularized and should be generalized\\n cov_params_func = kwargs.setdefault('cov_params_func', None)\\n if cov_params_func:\\n Hinv = cov_params_func(self, xopt, retvals)\\n elif method == 'newton' and full_output:\\n Hinv = np.linalg.inv(-retvals['Hessian']) / nobs\\n # TODO: try/except for non-invertible hessian?\\n elif not skip_hessian:\\n H = -1 * self.hessian(xopt)\\n invertible = False\\n if np.all(np.isfinite(H)):\\n eigvals, eigvecs = np.linalg.eigh(H)\\n if np.min(eigvals) > 0:\\n invertible = True\\n\\n if invertible:\\n Hinv = eigvecs.dot(np.diag(1.0 / eigvals)).dot(eigvecs.T)\\n Hinv = np.asfortranarray((Hinv + Hinv.T) / 2.0)\\n else:\\n warnings.warn('Inverting hessian failed, no bse or cov_params '\\n 'available', HessianInversionWarning)\\n Hinv = None\\n\\n if 'cov_type' in kwargs:\\n cov_kwds = kwargs.get('cov_kwds', {})\\n kwds = {'cov_type': kwargs['cov_type'], 'cov_kwds': cov_kwds}\\n else:\\n kwds = {}\\n if 'use_t' in kwargs:\\n kwds['use_t'] = kwargs['use_t']\\n # TODO: add Hessian approximation and change the above if needed\\n mlefit = LikelihoodModelResults(self, xopt, Hinv, scale=1., **kwds)\\n\\n # TODO: hardcode scale?\\n if isinstance(retvals, dict):\\n mlefit.mle_retvals = retvals\\n if warn_convergence and not retvals['converged']:\\n warnings.warn(\\\"Maximum Likelihood optimization failed to \\\"\\n \\\"converge. Check mle_retvals\\\",\\n ConvergenceWarning)\\n\\n mlefit.mle_settings = optim_settings\\n return mlefit\",\n \"def optimize(\\n # trials,\\n random_state=SEED):\\n\\n space = {\\n 'max_depth': scope.int(hp.uniform('max_depth', 5, 15)),\\n 'subsample': hp.uniform('subsample', 0.03, 1),\\n 'learning_rate' : hp.loguniform('learning_rate', np.log(0.005), np.log(0.5)) - 0.0001,\\n 'colsample_bytree': hp.uniform('colsample_bytree', 0.3, 1),\\n 'reg_alpha': hp.loguniform('reg_alpha', np.log(0.005), np.log(5)) - 0.0001,\\n 'reg_lambda': hp.loguniform('reg_lambda', np.log(1), np.log(5)),\\n 'bagging_freq': hp.choice('bagging_freq', [0, 1]),\\n 'num_leaves': scope.int(hp.uniform('num_leaves', 10, 128)),\\n 'n_estimators': 1000,\\n 'boosting': 'gbdt',\\n 'objective': 'multiclass',\\n 'num_class': 12,\\n 'metric': 'None',\\n 'is_unbalance': 'true',\\n # 'min_data_per_group': 1000,\\n 'verbose': -1,\\n 'random_seed': 42,\\n \\n }\\n\\n # Use the fmin function from Hyperopt to find the best hyperparameters\\n best = fmin(score_model, space, algo=tpe.suggest,\\n # trials=trials,\\n max_evals=hyperopt_niters)\\n return best\",\n \"def _maximize(self, board, possible_actions, depth_limit, alpha, beta):\\r\\n pass\",\n \"def work(params) -> Union[None, float]:\\n try:\\n # either HTTP or bindings\\n if host:\\n path = action if action == \\\"route\\\" else \\\"sources_to_targets\\\"\\n params_str = delimit_tuple(\\n tuple((delimit_tuple(x) for x in params)), delimiter=\\\";\\\"\\n )\\n route = requests.get(f\\\"{host}/{path}/v1/driving/{params_str}\\\")\\n else:\\n route = router.route(params) if action == \\\"route\\\" else None\\n except (RuntimeError, requests.exceptions.BaseHTTPError):\\n return None\\n\\n if (\\n random() > 0.95\\n ): # assume that large number of routes will be tested, only print sample in debug mode\\n LOGGER.debug(f\\\"Calculated route between {params[0]} and {params[1]}\\\")\\n\\n if report:\\n result = route.json()\\n if action == \\\"route\\\":\\n try:\\n dist = sum([x[\\\"distance\\\"] for x in result[\\\"routes\\\"]])\\n except KeyError:\\n LOGGER.critical(\\n f\\\"No route was found from {params[0]} to {params[1]}. \\\"\\n f\\\"Try regenerating the locations or specify a more narrow bounding box.\\\"\\n )\\n return None\\n else:\\n dists = [\\n inner[\\\"distance\\\"]\\n for outer in route[\\\"sources_to_targets\\\"]\\n for inner in outer\\n ]\\n dist: float = mean(filter(lambda x: x is not None, dists))\\n\\n return dist\",\n \"def checkgrad(self, target_param = None, verbose=False, step=1e-6, tolerance = 1e-3):\\n\\n x = self._get_params_transformed().copy()\\n\\n if not verbose:\\n #just check the global ratio\\n dx = step*np.sign(np.random.uniform(-1,1,x.size))\\n\\n #evaulate around the point x\\n f1, g1 = self.objective_and_gradients(x+dx)\\n f2, g2 = self.objective_and_gradients(x-dx)\\n gradient = self.objective_function_gradients(x)\\n\\n numerical_gradient = (f1-f2)/(2*dx)\\n global_ratio = (f1-f2)/(2*np.dot(dx,gradient))\\n\\n if (np.abs(1.-global_ratio)<tolerance) and not np.isnan(global_ratio):\\n return True\\n else:\\n return False\\n else:\\n #check the gradient of each parameter individually, and do some pretty printing\\n try:\\n names = self._get_param_names_transformed()\\n except NotImplementedError:\\n names = ['Variable %i'%i for i in range(len(x))]\\n\\n # Prepare for pretty-printing\\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\\n float_len = 10\\n cols = [max_names]\\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\\n cols = np.array(cols) + 5\\n header_string = [\\\"{h:^{col}}\\\".format(h = header[i], col = cols[i]) for i in range(len(cols))]\\n header_string = map(lambda x: '|'.join(x), [header_string])\\n separator = '-'*len(header_string[0])\\n print '\\\\n'.join([header_string[0], separator])\\n\\n if target_param is None:\\n param_list = range(len(x))\\n else:\\n param_list = self.grep_param_names(target_param)\\n\\n for i in param_list:\\n xx = x.copy()\\n xx[i] += step\\n f1, g1 = self.objective_and_gradients(xx)\\n xx[i] -= 2.*step\\n f2, g2 = self.objective_and_gradients(xx)\\n gradient = self.objective_function_gradients(x)[i]\\n\\n numerical_gradient = (f1-f2)/(2*step)\\n ratio = (f1-f2)/(2*step*gradient)\\n difference = np.abs((f1-f2)/2/step - gradient)\\n\\n if (np.abs(ratio-1)<tolerance):\\n formatted_name = \\\"\\\\033[92m {0} \\\\033[0m\\\".format(names[i])\\n else:\\n formatted_name = \\\"\\\\033[91m {0} \\\\033[0m\\\".format(names[i])\\n r = '%.6f' % float(ratio)\\n d = '%.6f' % float(difference)\\n g = '%.6f' % gradient\\n ng = '%.6f' % float(numerical_gradient)\\n grad_string = \\\"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\\\".format(formatted_name,r,d,g, ng, c0 = cols[0]+9, c1 = cols[1], c2 = cols[2], c3 = cols[3], c4 = cols[4])\\n print grad_string\",\n \"def step(self, closure=None, found_inf: Tensor = None):\\n if found_inf is None:\\n return super(AdamW, self).step(closure=closure)\\n\\n if found_inf.shape:\\n raise ValueError(\\\"The found_inf tensor has to be scalar type\\\")\\n\\n loss = None\\n if closure is not None:\\n with torch.enable_grad():\\n loss = closure()\\n\\n for group in self.param_groups:\\n params_with_grad = []\\n grads = []\\n exp_avgs = []\\n exp_avg_sqs = []\\n max_exp_avg_sqs = []\\n state_steps = []\\n beta1, beta2 = group['betas']\\n\\n for p in group['params']:\\n if p.grad is not None:\\n params_with_grad.append(p)\\n if p.grad.is_sparse:\\n raise RuntimeError('AdamW does not support sparse gradients')\\n grads.append(p.grad)\\n\\n state = self.state[p]\\n\\n # Lazy state initialization\\n if not state:\\n state['step'] = torch.zeros_like(found_inf)\\n # Exponential moving average of gradient values\\n state['exp_avg'] = torch.zeros_like(\\n p, memory_format=torch.preserve_format)\\n # Exponential moving average of squared gradient values\\n state['exp_avg_sq'] = torch.zeros_like(\\n p, memory_format=torch.preserve_format)\\n # Maintains max of all exp. moving avg. of sq. grad. values\\n state['max_exp_avg_sq'] = torch.zeros_like(\\n p, memory_format=torch.preserve_format)\\n\\n exp_avgs.append(state['exp_avg'])\\n exp_avg_sqs.append(state['exp_avg_sq'])\\n max_exp_avg_sqs.append(state['max_exp_avg_sq'])\\n\\n state_steps.append(state['step'])\\n\\n F.adam_step(\\n found_inf,\\n state_steps,\\n params_with_grad,\\n grads,\\n exp_avgs,\\n exp_avg_sqs,\\n max_exp_avg_sqs,\\n amsgrad=group['amsgrad'],\\n beta1=beta1,\\n beta2=beta2,\\n lr=group['lr'],\\n weight_decay=group['weight_decay'],\\n eps=group['eps'],\\n maximize=group['maximize'],\\n use_adamw=True)\\n\\n return loss\",\n \"def maxValue(gameState, depth, a, b):\\n ultimateMove = None # The best move the agent can do\\n if gameState.isWin() or gameState.isLose(): # if terminal node return gamescore\\n return self.evaluationFunction(gameState)\\n bestValue = -math.inf\\n # for all of max agents moves\\n for action in gameState.getLegalActions(0):\\n value = minValue(gameState.generateSuccessor(\\n 0, action), depth, 1, a, b) # save value from call to minimizing agent\\n if value > bestValue: # if value has increased, update parametres\\n bestValue = value\\n ultimateMove = action\\n a = max(a, bestValue) # updates a=alpha if bestvalue > alpha\\n if bestValue > b: # if value is greater than connected branch, do prune\\n return bestValue\\n if depth == self.depth: # if top node, return the best move\\n return ultimateMove\\n else:\\n # if not top node (and no pruning) return best value\\n return bestValue\",\n \"def run_agent(self):\\n '''\\n The child class is created in order to override the value method which will take into account\\n previous states of the agent. The reward function is made exponential rather than linear, which\\n decreases the probability of agent visiting the state which was already visited.\\n '''\\n\\n class GraphProblemSpecialised(GraphProblem):\\n def __init__(self, initial, goal, graph, reward_dict, already_visited_reward):\\n GraphProblem.__init__(self, initial, goal, graph)\\n self.rewards = reward_dict\\n self.already_visited_reward = already_visited_reward\\n\\n def value(self, state, history):\\n if state in history.keys():\\n return self.rewards[state] - (self.already_visited_reward ** history[state])\\n return self.rewards[state]\\n\\n # -- Load and init mission --#\\n print('Generate and load the ' + self.mission_type + ' mission with seed ' + str(\\n self.mission_seed) + ' allowing ' + self.AGENT_MOVEMENT_TYPE + ' movements')\\n mission_xml = init_mission(self.agent_host, self.agent_port, self.AGENT_NAME, self.mission_type,\\n self.mission_seed, self.AGENT_MOVEMENT_TYPE)\\n self.solution_report.setMissionXML(mission_xml)\\n self.solution_report.start()\\n\\n # -- Get the state of the world along with internal state... --#\\n state_t = self.agent_host.getWorldState()\\n\\n # -- Main loop: --#\\n while state_t.is_mission_running:\\n state_t = self.agent_host.getWorldState()\\n\\n # -- Check if anything went wrong along the way --#\\n for error in state_t.errors:\\n print(\\\"Error:\\\", error.text)\\n\\n # -- Oracle and Internal Sensors--#\\n if state_t.number_of_observations_since_last_state > 0: # Has any Oracle-like and/or internal sensor observations come in?\\n msg = state_t.observations[-1].text # Get the details for the last observed state\\n oracle_and_internal = json.loads(msg) # Parse the Oracle JSON\\n # print oracle_and_internal\\n # -- Oracle sensor --#\\n grid = oracle_and_internal.get(u'grid', 0) # Demo only, string with the\\n # -- GPS-like sensor --#\\n xpos = oracle_and_internal.get(u'XPos', 0) # Demo only, position in 2D plane, 1st axis\\n zpos = oracle_and_internal.get(u'ZPos', 0) # Demo only, position in 2D plane, 2nd axis (yes Z!)\\n ypos = oracle_and_internal.get(u'YPos', 0) # Demo only, height as measured from surface! (yes Y!)\\n\\n current_location_id = self._get_current_location_id((xpos, zpos))\\n\\n if self.history.get(current_location_id):\\n self.history[current_location_id] += 1\\n else:\\n self.history[current_location_id] = 1\\n\\n if self.first_time_flag:\\n start_location = current_location_id\\n\\n # Gets the possible actions and checks for goal block\\n state_space_actions, state_space_locations, reached_goal = self._get_local_state_space_actions(grid,\\n [xpos,\\n zpos])\\n\\n if reached_goal:\\n break\\n\\n self.rewards_by_location_id, self.previous_rewards_total = self._get_rewards(\\n self.rewards_by_location_id,\\n state_space_actions,\\n state_space_locations,\\n oracle_and_internal,\\n self.previous_rewards_total)\\n\\n # Creates a graph for local (neighbourhood) actions\\n local_map = UndirectedGraph(state_space_actions)\\n local_problem = GraphProblemSpecialised(initial=start_location, goal=None, graph=local_map,\\n reward_dict=self.rewards_by_location_id,\\n already_visited_reward=self.already_visited_reward)\\n # Looks for most optimal next step\\n next_step = self.hill_climbing(local_problem, self.history)\\n\\n # If the next step is already in history the reward will be exponentially increased (but is negated)\\n if next_step in self.history.keys():\\n print \\\"You already visited that so will be punished!\\\"\\n self.rewards_by_location_id[next_step] -= self.already_visited_reward ** self.history[next_step]\\n self.history[next_step] += 1\\n\\n next_x, next_z = state_space_locations[next_step]\\n self.agent_host.sendCommand(\\\"tp \\\" + str(next_x) + \\\" \\\" + str(217) + \\\" \\\" + str(next_z))\\n time.sleep(0.1)\\n\\n # -- Collect the number of rewards and add to reward_cumulative --#\\n # -- Note: Since we only observe the sensors and environment every a number of rewards may have accumulated in the buffer --#\\n for reward_t in state_t.rewards:\\n print(\\\"Reward_t:\\\", reward_t.getValue())\\n self.solution_report.addReward(reward_t.getValue(), datetime.datetime.now())\\n\\n # -- Check if anything went wrong along the way --#\\n for error in state_t.errors:\\n print(\\\"Error:\\\", error.text)\\n\\n print(\\\"Mission has ended.either because time has passed or you reached the goal.\\\")\\n return\",\n \"def instability_bf(funcs, step = 10, maximum = 300, guess = 0, tolerance=0.01):\\n if guess < maximum:\\n s = 1 # to increase\\n else:\\n s = -1 # to decrease\\n step = s*abs(step) # correct step\\n # offset to ensure that data moves to maximum even if actual data is stable\\n offset = [f(maximum) for f in funcs]\\n val_prev = np.array([f(guess-step) for f in funcs]+offset) # first y values with offset\\n acc = 0 # accumulator to interchange when to add offset and when not\\n while s*(maximum-guess)>0: # check approximation to maximum\\n val = [f(guess) for f in funcs] # get y values\\n if acc%2: # interchange\\n val = np.array(val+offset) # values with offset\\n else:\\n val = np.array(val+val) # just values\\n # np.repeat(np.mean(val),val.size)\\n # check minimization\\n if np.allclose(val, val_prev, tolerance, tolerance): # it means instability\\n return True, guess # success!\\n guess += step # updata step\\n acc += 1 # update accumulator\\n val_prev = val # update previous data\\n return False, guess # not found or limit reached\",\n \"def optimize_svr(data, targets):\\r\\n def svc_crossval(C,epsilon,loss_n):\\r\\n\\r\\n return svc_cv(C=C, epsilon=epsilon,loss_n=loss_n, data=data, targets=targets)\\r\\n\\r\\n optimizer = BayesianOptimization(\\r\\n f=svc_crossval,\\r\\n pbounds={\\\"C\\\": (0.0001, 1000), \\\"epsilon\\\": (0, 0.2),'loss_n':(0,1)},\\r\\n random_state=1234,\\r\\n verbose=2\\r\\n )\\r\\n logger=JSONLogger(path=\\\"./linsvrlogs.json\\\")\\r\\n optimizer.subscribe(Events.OPTMIZATION_STEP,logger)\\r\\n optimizer.maximize(init_points=50,n_iter=300)\\r\\n with open('./linsvrlogs.json','a',encoding='utf-8')as f:\\r\\n f.write(str(optimizer.max))\",\n \"def MidpointFnBuilder(max_speed = 26.8, gain = 0.1, beta = 0.5, duration = 500, bias = 1.0, ratio = 0.5):\\n\\n def MidpointFn((idx, car), sim, step):\\n \\\"\\\"\\\"\\n :param idx:\\n :param car:\\n :param sim:\\n :param step:\\n :return:\\n \\\"\\\"\\\"\\n vehID = car[\\\"id\\\"]\\n\\n try:\\n [back_car, front_car] = sim.getCars(idx, numBack=1, numForward=1, lane=car[\\\"lane\\\"])\\n except ValueError:\\n # Not enough cars on lane\\n return\\n\\n front_dist = (front_car[\\\"x\\\"] - car[\\\"x\\\"]) % sim.length\\n back_dist = (car[\\\"x\\\"] - back_car[\\\"x\\\"]) % sim.length\\n\\n curr_speed = car[\\\"v\\\"]\\n front_speed = front_car[\\\"v\\\"]\\n follow_dist = (front_dist + back_dist) * ratio\\n delta = front_dist - follow_dist\\n # print delta, curr_speed, front_speed, curr_speed-front_speed\\n if follow_dist < front_dist and curr_speed < max_speed:\\n # speed up\\n new_speed = min(curr_speed + beta * (front_speed-curr_speed) + gain * delta + bias, max_speed)\\n traci.vehicle.slowDown(vehID, new_speed, duration) # 2.5 sec\\n # print \\\"t=%d, FASTER, %0.1f -> %0.1f (%0.1f) | d=%0.2f = %0.2f vs %0.2f\\\" % \\\\\\n # (step, curr_speed, new_speed, front_speed, delta, front_dist, follow_dist)\\n elif follow_dist > front_dist:\\n # slow down\\n new_speed = max(curr_speed + beta * (front_speed-curr_speed) + gain * delta + bias, 0)\\n traci.vehicle.slowDown(vehID, new_speed, duration) # 2.5 sec\\n # print \\\"t=%d, SLOWER, %0.1f -> %0.1f (%0.1f) | d=%0.2f = %0.2f vs %0.2f\\\" % \\\\\\n # (step, curr_speed, new_speed, front_speed, delta, front_dist, follow_dist)\\n\\n return MidpointFn\",\n \"def _fit_amoeba(self, kwargs, verbose):\\n\\n args_init = self._param_class.kwargs_to_args(kwargs)\\n\\n options = {\\n \\\"adaptive\\\": True,\\n \\\"fatol\\\": self._tol_simplex_func,\\n \\\"maxiter\\\": self._simplex_n_iterations * len(args_init),\\n }\\n\\n method = \\\"Nelder-Mead\\\"\\n\\n if verbose:\\n print(\\\"starting amoeba... \\\")\\n\\n opt = minimize(\\n self.fast_rayshooting.chi_square,\\n x0=args_init,\\n method=method,\\n options=options,\\n )\\n\\n kwargs = self._param_class.args_to_kwargs(opt[\\\"x\\\"])\\n source_penalty = opt[\\\"fun\\\"]\\n\\n return kwargs, source_penalty\",\n \"def minimize(fun, \\n bounds = None, \\n value_limit = math.inf,\\n num_retries = 1000,\\n logger = None,\\n workers = mp.cpu_count(),\\n popsize = 31, \\n max_evaluations = 50000, \\n capacity = 500,\\n stop_fittness = None,\\n optimizer = None,\\n ):\\n\\n if optimizer is None:\\n optimizer = de_cma(max_evaluations, popsize, stop_fittness) \\n store = Store(bounds, capacity = capacity, logger = logger)\\n return retry(fun, store, optimizer.minimize, num_retries, value_limit, workers)\",\n \"def motion_correct(mov, max_iters=5, shift_threshold=1., reslice=slice(None,None), in_place=True, verbose=True, compute_kwargs={}, apply_kwargs={}):\\n if not in_place:\\n mov = mov.copy()\\n mov = mov[reslice]\\n \\n all_vals = []\\n for it in range(max_iters):\\n if verbose:\\n print('Iteration {}'.format(it)); sys.stdout.flush()\\n template,vals = compute_motion(mov, **compute_kwargs)\\n mov = apply_motion_correction(mov, vals, **apply_kwargs)\\n maxshifts = np.abs(vals[:,[0,1]]).max(axis=0)\\n all_vals.append(vals)\\n if verbose:\\n print('Shifts: {}'.format(str(maxshifts))); sys.stdout.flush()\\n if np.all(maxshifts < shift_threshold):\\n break\\n\\n # combine values from iterations\\n all_vals = np.array(all_vals)\\n return_vals = np.empty([all_vals.shape[1],all_vals.shape[2]])\\n return_vals[:,[0,1]] = all_vals[:,:,[0,1]].sum(axis=0)\\n return_vals[:,2] = all_vals[-1,:,2]\\n\\n return mov,template,return_vals\",\n \"def optimize(self, num_restarts=1, max_iters=100, max_f_eval=300.0, method='Anneal'):\\n dic = DictVectorizer()\\n # flatten the parameters\\n init_params,bounds=dic.fit_transform(self.params)\\n #we minimise minus the marginal likelihood\\n def objective(params_flatten):\\n self.params=dic.inverse_transform(params_flatten,bounds)\\n val = -self.log_marginal_likelihood()\\n return val# we want to maximize it\\n \\n \\n #run ptimisation with multiple restarts\\n optml=np.inf\\n for i in range(num_restarts):\\n #minimise function\\n if method=='Anneal':\\n res=dual_annealing(objective,bounds, maxiter=max_iters, maxfun=max_f_eval, x0=init_params)\\n else:\\n \\n res = minimize(objective, init_params, \\n bounds=bounds, method=method,options={'maxiter': max_iters, 'disp': False})\\n #print(\\\"Iteration \\\"+str(i)+\\\" \\\",-res.fun)\\n if res.fun<optml:\\n params_best=res.x #init_params \\n optml=res.fun\\n init_params=bounds[:,0]+(bounds[:,1]-bounds[:,0])*np.random.rand(len(bounds[:,0]))\\n print(\\\"Iteration \\\"+str(i)+\\\" \\\",-res.fun)\\n #params_best=res.x\\n #optml=res.fun\\n self.params=dic.inverse_transform(params_best,bounds)\\n return -optml\",\n \"def optimize(self): \\n if self.model == 'ARD':\\n estimate = minimize(\\n fun=optim_func,\\n x0=np.array([self.alpha, self.beta]),\\n args=(self,),\\n method='L-BFGS-B',\\n bounds=((0, 50), (0, 50)),\\n )\\n # logger.info(estimate)\\n\\n # organize into a dict\\n result = {\\n \\\"alpha\\\": estimate.x[0],\\n \\\"beta\\\": estimate.x[1],\\n \\\"Lik\\\": estimate.fun,\\n \\\"negLogLik\\\": -np.log(-estimate.fun),\\n \\\"convergence\\\": estimate.success,\\n }\\n logger.debug(result)\\n\\n elif self.model == 'ER':\\n estimate = minimize(\\n fun=optim_func,\\n x0=np.array([self.alpha]),\\n args=(self,),\\n method='L-BFGS-B',\\n bounds=[(0, 50)],\\n )\\n\\n result = {\\n \\\"alpha\\\": estimate.x[0],\\n \\\"Lik\\\": estimate.fun, \\n \\\"negLogLik\\\": -np.log(-estimate.fun),\\n \\\"convergence\\\": estimate.success,\\n }\\n logger.debug(result)\\n\\n else:\\n raise Exception('model must be specified as either ARD or ER')\\n\\n # get scaled likelihood values\\n self.log_lik = result[\\\"negLogLik\\\"]\\n self.tree = self.tree.set_node_values(\\n 'likelihood',\\n values={\\n node.idx: np.array(node.likelihood) / sum(node.likelihood)\\n for node in self.tree.idx_dict.values()\\n }\\n )\",\n \"def hyperopt_fmin(\\n fn,\\n space,\\n algo,\\n max_evals=sys.maxsize,\\n timeout=None,\\n loss_threshold=None,\\n trials=None,\\n rstate=None,\\n allow_trials_fmin=True,\\n pass_expr_memo_ctrl=None,\\n catch_eval_exceptions=False,\\n verbose=True,\\n return_argmin=True,\\n points_to_evaluate=None,\\n max_queue_len=1,\\n show_progressbar=True,\\n # early_stop_fn=None,\\n):\\n if rstate is None:\\n env_rseed = os.environ.get(\\\"HYPEROPT_FMIN_SEED\\\", \\\"\\\")\\n if env_rseed:\\n rstate = np.random.RandomState(int(env_rseed))\\n else:\\n rstate = np.random.RandomState()\\n\\n validate_timeout(timeout)\\n validate_loss_threshold(loss_threshold)\\n\\n if allow_trials_fmin and hasattr(trials, \\\"fmin\\\"):\\n assert False\\n # return trials.fmin(\\n # fn,\\n # space,\\n # algo=algo,\\n # max_evals=max_evals,\\n # timeout=timeout,\\n # loss_threshold=loss_threshold,\\n # max_queue_len=max_queue_len,\\n # rstate=rstate,\\n # pass_expr_memo_ctrl=pass_expr_memo_ctrl,\\n # verbose=verbose,\\n # catch_eval_exceptions=catch_eval_exceptions,\\n # return_argmin=return_argmin,\\n # show_progressbar=show_progressbar,\\n # early_stop_fn=early_stop_fn,\\n # )\\n\\n if trials is None:\\n if points_to_evaluate is None:\\n trials = base.Trials()\\n else:\\n assert type(points_to_evaluate) == list\\n trials = generate_trials_to_calculate(points_to_evaluate)\\n\\n domain = base.Domain(fn, space, pass_expr_memo_ctrl=pass_expr_memo_ctrl)\\n\\n rval = FMinIter(\\n algo,\\n domain,\\n trials,\\n max_evals=max_evals,\\n timeout=timeout,\\n loss_threshold=loss_threshold,\\n rstate=rstate,\\n verbose=verbose,\\n max_queue_len=max_queue_len,\\n show_progressbar=show_progressbar,\\n # early_stop_fn=early_stop_fn,\\n )\\n rval.catch_eval_exceptions = catch_eval_exceptions\\n\\n # next line is where the fmin is actually executed\\n rval.exhaust()\\n\\n if len(trials.trials) == 0:\\n raise Exception(\\n \\\"There are no evaluation tasks, cannot return argmin of task losses.\\\"\\n )\\n return trials\",\n \"def _generic_minimize(method, loss, x0,\\n verbose=False,\\n num_iters=1000,\\n tol=1e-4,\\n state=None,\\n full_output=False,\\n suppress_warnings=False,\\n **kwargs):\\n # Flatten the loss\\n _x0, unflatten = flatten(x0)\\n _objective = lambda x_flat, itr: loss(unflatten(x_flat), itr)\\n\\n if verbose:\\n print(\\\"Fitting with {}.\\\".format(method))\\n\\n # Specify callback for fitting\\n itr = [0]\\n def callback(x_flat):\\n itr[0] += 1\\n print(\\\"Iteration {} loss: {:.3f}\\\".format(itr[0], loss(unflatten(x_flat), -1)))\\n\\n # Wrap the gradient to avoid NaNs\\n def safe_grad(x, itr):\\n g = grad(_objective)(x, itr)\\n g[~np.isfinite(g)] = 1e8\\n return g\\n\\n # Call the optimizer. Pass in -1 as the iteration since it is unused.\\n result = minimize(_objective, _x0, args=(-1,),\\n jac=safe_grad,\\n method=method,\\n callback=callback if verbose else None,\\n options=dict(maxiter=num_iters, disp=verbose),\\n tol=tol,\\n **kwargs)\\n if verbose:\\n print(\\\"{} completed with message: \\\\n{}\\\".format(method, result.message))\\n\\n if not suppress_warnings and not result.success:\\n warn(\\\"{} failed with message:\\\\n{}\\\".format(method, result.message))\\n\\n if full_output:\\n return unflatten(result.x), result\\n else:\\n return unflatten(result.x)\",\n \"def downhill(F, xStart, args=None, side=0.1, ftol=1.0e-6, xtol=1.0e-6, maxiter=1000, maxfunc=1000, maxiternochange=10):\\n # TODO: check the types of the input ???\\n\\n # print \\\"Entering downhill\\\"\\n n = len(xStart)\\n x = np.zeros((n+1, n), dtype=float) #point null matrix, n+1 rows, n columns\\n f = np.zeros(n+1, dtype=float) # null vector, n+1 columns\\n p_count = 0 # counter for detecting a plateau\\n f_count = 0 # counter for the number of function call\\n f_best_count = 0 # counter for the number of iterations in which the best solution does not change\\n f_best_prev = 0.0 # holds the best value from the previous iteration\\n epsilon = 0.001 # tolerance for considering two values as equal\\n # max_iter_no_change = 10 # maximum number of accepted iterations with no change in the optimal solution\\n precision = 2\\n round_map = partial(round, ndigits=precision) # partial function for rounding purposes\\n\\n # initial simplex\\n x[0] = xStart\\n for i in xrange(1, n+1):\\n x[i] = xStart\\n x[i,i-1] = xStart[i-1] + side\\n\\n # print \\\"Evaluate the starting points\\\"\\n # compute the value of F at the vertices of the simplex\\n for i in xrange(n+1):\\n f[i] = F(x[i], args)\\n # p_count += 1\\n\\n # main loop\\n # print \\\"Start iterating\\\"\\n for k in xrange(maxiter):\\n\\n # check the number of function calls\\n if f_count > maxfunc:\\n print \\\"Stopping criteria: maximum number of function calls\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXFUNCALL'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXFUNCALL'}\\n\\n # find the best and worst vertex (consider a minimization problem)\\n iLo = np.argmin(f) # best vertex\\n iHi = np.argmax(f) # worst vertex\\n\\n # print k,\\\" \\\", f[iLo]\\n #\\n # if f[iLo] < -0.310000:\\n # print f[iLo]\\n # print x[iLo]\\n # print x\\n # sys.exit(1)\\n # print \\\"k: \\\", k, \\\" f_best_prev: \\\", f_best_prev, \\\" f[iLo]: \\\", f[iLo], \\\" f_best_count: \\\", f_best_count\\n # print \\\"Beginning of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\\\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\\n # print \\\"x: \\\", x, \\\" f: \\\", f\\n # print \\\"=========================================================================================\\\"\\n # check if the solution has changed from the previous iterations\\n if f[iLo] < f_best_prev:\\n f_best_prev = f[iLo]\\n f_best_count = 0\\n else:\\n f_best_count += 1\\n\\n if f_best_count > maxiternochange:\\n print \\\"Stopping criteria: maximum number of iterations with no improvement in the best solution\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'NOIMPROVEMENT'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'NOIMPROVEMENT'}\\n\\n if abs(f[iLo] - f[iHi]) < ftol: # If difference between highest and lowest is smaller than ftol, return\\n print \\\"Stopping criteria: difference between highest and lowest points is smaller than tolerance\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXTOLERANCE'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXTOLERANCE'}\\n # compute the move vector d\\n d = (-(n+1) * x[iHi] + np.sum(x, axis=0)) / n\\n # print \\\"d: \\\", d\\n\\n # check for convergence\\n if sqrt(np.dot(d, d)/n) < xtol: # length of the vector d\\n print \\\"Stopping criteria: length of step d smaller than tolerance\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'SMALLSTEP'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'SMALLSTEP'}\\n # try reflection\\n xNew = np.array(map(round_map, x[iHi] + 2 * d))\\n fNew = F(xNew, args)\\n f_count += 1\\n # print \\\"Reflected point: \\\", xNew, \\\" value: \\\", fNew\\n\\n # check for no improvement over the worst point\\n # and for plateau condition\\n if f[iHi] - epsilon <= fNew <= f[iHi] + epsilon:\\n p_count += 1\\n # print \\\"No improvement here\\\"\\n\\n if p_count == n+2: # we reflected all vertices with no improvement\\n print \\\"Stopping criteria: Probably we landed on a plateau... exiting\\\" # TODO: restart instead of exiting\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'PLATEAU'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'PLATEAU'}\\n\\n\\n else:\\n p_count = 0\\n\\n\\n if fNew <= f[iLo]: # if the new value is better than the best so far,\\n x[iHi] = xNew # substitute the worst vertex with the new one\\n f[iHi] = fNew\\n\\n # try to expand the reflection\\n xNew = np.array(map(round_map, x[iHi] + d))\\n fNew = F(xNew, args)\\n f_count += 1\\n # print \\\"Expanded point: \\\", xNew, \\\" value: \\\", fNew\\n\\n if fNew <= f[iHi]: # in the original source version it is f[iLo] (?)\\n x[iHi] = xNew\\n f[iHi] = fNew\\n else:\\n # try reflection again\\n if fNew <= f[iHi]:\\n x[iHi] = xNew\\n f[iHi] = fNew\\n else:\\n # try contraction\\n xNew = np.array(map(round_map, x[iHi] + 0.5 * d))\\n fNew = F(xNew, args)\\n f_count += 1\\n # print \\\"Contracted point: \\\", xNew, \\\" value: \\\", fNew\\n\\n if fNew <= f[iHi]: # accept contraction\\n x[iHi] = xNew\\n f[iHi] = fNew\\n else:\\n # shrink\\n for i in xrange(len(x)):\\n if i != iLo:\\n x[i] = np.array(map(round_map, x[i] - x[iLo] * 0.5))\\n f[i] = F(x[i], args)\\n f_count += 1\\n\\n # print \\\"End of iteration: %4d | Best x: %4f %4f %4f | Best value: %f\\\" % (k, x[iLo][0], x[iLo][1], x[iLo][2], f[iLo])\\n # print \\\"x: \\\", x, \\\" f: \\\", f\\n # print \\\"*\\\"*50\\n # print \\\"\\\"\\n\\n\\n\\n print \\\"Stopping criteria: maximum number of iterations\\\"\\n print \\\"Best solution so far: \\\", x[iLo], \\\" value: \\\", f[iLo], \\\" at iteration:\\\", k\\n # return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': (args['Q1'], args['Q2'], args['Q3']), 'stopping': 'MAXITERATION'}\\n return {'point' : x[iLo], 'value': f[iLo], 'iteration': k, 'funcalls': f_count, 'allocation': [args['Q{}'.format(h)] for h in xrange(1, args['retailers']+1)], 'stopping': 'MAXITERATION'}\",\n \"def checkgrad(self, target_param=None, verbose=False, step=1e-6, tolerance=1e-3):\\r\\n\\r\\n x = self._get_params_transformed().copy()\\r\\n\\r\\n if not verbose:\\r\\n # just check the global ratio\\r\\n\\r\\n #choose a random direction to find the linear approximation in\\r\\n if x.size==2:\\r\\n dx = step * np.ones(2) # random direction for 2 parameters can fail dure to symmetry\\r\\n else:\\r\\n dx = step * np.sign(np.random.uniform(-1, 1, x.size))\\r\\n\\r\\n # evaulate around the point x\\r\\n f1, g1 = self.objective_and_gradients(x + dx)\\r\\n f2, g2 = self.objective_and_gradients(x - dx)\\r\\n gradient = self.objective_function_gradients(x)\\r\\n\\r\\n numerical_gradient = (f1 - f2) / (2 * dx)\\r\\n global_ratio = (f1 - f2) / (2 * np.dot(dx, np.where(gradient==0, 1e-32, gradient)))\\r\\n\\r\\n return (np.abs(1. - global_ratio) < tolerance) or (np.abs(gradient - numerical_gradient).mean() < tolerance)\\r\\n else:\\r\\n # check the gradient of each parameter individually, and do some pretty printing\\r\\n try:\\r\\n names = self._get_param_names_transformed()\\r\\n except NotImplementedError:\\r\\n names = ['Variable %i' % i for i in range(len(x))]\\r\\n\\r\\n # Prepare for pretty-printing\\r\\n header = ['Name', 'Ratio', 'Difference', 'Analytical', 'Numerical']\\r\\n max_names = max([len(names[i]) for i in range(len(names))] + [len(header[0])])\\r\\n float_len = 10\\r\\n cols = [max_names]\\r\\n cols.extend([max(float_len, len(header[i])) for i in range(1, len(header))])\\r\\n cols = np.array(cols) + 5\\r\\n header_string = [\\\"{h:^{col}}\\\".format(h=header[i], col=cols[i]) for i in range(len(cols))]\\r\\n header_string = map(lambda x: '|'.join(x), [header_string])\\r\\n separator = '-' * len(header_string[0])\\r\\n print '\\\\n'.join([header_string[0], separator])\\r\\n\\r\\n if target_param is None:\\r\\n param_list = range(len(x))\\r\\n else:\\r\\n param_list = self.grep_param_names(target_param, transformed=True, search=True)\\r\\n if not np.any(param_list):\\r\\n print \\\"No free parameters to check\\\"\\r\\n return\\r\\n\\r\\n\\r\\n for i in param_list:\\r\\n xx = x.copy()\\r\\n xx[i] += step\\r\\n f1, g1 = self.objective_and_gradients(xx)\\r\\n xx[i] -= 2.*step\\r\\n f2, g2 = self.objective_and_gradients(xx)\\r\\n gradient = self.objective_function_gradients(x)[i]\\r\\n\\r\\n numerical_gradient = (f1 - f2) / (2 * step)\\r\\n ratio = (f1 - f2) / (2 * step * np.where(gradient==0, 1e-312, gradient))\\r\\n difference = np.abs((f1 - f2) / 2 / step - gradient)\\r\\n\\r\\n if (np.abs(1. - ratio) < tolerance) or np.abs(difference) < tolerance:\\r\\n formatted_name = \\\"\\\\033[92m {0} \\\\033[0m\\\".format(names[i])\\r\\n else:\\r\\n formatted_name = \\\"\\\\033[91m {0} \\\\033[0m\\\".format(names[i])\\r\\n r = '%.6f' % float(ratio)\\r\\n d = '%.6f' % float(difference)\\r\\n g = '%.6f' % gradient\\r\\n ng = '%.6f' % float(numerical_gradient)\\r\\n grad_string = \\\"{0:^{c0}}|{1:^{c1}}|{2:^{c2}}|{3:^{c3}}|{4:^{c4}}\\\".format(formatted_name, r, d, g, ng, c0=cols[0] + 9, c1=cols[1], c2=cols[2], c3=cols[3], c4=cols[4])\\r\\n print grad_string\",\n \"def _autolag(mod, endog, exog, startlag, maxlag, method, modargs=(),\\n fitargs=(), regresults=True):\\n if not regresults: # pragma: no cover\\n # TODO: update docstring\\n raise NotImplementedError(\\\"option `regresults=False` not ported \\\"\\n \\\"from upstream. _autolag always returns \\\"\\n \\\"a tuple (icbest, bestlag, results)\\\")\\n\\n # TODO: can tcol be replaced by maxlag + 2?\\n # TODO: This could be changed to laggedRHS and exog keyword arguments if\\n # this will be more general.\\n\\n results = {}\\n method = method.lower()\\n for lag in range(startlag, startlag + maxlag + 1):\\n mod_instance = mod(endog, exog[:, :lag], *modargs)\\n results[lag] = mod_instance.fit()\\n\\n if method == \\\"aic\\\":\\n icbest, bestlag = min((v.aic, k) for k, v in results.items())\\n elif method == \\\"bic\\\":\\n icbest, bestlag = min((v.bic, k) for k, v in results.items())\\n elif method == \\\"t-stat\\\":\\n # stop = stats.norm.ppf(.95)\\n stop = 1.6448536269514722\\n for lag in range(startlag + maxlag, startlag - 1, -1):\\n icbest = np.abs(results[lag].tvalues[-1])\\n if np.abs(icbest) >= stop:\\n bestlag = lag\\n icbest = icbest\\n break\\n else: # pragma: no cover\\n raise ValueError(\\\"Information Criterion %s not understood.\\\" % method)\\n\\n return icbest, bestlag, results\",\n \"def optimiseOne(paramOption, row, extractdata, start, stop, step):\\n stockname = row[0]\\n exclAttribs = row[1]\\n bestNu = row[2]\\n\\n tryParam = start\\n bestParam = tryParam\\n (trialError, trialCorrelation, trailAttrCsv) = common.lsCalcModel(\\n stockname, exclAttribs, common.cv, extractdata, bestNu, \\\"{0} {1}\\\".format(paramOption, tryParam))\\n\\n print \\\"Starting correlation={0}, with param={1}\\\".format(trialCorrelation, bestParam)\\n bestCorrelation = trialCorrelation\\n\\n tryParam = start + step\\n while tryParam < stop:\\n print \\\"Trial {0}={1}\\\".format(paramOption, tryParam)\\n (trialError, trialCorrelation, trailAttrCsv) = common.lsCalcModel(\\n stockname, exclAttribs, common.cv, extractdata, tryParam)\\n print \\\"Result: correlation={0} for trial Nu={1} with current bestCorrelation={2}\\\".\\\\\\n format(trialCorrelation, tryParam, bestCorrelation)\\n if trialCorrelation >= bestCorrelation:\\n bestCorrelation = trialCorrelation\\n bestParam = tryParam\\n print \\\"Found better or same correlation=\\\" + str(bestCorrelation) + \\\" with Nu={0}\\\".format(bestParam)\\n else:\\n print \\\"Not better. Best parameter value = {0} with correlation={1}\\\".format(bestParam, bestCorrelation)\\n break\\n\\n tryParam = tryParam + step\\n\\n return (bestParam, bestCorrelation)\",\n \"def tune_parameters(self, parameters, search_alg, num_trials=5, metric=\\\"f1\\\", direction=\\\"maximize\\\", train_ratio=0.7, num_times=1, export_metrics=True):\\n self._clear_cache()\\n model_id = self.model_id\\n if self.comet_key != None:\\n exp = init_experiment(self.comet_key, \\\"model-performance\\\", \\\"covid-vaccine\\\")\\n exp.log_parameters({\\n \\\"model_id\\\":model_id,\\n \\\"model_type\\\":self.embedding_type,\\n \\\"multiclass\\\":self.class_label,\\n \\\"train_ratio\\\":train_ratio,\\n \\\"num_samples\\\":num_trials,\\n \\\"metric\\\":metric,\\n \\\"direction\\\":direction,\\n \\\"search_alg\\\":search_alg\\n })\\n log_fixed_params(parameters, exp)\\n exp.add_tag(\\\"multi\\\" if self.class_label == \\\"Multiclass\\\" else \\\"binary\\\")\\n start = time.time()\\n tr_text, tr_label, self.tr_meta, te_text, te_label, self.te_meta, _ = get_train_test_data(self.seed_fp, self.label_fp, train_ratio=train_ratio, meta_cols=self.meta_cols, drop_irrelevant=self.drop_irrelevant, visualize=False, verbose=self.verbose)\\n self._transform_labels(tr_label, te_label)\\n print(\\\"data loading:\\\", time.time() - start, \\\"seconds\\\\n\\\")\\n start = time.time()\\n self._prepare_feature_components(tr_text, te_text, parameters)\\n print(\\\"total preprocessing:\\\", time.time() - start, \\\"seconds\\\\n\\\")\\n metric_df_parts = []\\n def objective(trial):\\n config = suggest_config(parameters, trial)\\n instances = []\\n for _ in range(num_times):\\n instance_df = self._run_single_config(train_ratio, config)\\n instance_df = instance_df[instance_df[\\\"part\\\"] == \\\"test\\\"]\\n instances.append(instance_df)\\n tmp_df = pd.concat(instances, axis=0)\\n print(\\\"metrics 1\\\", tmp_df.shape)\\n group_cols = list(tmp_df.drop(\\\"score\\\", axis=1).columns)\\n print(group_cols)\\n tmp_df = tmp_df.groupby(group_cols)[\\\"score\\\"].agg([\\\"mean\\\",\\\"std\\\"]).reset_index()\\n print(\\\"metrics 2\\\", tmp_df.shape)\\n metric_df_parts.append(tmp_df)\\n metrics = dict(zip(tmp_df[\\\"metric\\\"],tmp_df[\\\"mean\\\"]))\\n return metrics[metric]\\n if search_alg == \\\"GRID\\\":\\n algo = GridSampler(extract_grid(parameters))\\n elif search_alg == \\\"RND\\\":\\n algo = RandomSampler()\\n elif search_alg == \\\"TPE\\\":\\n algo = TPESampler(n_startup_trials=int(num_trials*0.3))\\n else:#default optuna setting\\n algo = None\\n study = optuna.create_study(direction=\\\"maximize\\\", sampler=algo)\\n study.optimize(objective, n_trials=num_trials, n_jobs=1)\\n metrics_df = pd.concat(metric_df_parts)\\n best_config = study.best_params\\n print(\\\"Best config: \\\", best_config)\\n if export_metrics:\\n result_dir = os.path.join(self.model_dir, \\\"results\\\")\\n if not os.path.exists(result_dir):\\n os.makedirs(result_dir)\\n study_fp = os.path.join(result_dir, \\\"%s.pkl\\\" % model_id)\\n print(\\\"Study file:\\\", study_fp)\\n joblib.dump(study, study_fp)\\n result_fp = os.path.join(result_dir, \\\"%s.csv\\\" % model_id)\\n print(\\\"Output file:\\\", result_fp)\\n metrics_df.to_csv(result_fp, index=False)\\n if self.comet_key != None:\\n exp.log_parameters(best_config)\\n exp.log_metrics({\\n \\\"train_size\\\":len(tr_text),\\n \\\"test_size\\\":len(te_text)\\n })\\n best_results = dict(metrics_df.groupby(\\\"metric\\\")[\\\"mean\\\"].max()[[\\\"f1\\\",\\\"acc\\\",\\\"auc\\\"]])\\n exp.log_metrics(best_results)\\n exp.end()\\n return best_config\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\n def miniMaxAgent(state, depth, agentIndex):\\n \\n #return evaluation function if game is won or lost or the depth is reached\\n if state.isLose() or state.isWin() or depth == self.depth:\\n return self.evaluationFunction(state)\\n \\n #if agent index is 0 that is pacman so get the maximum value\\n if agentIndex == 0:\\n maximum = float(\\\"-inf\\\")\\n actions = state.getLegalActions(agentIndex) #pacmans legal actions\\n \\n #get successor from all actions and set maximum as the largest value found\\n for action in actions:\\n successor = state.generateSuccessor(agentIndex, action)\\n maximum = max(maximum, miniMaxAgent(successor, depth, 1)) #pass agent index as 1 to move onto the ghosts (min)\\n \\n return maximum\\n \\n #if agent index is greater than 0 it is a ghost so get the minimum value\\n else:\\n minimum = float(\\\"inf\\\")\\n actions = state.getLegalActions(agentIndex)\\n \\n #get successor from all actions and set the minimum to the smallest value found\\n for action in actions:\\n successor = state.generateSuccessor(agentIndex, action) #ghosts legal actions\\n \\n #if all ghosts have found a min, increase depth and set agent back to pacman (max)\\n if state.getNumAgents() -1 == agentIndex:\\n minimum = min(minimum, miniMaxAgent(successor, depth + 1, 0))\\n \\n #increase agent index to get the next ghost\\n else:\\n minimum = min(minimum, miniMaxAgent(successor, depth, agentIndex + 1))\\n return minimum\\n \\n score = float(\\\"-inf\\\")\\n direction = None\\n \\n #get all the legal actions in the game state\\n legalActions = gameState.getLegalActions()\\n \\n #get successor from each action in the game\\n for action in legalActions:\\n successor = gameState.generateSuccessor(0, action)\\n \\n #start at depth 0 and agent index 1\\n value = miniMaxAgent(successor, 0, 1)\\n \\n #find the largest value and set direction to the action that returned that value\\n if score < value:\\n score = value\\n direction = action\\n \\n return direction\\n util.raiseNotDefined()\",\n \"def do_MD_atom_walk(at, movement_args, Emax, KEmax):\\n#DOC\\n#DOC ``do_MD_atom_walk``\\n orig_E = at.info['ns_energy']\\n if orig_E >= Emax:\\n print print_prefix, \\\": WARNING: orig_E =\\\",orig_E,\\\" >= Emax =\\\",Emax\\n\\n #DOC \\\\item if MD\\\\_atom\\\\_velo\\\\_pre\\\\_perturb, call do\\\\_MC\\\\_atom\\\\_velo\\\\_walk() for magnitude and rotation\\n if movement_args['MD_atom_velo_pre_perturb']:\\n do_MC_atom_velo_walk(at, movement_args, Emax, KEmax)\\n\\n pre_MD_pos = at.get_positions()\\n pre_MD_velo = at.get_velocities()\\n if ns_args['n_extra_data'] > 0:\\n pre_MD_extra_data = at.arrays['ns_extra_data'].copy()\\n\\n pre_MD_E = at.info['ns_energy']\\n\\n #DOC \\\\item propagate in time atom\\\\_traj\\\\_len time steps of length MD\\\\_atom\\\\_timestep\\n if movement_args['python_MD']:\\n forces = eval_forces(at)\\n final_E = None\\n timestep = movement_args['MD_atom_timestep']\\n for i in range(movement_args['atom_traj_len']):\\n at.set_momenta(at.get_momenta()+forces*0.5*timestep)\\n at.set_positions(at.get_positions()+at.get_momenta()*timestep)\\n try:\\n forces = eval_forces(at)\\n except:\\n final_E = 2.0*abs(Emax)\\n break\\n at.set_momenta(at.get_momenta()+forces*0.5*timestep)\\n if final_E is None: # didn't abort due to exception in eval_forces()\\n final_E = eval_energy(at)\\n else:\\n if do_calc_quip:\\n propagate_NVE_quippy(at, dt=movement_args['MD_atom_timestep'], n_steps=movement_args['atom_traj_len'])\\n final_E = eval_energy(at)\\n elif do_calc_lammps:\\n if propagate_lammps(at, dt=movement_args['MD_atom_timestep'], n_steps=movement_args['atom_traj_len'], algo='NVE'):\\n final_E = pot.results['energy'] + eval_energy(at, do_PE=False)\\n else: # propagate returned success == False\\n final_E = 2.0*abs(Emax)\\n ## print \\\"error in propagate_lammps NVE, setting final_E = 2*abs(Emax) =\\\" , final_E\\n elif do_calc_fortran:\\n final_E = f_MC_MD.MD_atom_NVE_walk(at, n_steps=movement_args['atom_traj_len'], timestep=movement_args['MD_atom_timestep'], debug=ns_args['debug'])\\n final_E += eval_energy(at, do_PE=False, do_KE=False)\\n else:\\n exit_error(\\\"Need some non-quippy, non-fortran, non-lammps way of doing MD\\\\n\\\",3)\\n\\n reject_fuzz = False\\n final_KE = eval_energy_KE(at)\\n #DOC \\\\item If MD\\\\_atom\\\\_reject\\\\_energy\\\\_violation is set, accept/reject entire move on E deviating by less than MD\\\\_atom\\\\_energy\\\\_fuzz times kinetic energy\\n if abs(final_E-pre_MD_E) > movement_args['MD_atom_energy_fuzz']*final_KE:\\n if movement_args['MD_atom_reject_energy_violation']:\\n reject_fuzz = True\\n # else:\\n # print print_prefix, \\\": WARNING: MD energy deviation > fuzz*final_KE. Pre-MD, post-MD, difference, final_KE \\\", pre_MD_E, final_E, final_E-pre_MD_E, final_KE\\n\\n #DOC \\\\item accept/reject entire move on E < Emax and KE < KEmax\\n reject_Emax = (final_E >= Emax)\\n reject_KEmax = (KEmax > 0.0 and final_KE >= KEmax)\\n\\n #DOC \\\\item if reject\\n if reject_fuzz or reject_Emax or reject_KEmax: # reject\\n #DOC \\\\item set positions, velocities, energy back to value before perturbation (maybe should be after?)\\n # print print_prefix, \\\": WARNING: reject MD traj Emax \\\", Emax, \\\" initial E \\\", orig_E, \\\" velo perturbed E \\\", pre_MD_E, \\\" final E \\\",final_E, \\\" KEmax \\\", KEmax, \\\" KE \\\", final_KE\\n at.set_positions(pre_MD_pos)\\n if movement_args['MD_atom_velo_flip_accept']:\\n at.set_velocities(pre_MD_velo)\\n else:\\n at.set_velocities(-pre_MD_velo)\\n if ns_args['n_extra_data'] > 0:\\n at.arrays['ns_extra_data'][...] = pre_MD_extra_data\\n at.info['ns_energy'] = pre_MD_E\\n n_accept = 0\\n #DOC \\\\item else\\n else: # accept\\n #DOC \\\\item flip velocities if MD\\\\_atom\\\\_velo\\\\_flip\\\\_accept\\n # remember to reverse velocities on acceptance to preserve detailed balance, since velocity is (sometimes) being perturbed, not completely randomized\\n if movement_args['MD_atom_velo_flip_accept']:\\n at.set_velocities(-at.get_velocities()) # is there a faster way of doing this in ASE? Can you do at.velocities?\\n at.info['ns_energy'] = final_E\\n n_accept = 1\\n\\n #DOC \\\\item if MD\\\\_atom\\\\_velo\\\\_post\\\\_perturb, call do\\\\_MC\\\\_atom\\\\_velo\\\\_walk() for magnitude and rotation\\n if movement_args['MD_atom_velo_post_perturb']:\\n do_MC_atom_velo_walk(at, movement_args, Emax, KEmax)\\n\\n return {'MD_atom' : (1, n_accept) }\",\n \"def fit(args):\\n\\n config_file = args.setupfn\\n conf_base = os.path.basename(config_file).split('.')[0]\\n print(\\\"Performing maximum a posteriori fitting for {}\\\".format(conf_base))\\n\\n P, post = radvel.utils.initialize_posterior(config_file, decorr=args.decorr)\\n\\n post = radvel.fitting.maxlike_fitting(post, verbose=True)\\n\\n postfile = os.path.join(args.outputdir,\\n '{}_post_obj.pkl'.format(conf_base))\\n post.writeto(postfile)\\n\\n savestate = {'run': True,\\n 'postfile': os.path.relpath(postfile)}\\n save_status(os.path.join(args.outputdir,\\n '{}_radvel.stat'.format(conf_base)),\\n 'fit', savestate)\",\n \"def progressive_deepening(state, heuristic_fn=always_zero, depth_limit=INF,\\n maximize=True) :\\n anytime_value = AnytimeValue() # TA Note: Use this to store values.\\n depth = 0\\n while depth<=depth_limit-1:\\n depth+=1\\n best_option=minimax_search_alphabeta(state,-INF,INF, heuristic_fn=heuristic_fn,depth_limit=depth, maximize=True)\\n anytime_value.set_value(best_option)\\n return anytime_value\",\n \"def optim_func(params, model):\\n if model.model == 'ARD':\\n model.alpha, model.beta = params\\n lik = model.pruning_algorithm()\\n\\n else:\\n model.alpha = params[0]\\n lik = model.pruning_algorithm()\\n \\n return -lik\",\n \"def __max_step(self, batch):\\n\\n # short hand and optimizer\\n policy = self.mc.get('policy', target=False)\\n policy_parameters = list(policy.parameters())\\n opt_outer = optim.Adam(policy_parameters, lr=self.outer_lr)\\n\\n # optimize\\n opt_outer.zero_grad()\\n obj = -self.obj(batch)\\n obj.backward()\\n opt_outer.step()\",\n \"def _objective(self, trial, X, y, weights=None, split=None):\\n\\n # Generate even weights if none\\n if weights is None:\\n weights = pd.Series(np.ones(len(y)), index=y.index)\\n else:\\n weights = pd.Series(weights, index=y.index)\\n\\n # Execute trial function\\n try:\\n res = eval(self.function)\\n except:\\n raise RuntimeError(f\\\"Optuna execution error: {self.function}\\\")\\n\\n # If indicator result is tuple, select the one of interest\\n if isinstance(res, tuple):\\n res = res[self.idx]\\n\\n # Ensure result is a dataframe with same index as X\\n res = pd.DataFrame(res, index=X.index)\\n\\n # If indicator result is dataframe, select the one of interest\\n if len(res.columns) > 1:\\n res = pd.DataFrame(res.iloc[:, self.idx])\\n\\n # y may be a subset of X, so reduce result to y and convert to series\\n res_y = res.reindex(y.index).iloc[:, 0].replace([np.inf, -np.inf], np.nan)\\n\\n # Save all trial results for pruning and reporting\\n # Only the best trial will eventually be saved to limit storage requirements\\n self.res_y.append(res_y) # Save results\\n\\n # Indicator result may be all NANs based on parameter set\\n # Return FALSE and alert\\n if np.isnan(res_y).sum() / len(res_y) > .95: # Most or all NANs\\n self.res_y_corr.append(np.zeros(len(y)))\\n if split is not None:\\n return tuple([False] * (len(split) - 1))\\n else:\\n return False\\n\\n # Obtain correlation for entire dataset\\n if self.spearman:\\n corr = _weighted_spearman(np.array(y), np.array(res_y), np.array(weights))\\n else:\\n corr = _weighted_pearson(np.array(y), np.array(res_y), np.array(weights))\\n\\n # Save correlation for res_y\\n self.res_y_corr.append(corr)\\n\\n # Multi-objective optimization\\n # Obtain correlation to target for each split for Optuna to maximize\\n if split is not None:\\n mo = []\\n for i, e in enumerate(split):\\n if i == 0:\\n s = e\\n continue\\n\\n # y could be a subset of X, use index of X to filter y\\n idx = X[s:e].index\\n\\n # Filter y based on X split\\n y_se = np.array(y[y.index.isin(idx)]).astype('float64')\\n\\n # Filter y predictions based on X split\\n res_y_se = np.array(res_y[res_y.index.isin(idx)]).astype('float64')\\n\\n # Filter weights based on X split\\n weights_se = np.array(weights[weights.index.isin(idx)]).astype('float64')\\n\\n if np.isnan(res_y_se).sum() / len(res_y_se) > .95:\\n return tuple([False]*(len(split)-1))\\n\\n if self.spearman:\\n mo.append(_weighted_spearman(y_se, res_y_se, weights_se))\\n else:\\n mo.append(_weighted_pearson(y_se, res_y_se, weights_se))\\n s = e\\n return tuple(mo)\\n\\n # Single objective optimization return corr for entire dataset\\n else:\\n return corr\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n def agentCounter(gameState, index, depth):\\n \\\"\\\"\\\"When index is out of bounds return pacmans index and\\n reduce depth by 1\\\"\\\"\\\"\\n if index == gameState.getNumAgents():\\n return [depth-1, 0]\\n else:\\n return [depth, index]\\n\\n def minimax(self, gameState, depth, index):\\n \\\"\\\"\\\"Implement minimax function for pacman game. \\n return an array with score and best move\\\"\\\"\\\"\\n ultimateMove = None # The best move the agent can use\\n if depth == 0 or gameState.isWin() or gameState.isLose():\\n # if leaf node return value.\\n return [self.evaluationFunction(gameState), ultimateMove]\\n else:\\n if index == 0: # if pacman => agent is max agent\\n value = -math.inf\\n maxValue = value\\n # iterates through max agent w/index=0 moves\\n for action in gameState.getLegalActions(0):\\n depthIndex = agentCounter(gameState, index+1, depth)\\n successorState = gameState.generateSuccessor(\\n index, action) # generates the next state when move is done\\n value = max(value, minimax(\\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return max of saved value and recursive function\\n if maxValue != value: # If value has changed update values\\n ultimateMove = action\\n maxValue = value\\n return [value, ultimateMove]\\n else: # is ghost => agent is min agent\\n value = math.inf\\n minValue = value\\n # Iterate through the moves of a min agent w/index not 0\\n for action in gameState.getLegalActions(index):\\n depthIndex = agentCounter(gameState, index+1, depth)\\n successorState = gameState.generateSuccessor(\\n index, action)\\n value = min(value, minimax(\\n self, successorState, depthIndex[0], depthIndex[1])[0]) # return min of saved value and recursive function\\n if minValue != value: # If value has changed update values\\n ultimateMove = action\\n minValue = value\\n return [value, ultimateMove]\\n\\n best = minimax(self, gameState, self.depth, self.index)\\n #print(\\\"Move: \\\", best[1], \\\" | Score: \\\", best[0])\\n return best[1]\",\n \"def example():\\n Optimizer = BFGS(f, g)\\n startPoint = 100 * numpy.ones(2);\\n res = Optimizer.optimize(startPoint,\\n epsilon=1e-5,\\n maxIterations=10)\\n print res\\n pass\",\n \"def compute_optimalReward(task):\\n\\n\\tT = 15.0\\n\\tweights = 0\\n\\tif task == TABLE_TASK or task == COFFEE_TASK:\\n\\t\\tweights = 1\\n\\telif task == LAPTOP_TASK:\\n\\t\\tweights = 10\\n\\n\\t# initialize start/goal based on task \\n\\tif task == COFFEE_TASK or task == HUMAN_TASK:\\n\\t\\tpick = pick_shelf\\n\\telse:\\n\\t\\tpick = pick_basic\\n\\n\\tif task == LAPTOP_TASK:\\n\\t\\tplace = place_higher\\n\\telse:\\n\\t\\tplace = place_lower\\n\\t\\t\\n\\tstartRad = np.array(pick)*(math.pi/180.0)\\n\\tgoalRad = np.array(place)*(math.pi/180.0)\\n\\tstart = startRad\\n\\tgoal = goalRad\\n\\n\\tplan = Planner(task)\\t\\n\\tfilename = None\\n\\tif task == 1:\\n\\t\\tfilename = \\\"task1.csv\\\"\\n\\telif task == 2:\\n\\t\\tfilename = \\\"task2.csv\\\"\\n\\telif task == 3:\\n\\t\\tfilename = \\\"task3.csv\\\"\\n\\t\\t\\n\\t# get optimal waypts from file\\n\\twaypts = get_opt_waypts(filename)\\n\\tr = plan.featurize(waypts)\\n\\tRvel = r[0]\\n\\tRfeat = np.sum(r[1])\\n\\n\\tplan.kill_planner()\\n\\treturn (Rvel, Rfeat)\",\n \"def optimize(\\n self, n, tol=None, jac=True, hessp=False, optlib=\\\"scipy\\\", **options\\n ):\\n return {\\\"scipy\\\": self.optimize_scipy, \\\"nlopt\\\": self.optimize_nlopt,}[\\n optlib\\n ](n=n, tol=tol, jac=jac, hessp=hessp, **options)\",\n \"def __init__(self, direction, max_momentum, current_momentum=None, max_speed=2, current_speed=0, rowing=False):\\n self.direction = direction\\n self.max_momentum = max_momentum\\n if current_momentum is None:\\n self.current_momentum = self.max_momentum\\n else:\\n self.current_momentum = current_momentum\\n self.max_speed = max_speed\\n self.current_speed = current_speed\\n self.rowing = rowing\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70528316","0.59501183","0.5642754","0.5085643","0.50599","0.5013388","0.5011954","0.5007961","0.5003236","0.49108404","0.48720664","0.48720354","0.48174542","0.4795054","0.47906741","0.47627977","0.47517008","0.46950796","0.46797842","0.46576664","0.464577","0.46434075","0.46383366","0.45940447","0.4570762","0.45672405","0.4563032","0.45611793","0.4514062","0.45022818","0.4485873","0.4473632","0.44566587","0.44444147","0.44406152","0.44368598","0.443667","0.44349545","0.4433418","0.44316208","0.44285032","0.44167855","0.43913692","0.43846676","0.43834084","0.43806526","0.43722382","0.4356717","0.4348689","0.43450516","0.4337428","0.4335303","0.4328867","0.43244237","0.42946523","0.4293306","0.42932338","0.42928696","0.42893413","0.42790988","0.42790988","0.427324","0.4271819","0.42659557","0.42633238","0.42613405","0.425623","0.42551777","0.42550826","0.4254695","0.42433813","0.42425767","0.42391527","0.42389327","0.42372692","0.42370087","0.4236038","0.4228778","0.4222919","0.42170712","0.42129174","0.42111373","0.42085347","0.41972905","0.41832116","0.41803625","0.4178804","0.41704175","0.41669852","0.41665405","0.4158127","0.41572994","0.4151666","0.41509527","0.4148606","0.4147388","0.41455013","0.41311547","0.4127072","0.41159743"],"string":"[\n \"0.70528316\",\n \"0.59501183\",\n \"0.5642754\",\n \"0.5085643\",\n \"0.50599\",\n \"0.5013388\",\n \"0.5011954\",\n \"0.5007961\",\n \"0.5003236\",\n \"0.49108404\",\n \"0.48720664\",\n \"0.48720354\",\n \"0.48174542\",\n \"0.4795054\",\n \"0.47906741\",\n \"0.47627977\",\n \"0.47517008\",\n \"0.46950796\",\n \"0.46797842\",\n \"0.46576664\",\n \"0.464577\",\n \"0.46434075\",\n \"0.46383366\",\n \"0.45940447\",\n \"0.4570762\",\n \"0.45672405\",\n \"0.4563032\",\n \"0.45611793\",\n \"0.4514062\",\n \"0.45022818\",\n \"0.4485873\",\n \"0.4473632\",\n \"0.44566587\",\n \"0.44444147\",\n \"0.44406152\",\n \"0.44368598\",\n \"0.443667\",\n \"0.44349545\",\n \"0.4433418\",\n \"0.44316208\",\n \"0.44285032\",\n \"0.44167855\",\n \"0.43913692\",\n \"0.43846676\",\n \"0.43834084\",\n \"0.43806526\",\n \"0.43722382\",\n \"0.4356717\",\n \"0.4348689\",\n \"0.43450516\",\n \"0.4337428\",\n \"0.4335303\",\n \"0.4328867\",\n \"0.43244237\",\n \"0.42946523\",\n \"0.4293306\",\n \"0.42932338\",\n \"0.42928696\",\n \"0.42893413\",\n \"0.42790988\",\n \"0.42790988\",\n \"0.427324\",\n \"0.4271819\",\n \"0.42659557\",\n \"0.42633238\",\n \"0.42613405\",\n \"0.425623\",\n \"0.42551777\",\n \"0.42550826\",\n \"0.4254695\",\n \"0.42433813\",\n \"0.42425767\",\n \"0.42391527\",\n \"0.42389327\",\n \"0.42372692\",\n \"0.42370087\",\n \"0.4236038\",\n \"0.4228778\",\n \"0.4222919\",\n \"0.42170712\",\n \"0.42129174\",\n \"0.42111373\",\n \"0.42085347\",\n \"0.41972905\",\n \"0.41832116\",\n \"0.41803625\",\n \"0.4178804\",\n \"0.41704175\",\n \"0.41669852\",\n \"0.41665405\",\n \"0.4158127\",\n \"0.41572994\",\n \"0.4151666\",\n \"0.41509527\",\n \"0.4148606\",\n \"0.4147388\",\n \"0.41455013\",\n \"0.41311547\",\n \"0.4127072\",\n \"0.41159743\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72034293"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":10490,"cells":{"query":{"kind":"string","value":"generator function that samples mixtures according to the `model`. `steps` determines how many mixtures are sampled `dtype` determines the dtype of the resulting concentration vector"},"document":{"kind":"string","value":"def _sample_binary_mixtures(model, steps, dtype=np.uint):\n mixture_size = model.parameters['fixed_mixture_size']\n \n if not model.is_correlated_mixture and mixture_size is None:\n # use simple monte carlo algorithm\n prob_s = model.substrate_probabilities\n \n for _ in range(int(steps)):\n # choose a mixture vector according to substrate probabilities\n yield (np.random.random(model.Ns) < prob_s).astype(dtype)\n\n elif mixture_size is None:\n # go through all mixtures and don't keep the size constant\n\n # use metropolis algorithm\n hi = model.commonness\n Jij = model.correlations\n \n # start with a random concentration vector \n c = np.random.randint(0, 2, model.Ns).astype(dtype)\n E_last = -np.dot(np.dot(Jij, c) + hi, c)\n \n for _ in range(int(steps)):\n i = random.randrange(model.Ns)\n c[i] = 1 - c[i] #< switch the entry\n Ei = -np.dot(np.dot(Jij, c) + hi, c)\n if Ei < E_last or random.random() < np.exp(E_last - Ei):\n # accept the new state\n E_last = Ei\n else:\n # reject the new state and revert to the last one\n c[i] = 1 - c[i]\n \n yield c\n \n elif mixture_size == 0:\n # special case which is not covered by the iteration below\n c_zero = np.zeros(model.Ns, dtype)\n for _ in range(model._sample_steps):\n yield c_zero\n\n elif mixture_size == model.Ns:\n # special case which is not covered by the iteration below\n c_ones = np.ones(model.Ns, dtype)\n for _ in range(steps):\n yield c_ones\n \n else:\n # go through mixtures with keeping their size constant\n\n # use metropolis algorithm\n hi = model.commonness\n Jij = model.correlations\n\n # create random concentration vector with fixed substrate count\n c = np.r_[np.ones(mixture_size, dtype),\n np.zeros(model.Ns - mixture_size, dtype)]\n np.random.shuffle(c)\n E_last = -np.dot(np.dot(Jij, c) + hi, c)\n \n for _ in range(int(steps)):\n # find the next mixture by swapping two items\n i0 = random.choice(np.flatnonzero(c == 0)) #< find 0\n i1 = random.choice(np.flatnonzero(c)) #< find 1\n c[i0], c[i1] = 1, 0 #< swap entries\n Ei = -np.dot(np.dot(Jij, c) + hi, c)\n if Ei < E_last or random.random() < np.exp(E_last - Ei):\n # accept the new state\n E_last = Ei\n else:\n # reject the new state and revert to the last one\n c[i0], c[i1] = 0, 1\n \n yield c"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _sample_mixtures(self, steps=None, dtype=np.uint):\n if steps is None:\n steps = self._sample_steps\n \n return _sample_binary_mixtures(self, steps, dtype)","def _iterate_mixtures(self):\n \n if self._iterate_steps > self.parameters['max_steps']:\n raise RuntimeError('The iteration would take more than %g steps'\n % self.parameters['max_steps'])\n \n hi = self.commonness\n Jij = self.correlations\n\n mixture_size = self.parameters['fixed_mixture_size']\n if mixture_size is None:\n # iterate over all mixtures\n for c in itertools.product((0, 1), repeat=self.Ns):\n c = np.array(c, np.uint8)\n weight_c = np.exp(np.dot(np.dot(Jij, c) + hi, c))\n yield c, weight_c\n \n elif mixture_size == 0:\n # special case which is not covered by the iteration below\n yield np.zeros(self.Ns, np.uint8), 1\n \n elif mixture_size == self.Ns:\n # special case which is not covered by the iteration below\n yield np.ones(self.Ns, np.uint8), 1\n \n else:\n # iterate over all mixtures with constant number of substrates\n c = np.zeros(self.Ns, np.uint8)\n for nz in itertools.combinations(range(self.Ns), mixture_size):\n c[:] = 0\n c[np.array(nz)] = 1\n weight_c = np.exp(np.dot(np.dot(Jij, c) + hi, c))\n yield c, weight_c","def data_gen(voc_size, batch, nbatches, seq_len = 15):\r\n for i in range(nbatches):\r\n # (batch_size, seq_len)\r\n data = torch.from_numpy(\r\n np.random.randint(1, voc_size, size=(batch, seq_len)))\r\n data[:, 0] = 1 # add start token\r\n src = Variable(data, requires_grad=False)\r\n tgt = Variable(data, requires_grad=False)\r\n yield Batch(src, tgt, 0) # Accessed by next function one by one\r","def generate_data(model, n_batches=5, samples_per_batch=200):\n\tcalcium, spec, yn_samples, yb_samples = [], [], [], []\n\twith torch.no_grad():\n\t\tfor i in range(n_batches):\n\t\t\tz_sample = torch.randn(samples_per_batch,1,1,model.z_dim).to(model.device)\n\t\t\tyn_sample = model.sample_yn(z_sample)\n\t\t\tyb_sample = model.sample_yb(z_sample)\n\t\t\tc_μ = model.decode_calcium(yn_sample).squeeze()\n\t\t\tif model.model_type == 'sparse_poe_finch':\n\t\t\t\tspec_rec, _ = model.decode_spec(yb_sample)\n\t\t\telse:\n\t\t\t\tspec_rec = model.decode_spec(yb_sample)\n\t\t\tspec_rec = spec_rec.squeeze()\n\t\t\tcalcium.append(c_μ)\n\t\t\tspec.append(spec_rec)\n\t\t\tyn_samples.append(yn_sample.squeeze(1).squeeze(1))\n\t\t\tyb_samples.append(yb_sample.squeeze(1).squeeze(1))\n\t\tcalcium = torch.cat(calcium, dim=0).detach().cpu().numpy()\n\t\tspec = torch.cat(spec, dim=0).detach().cpu().numpy()\n\t\tyn_samples = torch.cat(yn_samples, dim=0).detach().cpu().numpy()\n\t\tyb_samples = torch.cat(yb_samples, dim=0).detach().cpu().numpy()\n\treturn calcium, spec, yn_samples, yb_samples","def data_generator(delta=1, batch_size=32):\n while True:\n yield generate_samples(delta=delta, n=batch_size)","def generate_samples(self, n_samples):","def generate_samples(self, n_samples):","def seq_data_iter_sequential(corpus, batch_size, num_steps):\n # Start with a random offset to partition a sequence\n offset = random.randint(0, num_steps)\n num_tokens = ((len(corpus) - offset - 1) // batch_size) * batch_size\n Xs = torch.tensor(corpus[offset: offset + num_tokens])\n Ys = torch.tensor(corpus[offset + 1: offset + 1 + num_tokens])\n Xs, Ys = Xs.reshape(batch_size, -1), Ys.reshape(batch_size, -1)\n num_batches = Xs.shape[1] // num_steps\n for i in range(0, num_steps * num_batches, num_steps):\n X = Xs[:, i: i + num_steps]\n Y = Ys[:, i: i + num_steps]\n yield X, Y","def _sample_steps(self):\n mixture_size = self.parameters['fixed_mixture_size']\n if not self.is_correlated_mixture and mixture_size is None:\n return self.get_steps('monte_carlo')\n else:\n return self.get_steps('metropolis')","def seq_data_iter_random(corpus, batch_size, num_steps): #@save\n # Start with a random offset (inclusive of `num_steps - 1`) to partition a\n # sequence\n corpus = corpus[random.randint(0, num_steps - 1):]\n # Subtract 1 since we need to account for labels\n num_subseqs = (len(corpus) - 1) // num_steps\n # The starting indices for subsequences of length `num_steps`\n initial_indices = list(range(0, num_subseqs * num_steps, num_steps))\n # In random sampling, the subsequences from two adjacent random\n # minibatches during iteration are not necessarily adjacent on the\n # original sequence\n random.shuffle(initial_indices)\n\n def data(pos):\n # Return a sequence of length `num_steps` starting from `pos`\n return corpus[pos: pos + num_steps]\n\n num_batches = num_subseqs // batch_size\n for i in range(0, batch_size * num_batches, batch_size):\n # Here, `initial_indices` contains randomized starting indices for\n # subsequences\n initial_indices_per_batch = initial_indices[i: i + batch_size]\n X = [data(j) for j in initial_indices_per_batch]\n Y = [data(j + 1) for j in initial_indices_per_batch]\n yield torch.tensor(X), torch.tensor(Y)","def create_mixture_csv(data_type):\n \n workspace = config.workspace\n data_dir = config.data_dir\n speech_dir = os.path.join(data_dir,'{}_speech'.format(data_type))\n noise_dir = os.path.join(data_dir,'{}_noise'.format(data_type)) \n magnification = config.magnification\n fs = config.sample_rate\n \n speech_names = [na for na in os.listdir(speech_dir) if na.lower().endswith(\".wav\")]\n noise_names = [na for na in os.listdir(noise_dir) if na.lower().endswith(\".wav\")]\n \n rs = np.random.RandomState(0)\n out_csv_path = os.path.join(workspace, \"mixture_csvs\", \"%s.csv\" % data_type)\n create_folder(os.path.dirname(out_csv_path))\n \n cnt = 0\n f = open(out_csv_path, 'w')\n f.write(\"%s\\t%s\\t%s\\t%s\\n\" % (\"speech_name\", \"noise_name\", \"noise_onset\", \"noise_offset\"))\n for speech_na in speech_names:\n # Read speech. \n speech_path = os.path.join(speech_dir, speech_na)\n (speech_audio, _) = read_audio(speech_path)\n len_speech = len(speech_audio)\n \n # For training data, mix each speech with randomly picked #magnification noises. \n if data_type == 'train':\n selected_noise_names = rs.choice(noise_names, size=magnification, replace=False)\n # For test data, mix each speech with all noises. \n elif data_type == 'test':\n selected_noise_names = noise_names\n else:\n raise Exception(\"data_type must be train | test!\")\n\n # Mix one speech with different noises many times. \n for noise_na in selected_noise_names:\n noise_path = os.path.join(noise_dir, noise_na)\n (noise_audio, _) = read_audio(noise_path)\n \n len_noise = len(noise_audio)\n\n if len_noise <= len_speech:\n noise_onset = 0\n nosie_offset = len_speech\n # If noise longer than speech then randomly select a segment of noise. \n else:\n noise_onset = rs.randint(0, len_noise - len_speech, size=1)[0]\n nosie_offset = noise_onset + len_speech\n \n if cnt % 100 == 0:\n print(cnt)\n \n cnt += 1\n f.write(\"%s\\t%s\\t%d\\t%d\\n\" % (speech_na, noise_na, noise_onset, nosie_offset))\n f.close()\n print(out_csv_path)\n print(\"Create %s mixture csv finished!\" % data_type)","def trainDataGenerator(num_epochs):\r\n samples, all_files = get_filenames()\r\n for num in range(num_epochs):\r\n for i in range(len(samples)):\r\n sample = samples[i]\r\n for file in all_files[i]:\r\n ohvs, Y = prepData(sample, file)\r\n if (ohvs == []):\r\n continue\r\n X = np.array([ohvs[:800]])\r\n yield X, Y\r\n # for i in range(0, len(ohvs), 400):\r\n # X = np.array([ohvs[i : i+400]])\r\n # print(\"\\tX shape =\", X.shape)\r\n # yield X, Y\r","def create_step_samples(self):\n pass # Deferred to subclasses\n\n \"\"\" Example using pod height:\n start_value = self.sim.pod.last_height\n end_value = self.sim.pod.height\n\n # Lerp values to get samples\n samples = start_value + self.step_lerp_pcts * (end_value - start_value) # Or use self.lerp(start_value, end_value), but doing it directly is faster since no function call\n if self.noise_scale > 0:\n # Add gaussian noise if specified\n return samples + np.random.normal(0.0, noise_scale, len(samples))\n else:\n # No noise\n return samples \n \"\"\"","def calculate_mixture_features(data_type):\n workspace = config.workspace\n data_dir = config.data_dir\n speech_dir = os.path.join(data_dir,'{}_speech'.format(data_type))\n noise_dir = os.path.join(data_dir,'{}_noise'.format(data_type)) \n \n fs = config.sample_rate\n \n if data_type == 'train':\n snr = config.Tr_SNR\n elif data_type == 'test':\n snr = config.Te_SNR \n else:\n raise Exception(\"data_type must be train | test!\")\n \n \n # Open mixture csv. \n mixture_csv_path = os.path.join(workspace, \"mixture_csvs\", \"%s.csv\" % data_type)\n with open(mixture_csv_path, 'r') as f:\n reader = csv.reader(f, delimiter='\\t')\n lis = list(reader)\n \n t1 = time.time()\n cnt = 0\n for i1 in range(1, len(lis)):\n [speech_na, noise_na, noise_onset, noise_offset] = lis[i1]\n noise_onset = int(noise_onset)\n noise_offset = int(noise_offset)\n \n # Read speech audio. \n speech_path = os.path.join(speech_dir, speech_na)\n (speech_audio, _) = read_audio(speech_path, target_fs=fs)\n \n # Read noise audio. \n noise_path = os.path.join(noise_dir, noise_na)\n (noise_audio, _) = read_audio(noise_path, target_fs=fs)\n \n # Repeat noise to the same length as speech. \n if len(noise_audio) < len(speech_audio):\n n_repeat = int(np.ceil(float(len(speech_audio)) / float(len(noise_audio))))\n noise_audio_ex = np.tile(noise_audio, n_repeat)\n noise_audio = noise_audio_ex[0 : len(speech_audio)]\n # Truncate noise to the same length as speech. \n else:\n noise_audio = noise_audio[noise_onset : noise_offset]\n \n # Scale speech to given snr. \n scaler = get_amplitude_scaling_factor(speech_audio, noise_audio, snr=snr)\n speech_audio *= scaler\n \n # Get normalized mixture, speech, noise. \n (mixed_audio, speech_audio, noise_audio, alpha) = additive_mixing(speech_audio, noise_audio)\n\n # Write out mixed audio. \n out_bare_na = os.path.join(\"%s.%s\" % \n (os.path.splitext(speech_na)[0], os.path.splitext(noise_na)[0]))\n out_audio_path = os.path.join(workspace, \"mixed_audios\", \"spectrogram\", \n data_type, \"%ddb\" % int(snr), \"%s.wav\" % out_bare_na)\n create_folder(os.path.dirname(out_audio_path))\n write_audio(out_audio_path, mixed_audio, fs)\n\n # Extract spectrogram. \n mixed_complx_x = calc_sp(mixed_audio, mode='complex')\n speech_x = calc_sp(speech_audio, mode='magnitude')\n noise_x = calc_sp(noise_audio, mode='magnitude')\n\n # Write out features. \n out_feat_path = os.path.join(workspace, \"features\", \"spectrogram\", \n data_type, \"%ddb\" % int(snr), \"%s.p\" % out_bare_na)\n create_folder(os.path.dirname(out_feat_path))\n data = [mixed_complx_x, speech_x, noise_x, alpha, out_bare_na]\n pickle.dump(data, open(out_feat_path, 'wb'), protocol=pickle.HIGHEST_PROTOCOL)\n \n # Print. \n if cnt % 100 == 0:\n print(cnt)\n \n cnt += 1\n\n print(\"Extracting feature time: %s\" % (time.time() - t1))","def sample(model, x, steps, temperature=1.0, sample=False, top_k=None):\n block_size = model.get_block_size()\n model.eval()\n for k in range(steps):\n x_cond = x if x.size(1) <= block_size else x[:, -block_size:] # crop context if needed\n logits, _ = model(x_cond)\n # pluck the logits at the final step and scale by temperature\n logits = logits[:, -1, :] / temperature\n # optionally crop probabilities to only the top k options\n if top_k is not None:\n logits = top_k_logits(logits, top_k)\n # apply softmax to convert to probabilities\n probs = F.softmax(logits, dim=-1)\n # sample from the distribution or take the most likely\n if sample:\n ix = torch.multinomial(probs, num_samples=1)\n else:\n _, ix = torch.topk(probs, k=1, dim=-1)\n # append to the sequence and continue\n x = torch.cat((x, ix), dim=1)\n\n return x","def gen(num_batches,\n batch_size,\n seq_width,\n min_len,\n max_len):\n for batch_num in range(num_batches):\n\n # All batches have the same sequence length\n seq_len = random.randint(min_len, max_len)\n seq = np.random.binomial(1, 0.5, (seq_len, batch_size, seq_width))\n seq = Variable(torch.from_numpy(seq))\n\n # The input includes an additional channel used for the delimiter\n inp = Variable(torch.zeros(seq_len + 1, batch_size, seq_width + 1))\n inp[:seq_len, :, :seq_width] = seq\n inp[seq_len, :, seq_width] = 1.0 # delimiter in our control channel\n outp = seq.clone()\n\n yield batch_num+1, inp.float().to(params.device), outp.float().to(params.device)","def gen_mixture():\n npr.seed(0)\n num_exp = int(1e4)\n x_dim = 2\n z_dim = 2\n mu1 = [5, 5,]\n mu2 = [-5, -5]\n theta = np.array([[2,1],[-1,-2]])\n sigma = 0.1\n u = npr.uniform((num_exp,))\n z = np.zeros((num_exp, z_dim))\n cov = np.zeros((z_dim, z_dim))\n np.fill_diagonal(cov, 1)\n sz = int(num_exp/2)\n z[:sz, ]= npr.multivariate_normal(mu1, cov,sz)\n z[sz:, ] = npr.multivariate_normal(mu2,cov,sz)\n mu_x = theta@z.transpose()\n\n x = np.zeros((num_exp, x_dim))\n for i in range(num_exp):\n x[i,:] = npr.multivariate_normal(mu_x[:,i], sigma*cov)\n print(x.shape)\n np.save('data/syn_mixture.npy', x)","def bootstrap_sample_generator_3D(samples: Union[NumpyFloatArray, NumpyIntArray]):\n n_samples = samples.shape[1]\n array_shape = samples.shape[1:]\n num_cols = samples.shape[2]\n cols = np.arange(num_cols)\n\n while True:\n _indices = np.random.randint(0, high=n_samples, size=array_shape)\n\n yield samples[:, _indices, cols]","def generate(model, n_samples, device, shape, levels):\n channels, height, width = shape[1], shape[2], shape[3]\n x_shapes = create_x_shapes(channels, height, width, levels)\n temperature = 0.7\n x_sample = []\n for ch, h, w in x_shapes:\n x_random = torch.randn(n_samples, ch, h, w) * temperature\n x_sample.append(x_random.to(device))\n x = model.reverse(x_sample)\n #x /= 0.6 # attempt to make it brighter, seen as rescaling it to reverse the effect of using temperature\n return x","def generate_samples(model, num_samples, latent):\n\n noise = tf.random.normal([num_samples, latent])\n samples = model(noise)[:, :, 0]\n return np.array(samples)","def data_gen(\n v: int, batch: int, nbatches: int, device: torch.device = torch.device(\"cpu\")\n) -> Iterator[Batch]: # TODO bad name\n for i in range(nbatches):\n data = np.random.randint(1, v, size=(batch, 10))\n data[:, 0] = 1\n src: LongTensorType = torch.from_numpy(data)\n tgt: LongTensorType = torch.from_numpy(data)\n src, tgt = src.to(device), tgt.to(device)\n yield Batch(src, tgt, 0)","def generate(self, num_steps):\n music = []\n with tf.variable_scope('batch_size'):\n batch_size = tf.shape(self._inputs)[0]\n\n intro_states = []\n # Generators' forward pass\n for i in range(self.num_tracks):\n with tf.variable_scope(f'inputs/{self.tracks[i]}'):\n inputs = tf.concat([self._x_encoded[i], self._x_feedback], axis=-1)\n\n with tf.variable_scope(f'intro_state/{self.tracks[i]}'):\n state = self.generators[i].steps(inputs)\n intro_states.append(state)\n\n #\n with tf.variable_scope('feedback_sampler'):\n samples_h, _, _ = tf.scan(\n self._feedback_recurrence,\n tf.zeros((num_steps, 1)),\n initializer=(\n tf.zeros((batch_size, self._num_dims_generator, self.num_tracks)),\n intro_states,\n self._feedback_final_state)\n )\n\n with tf.variable_scope('samples/encoded/'):\n samples_h = tf.unstack(tf.transpose(samples_h, [1, 0, 2, 3]), axis=-1)\n\n for i in range(self.num_tracks):\n # Decoding inputs into the original format\n with tf.variable_scope(f'samples/{self.tracks[i]}/'):\n _, samples = self.encoders[i].decode(samples_h[i])\n\n music.append(samples)\n\n with tf.variable_scope('samples/'):\n return tf.stack(music, axis=3, name='music')","def generate_fake_samples(generator_model : Model, dataset : np.ndarray, patch_shape : int) -> np.ndarray:\n X = generator_model.predict(dataset)\n y = generate_patch_labels(len(X), patch_shape, label=0)\n return X, y","def __getitem__(self, item):\n c_ex = self.examples[item]\n # randomly select ref mic\n mics = [x for x in c_ex.keys()]\n if self.train:\n np.random.shuffle(mics) # randomly permute during training to change ref mics\n\n mixtures = []\n sources = []\n for i in range(len(mics)):\n c_mic = c_ex[mics[i]]\n\n if self.segment:\n offset = 0\n if c_mic[\"length\"] > int(self.segment * self.sample_rate):\n offset = np.random.randint(\n 0, c_mic[\"length\"] - int(self.segment * self.sample_rate)\n )\n\n # we load mixture\n mixture, fs = sf.read(\n c_mic[\"mixture\"],\n start=offset,\n stop=offset + int(self.segment * self.sample_rate),\n dtype=\"float32\",\n )\n spk1, fs = sf.read(\n c_mic[\"spk1\"],\n start=offset,\n stop=offset + int(self.segment * self.sample_rate),\n dtype=\"float32\",\n )\n spk2, fs = sf.read(\n c_mic[\"spk2\"],\n start=offset,\n stop=offset + int(self.segment * self.sample_rate),\n dtype=\"float32\",\n )\n else:\n mixture, fs = sf.read(c_mic[\"mixture\"], dtype=\"float32\") # load all\n spk1, fs = sf.read(c_mic[\"spk1\"], dtype=\"float32\")\n spk2, fs = sf.read(c_mic[\"spk2\"], dtype=\"float32\")\n\n mixture = torch.from_numpy(mixture).unsqueeze(0)\n spk1 = torch.from_numpy(spk1).unsqueeze(0)\n spk2 = torch.from_numpy(spk2).unsqueeze(0)\n\n assert fs == self.sample_rate\n mixtures.append(mixture)\n sources.append(torch.cat((spk1, spk2), 0))\n\n mixtures = torch.cat(mixtures, 0)\n sources = torch.stack(sources)\n # we pad till max_mic\n valid_mics = mixtures.shape[0]\n if mixtures.shape[0] < self.max_mics:\n dummy = torch.zeros((self.max_mics - mixtures.shape[0], mixtures.shape[-1]))\n mixtures = torch.cat((mixtures, dummy), 0)\n sources = torch.cat((sources, dummy.unsqueeze(1).repeat(1, sources.shape[1], 1)), 0)\n return mixtures, sources, valid_mics","def batch_generator(batch_size, sequence_length,\n x_train_scaled, y_train_scaled, num_x_signals, num_y_signals, num_train):\n # Infinite loop.\n while True:\n # Allocate a new array for the batch of input-signals.\n x_shape = (batch_size, sequence_length, num_x_signals)\n x_batch = np.zeros(shape=x_shape, dtype=np.float16)\n\n # Allocate a new array for the batch of output-signals.\n y_shape = (batch_size, sequence_length, num_y_signals)\n y_batch = np.zeros(shape=y_shape, dtype=np.float16)\n\n # Fill the batch with random sequences of data.\n for i in range(batch_size):\n # Get a random start-index.\n # This points somewhere into the training-data.\n idx = np.random.randint(num_train - sequence_length)\n\n # Copy the sequences of data starting at this index.\n x_batch[i] = x_train_scaled[idx:idx + sequence_length]\n y_batch[i] = y_train_scaled[idx:idx + sequence_length]\n yield x_batch, y_batch\n # return x_batch, y_batch","def my_generator(batch_size, img_dir):\n cat_dirs = glob.glob(img_dir + \"/*\")\n counter = 0\n while True:\n input_images = np.zeros(\n (batch_size, config.height, config.width, 3 * 5))\n output_images = np.zeros((batch_size, config.height, config.width, 3))\n random.shuffle(cat_dirs)\n if (counter+batch_size >= len(cat_dirs)):\n counter = 0\n for i in range(batch_size):\n input_imgs = glob.glob(cat_dirs[counter + i] + \"/cat_[0-4]*\") \n imgs = [Image.open(img) for img in sorted(input_imgs)]\n input_images[i] = np.concatenate(imgs, axis=2)\n output_imgs = glob.glob(cat_dirs[counter + i] + \"/cat_[5-7]*\")\n imgs = [Image.open(img) for img in sorted(output_imgs)]\n output_images[i] = np.concatenate(imgs, axis=1)\n input_images[i] /= 255.\n output_images[i] /= 255.\n yield (input_images, output_images)\n counter += batch_size","def generate_samples(mu1,cov,number_of_samples):\n samples = np.random.multivariate_normal(mu1, cov,number_of_samples)\n return samples","def collect_data(self, cue_size=10, sigma=0.1, test_factors=[2], \n cue_offset=9*pi/8, **kwargs):\n self.results['cue_size'] = cue_size = (pi/180) * cue_size\n self.results['cue_offset'] = cue_offset\n self.results['test_factors'] = test_factors = [0, 1] + test_factors\n self.results['sigma'] = sigma\n \n # Set up model parameters\n pdict = dict( N_outputs=500, \n N_theta=1000,\n C_W=0.05,\n N_cues_local=1, \n N_cues_distal=1, \n local_cue_std=cue_size,\n cue_offset=cue_offset,\n init_random=False,\n gamma_distal=0, \n num_trials=2*len(test_factors),\n monitoring=True )\n pdict.update(kwargs)\n \n # Create the simulation object and save the cue peak (gamma)\n self.out('Running training simulation...')\n model = VMONoiseModel(**pdict)\n if 'T' in kwargs:\n model.T = kwargs['T']\n cue_gamma = model.gamma_local\n \n # Simulate the phase noise test trials without, then with, cue\n for gamma in 0.0, cue_gamma:\n model.gamma_local = gamma\n for factor in test_factors:\n model.sigma = sigma * factor\n model.advance()\n \n # Compute responses and save session data\n self.out('Computing and saving session data files...')\n sessions = VMOSession.get_session_list(model)\n VMOSession.save_session_list(sessions, os.path.join(self.datadir, 'sessions'))\n \n # Save raw simulation data file and clean up\n model.post_mortem().tofile(os.path.join(self.datadir, 'data'))\n \n # Compute population and population lap matrices and save to data directory\n self.out('Computing and saving population responses...')\n clusts = np.arange(pdict['N_outputs'])\n R = [SD.get_population_matrix(clusters=clusts, inplace=True) for SD in sessions]\n R_laps = [SD.get_population_lap_matrix(clusters=clusts, inplace=True) for SD in sessions]\n np.save(os.path.join(self.datadir, 'R_session'), np.asarray(R))\n np.save(os.path.join(self.datadir, 'R_laps'), np.asarray(R_laps))\n \n # All done!\n self.out('Good bye!')","def generator(data_dir, samples, batch_size=32):\n num_samples = len(samples)\n while 1:\n sklearn.utils.shuffle(samples)\n for offset in range(0, num_samples, batch_size):\n batch_samples = samples[offset:offset+batch_size]\n\n images = []\n measurements = []\n for batch_sample in batch_samples:\n filename = csv_log_to_image_filename(data_dir,\n batch_sample[0])\n image = cv2.imread(filename)\n if image is not None:\n images.append(image)\n measurements.append(batch_sample[1])\n else:\n print(\"File \" + filename + \" is missing.\")\n\n X_data = np.array(images)\n y_data = np.array(measurements)\n yield sklearn.utils.shuffle(X_data, y_data)","def _generate(self, **kwargs):\n self._samples = numpy.array(list(itertools.product(*self.parameter_schema.values())), dtype=object)\n super()._generate()","def cal_samples(self):\n max_omega = max(\n abs(2 * np.pi * self.u.fundamental),\n abs(2 * np.pi * self.v.fundamental),\n abs(2 * np.pi * self.w.fundamental),\n )\n max_freq = max_omega / (2 * np.pi)\n self.fake_samples_number = (\n (max_freq ** 2) * 6 * self.u.data.shape[0] / self.u.sampling_rate\n )","def _encode_samples(self, batch_size):\n return np.array(random.choices(self.data,\n [i[1] for i in self.data],\n k=batch_size))","def _get_samples(batch_shape, state_dim, transitions, sample_shape) -> np.ndarray:\n ssm, _ = StateSpaceModelBuilder(batch_shape, state_dim, transitions).build()\n\n return ssm.sample(sample_shape).numpy()","def pc_sampler(model):\n with torch.no_grad():\n # Initial sample\n x = sde.prior_sampling(shape).to(device)\n timesteps = torch.linspace(1, eps, sde.N, device=device)\n\n for i in range(sde.N):\n t = timesteps[i]\n vec_t = torch.ones(shape[0], device=t.device) * t\n x, x_mean = corrector_update_fn(x, vec_t, model=model)\n x, x_mean = predictor_update_fn(x, vec_t, model=model)\n\n return x_mean if denoise else x, sde.N * (n_steps + 1)","def signal_generator(patient_generator, frame_size=2048, samples_per_patient=1):\n for _, (signal, _) in patient_generator:\n num_segments, segment_size = signal.shape\n for _ in range(samples_per_patient):\n # randomly choose a frame that lies within the segment i.e. no zero-padding is necessary\n segment_index = np.random.randint(num_segments)\n frame_start = np.random.randint(segment_size - frame_size)\n frame_end = frame_start + frame_size\n x = signal[segment_index, frame_start:frame_end]\n x = np.expand_dims(x, axis=1) # add channel dimension\n yield x","def varying_noise_continuous_ndim_without_category(self, figure, iteration, order, total_continuous_dim, result_path):\n\n continuous_sample_points = np.linspace(-2.0, 2.0, 20)\n #a specific noise factor will be varied with 10 steps.\n\n num_points, steps = 10, len(continuous_sample_points)\n # each step has points with randomly-sampled other noise factor\n\n\n continuous_noise = []\n for _ in range(num_points):\n cur_sample = np.random.normal(size=[1, total_continuous_dim])\n continuous_noise.extend([cur_sample]*steps)\n continuous_noise = np.concatenate(continuous_noise)\n\n varying_factor = np.tile(continuous_sample_points, num_points)\n continuous_noise[:, order] = varying_factor \n continuous_noise = np.float32(continuous_noise)\n \n display_images = []\n with variable_scope.variable_scope(self.gen_scope.name, reuse = True):\n varying_data = self.generator(continuous_noise)\n\n #colors = cm.rainbow(np.linspace(0, 1, len(continuous_sample_points)))\n colors = [ ( 1/(i%steps + 1), 0, (i%steps + 1)/steps, 1) for i in range( continuous_noise.shape[0] )] #red to green\n\n scales = [ (1.1**(i%steps + 1))*10 for i in range( continuous_noise.shape[0] )]\n\n gen_data_test = self.sess.run(varying_data)\n ax1 = figure\n ax1.scatter(gen_data_test[:, 0], gen_data_test[:, 1], s=scales, c=(0, 0, 0))\n\n for i, factor in enumerate(continuous_noise[:, order]):\n ax1.annotate(str(round(factor, 2)), (gen_data_test[i, 0], gen_data_test[i, 1]), color=colors[i])","def concoct_dataset(n_per_label, feat_specs, sigma=0, shuffle=True):\n samples = dict((label, [list() for i in range(n)]) for (label,n) in enumerate(n_per_label))\n for feat_spec in feat_specs:\n for (label, breakdown) in enumerate(feat_spec):\n if shuffle: random.shuffle(samples[label])\n s = 0\n for (value, n_per_value) in enumerate(breakdown):\n if s+n_per_value > len(samples[label]): raise Exception(str(feat_spec)+' has too many samples')\n for i in range(n_per_value):\n samples[label][s+i].append(np.random.normal(value, sigma))\n s += n_per_value\n if s < len(samples[label]): raise Exception(str(feat_spec)+' has too few samples')\n print(samples)\n return [ExpressionProfile(str(i),str(label),values) for (label, value_sets) in samples.items() for (i,values) in enumerate(value_sets)]","def sample_for_inception(model, encoder, batch_size, dataloader, device):\n\n captions = []\n gen_imgs = []\n # get sample captions\n done = False\n while not done:\n for (_, labels_batch, captions_batch) in dataloader:\n captions += captions_batch\n conditional_embeddings = encoder(labels_batch.to(device), captions)\n imgs = model.sample(conditional_embeddings).cpu()\n gen_imgs.append(imgs)\n\n if len(captions) > batch_size:\n done = True\n break\n\n gen_imgs = torch.cat(gen_imgs).numpy()\n gen_imgs = np.clip(gen_imgs, 0, 1)\n return(gen_imgs)","def sample_mcd(model: 'BaseModel', data: Dict[str, torch.Tensor], n_samples: int,\n scaler: Dict[str, Union[pd.Series, xarray.Dataset]]) -> Dict[str, torch.Tensor]:\n setup = _SamplingSetup(model, data, model.cfg.head)\n\n # force model into train mode for mc_dropout:\n if setup.mc_dropout:\n model.train()\n\n # sample for different frequencies and targets:\n samples = {}\n for freq_suffix in setup.freq_suffixes:\n sample_points = []\n frequency_last_n = setup._get_frequency_last_n(freq_suffix=freq_suffix)\n\n for nth_target in range(setup.number_of_targets):\n # unbound sampling:\n def _sample_values(ids: List[int]) -> torch.Tensor:\n # The ids are used for location-specific resampling for 'truncation' in '_handle_negative_values'\n target_values = torch.zeros(len(ids), frequency_last_n, n_samples)\n for i in range(n_samples): # forward-pass for each frequency separately to guarantee independence\n prediction = model(data)\n value_buffer = prediction[f'y_hat{freq_suffix}'][:, -frequency_last_n:, 0]\n target_values[ids, -frequency_last_n:, i] = value_buffer.detach().cpu()\n return target_values\n\n ids = list(range(data[f'x_d{freq_suffix}'].shape[0]))\n values = _sample_values(ids)\n\n # bind values and add to sample_points:\n values = _handle_negative_values(setup.cfg, values, _sample_values, scaler, nth_target)\n sample_points.append(values)\n\n # add sample_points to dictionary of samples:\n freq_key = f'y_hat{freq_suffix}'\n samples.update({freq_key: torch.stack(sample_points, 2)})\n\n return samples","def generate_continuous_data_and_targets(\n n_dim,\n n_samples,\n mixing_factor=0.025,\n frac_positive=0.1):\n cov = generate_positive_semi_definite_matrix(n_dim)\n X = np.random.multivariate_normal(\n mean=np.zeros(n_dim),\n cov=cov,\n size=n_samples)\n weights = np.random.randn(n_dim)\n y_probs = sigmoid(mixing_factor * np.dot(X, weights))\n y = np.random.binomial(1, p=y_probs)\n X, y = subsample(X, y, frac_positive)\n return X, y","def trainCartGenerator(self,):\n return tf.data.Dataset.from_generator(self.trainDataCart, \\\n output_types=(tf.float32, tf.float32, tf.float32), \\\n output_shapes=(tf.TensorShape(self.config_model[\"input_shape\"]), \\\n tf.TensorShape(list(self.cart_shape[1:3]) + \\\n [len(self.anchor_boxes_cart)] + \\\n [len(self.config_data[\"all_classes\"]) + 5]), \n tf.TensorShape([self.config_data[\"max_boxes_per_frame\"], 5]) \\\n ), )","def generate_batch(self, batch_size=8, shuffle=True):\n if self._contour_dicom_folder:\n contour_files = glob(os.path.join(self._contour_dicom_folder, \"*.h5\"))\n if shuffle:\n contour_files = np.random.permutation(contour_files)\n contours_generator = self._contour_folder_gen(contour_files)\n else:\n contours_generator = self._contour_dicom_generator\n\n x_batch, y_batch, sources_batch = [], [], []\n batch_idx = 0\n for idx, (dataset, sources) in enumerate(contours_generator):\n if batch_idx > 0 and batch_idx % batch_size == 0:\n if self._include_sources:\n yield sources_batch, np.array(x_batch), np.array(y_batch)\n else:\n yield np.array(x_batch), np.array(y_batch)\n x_batch, y_batch, sources_batch = [], [], []\n batch_idx = 0\n try:\n x_data = self._parse_channels(dataset, self.x_channels)\n y_data = self._parse_channels(dataset, self.y_channels)\n x_batch.append(x_data)\n y_batch.append(y_data)\n sources_batch.append(sources)\n batch_idx += 1\n except ValueError:\n # Log Error\n err_msg = \"Missing all channels in {}\".format(sources[\"filename\"])\n self._log_error(err_msg)\n\n if self._include_sources:\n yield sources_batch, np.array(x_batch), np.array(y_batch)\n else:\n yield np.array(x_batch), np.array(y_batch)","def generate_train_data(comps: List[pd.DataFrame], concen_upper_bound=1000, num_per_combination=1000):\n cps = [to_int_index(c) for c in comps]\n cps = [zero_end_interpolation(c) for c in comps]\n cps = alignment(cps)\n cps = [scale_dataframe(c) for c in cps]\n\n samples = []\n for n_class in range(1, len(cps) + 1):\n comps_roller = ComponentRoller(cps, n_class)\n concen_roller = ConcentrationRoller(1, concen_upper_bound, n_class)\n for i in range(num_per_combination):\n picked_comps, label = comps_roller.roll()\n concen_vector = concen_roller.roll_unique(label)\n the_sample = pd.Series(name=label, data=np.sum(picked_comps * concen_vector, axis=1))\n samples.append(the_sample)\n if i % 100 == 0:\n print('组合数{}: 第{}个样本 --- 标签{}，浓度比{}'.format(n_class, i, label, concen_vector))\n df = pd.concat(samples, axis=1)\n return df.values.T, np.array(_to_vectors(df.columns.tolist()))","def testCartGenerator(self,):\n return tf.data.Dataset.from_generator(self.testDataCart, \\\n output_types=(tf.float32, tf.float32, tf.float32), \\\n output_shapes=(tf.TensorShape(self.config_model[\"input_shape\"]), \\\n tf.TensorShape(list(self.cart_shape[1:3]) + \\\n [len(self.anchor_boxes_cart)] + \\\n [len(self.config_data[\"all_classes\"]) + 5]), \n tf.TensorShape([self.config_data[\"max_boxes_per_frame\"], 5]) \\\n ), )","def sample(self, batchsize, *args, **kwargs):\n raise NotImplementedError","def RandomDataloader(num_batches,\n batch_size,\n seq_width,\n min_len,\n max_len):\n for batch_num in range(num_batches):\n\n # All batches have the same sequence length\n seq_len = random.randint(min_len, max_len)\n seq = np.random.binomial(1, 0.5, (seq_len, batch_size, seq_width))\n seq = torch.from_numpy(seq)\n\n # The input includes an additional channel used for the delimiter\n inp = torch.zeros(seq_len + 1, batch_size, seq_width + 1)\n inp[:seq_len, :, :seq_width] = seq\n inp[seq_len, :, seq_width] = 1.0 # delimiter in our control channel\n outp = seq.clone()\n\n yield inp.float(), outp.float()","def next_sample(self, batch_size=1):\n\n X = []\n y = []\n\n for count in range(batch_size):\n #check for abrupt drift\n if count % self.abrupt_drift_rate == 0:\n dimfaks = [round(np.random.rand() * 4, 1) for _ in range(self.dims)]\n dimpots = [1 + round(np.random.rand() * 2) for _ in range(self.dims)]\n dimvars = [np.random.rand() * self.var for _ in range(self.dims)]\n dimmeans = [5 + np.random.rand() * 10 for _ in range(self.dims)]\n print(\"Random Polynomconcept: \", end=\"\")\n for i in range(self.dims):\n print(dimfaks[i],\" * x\", i+1, \"^\", dimpots[i], \" + \",end=\"\", sep=\"\")\n print()\n\n value = 0\n sample = []\n for i in range(self.dims):\n sample.append(np.random.normal(loc=dimmeans[i], scale=dimvars[i]))\n value += dimfaks[i] * (sample[i] ** dimpots[i])\n \n X.append(sample)\n y.append(value)\n\n self._x_idx += batch_size\n\n return (X, y)","def get_data(self):\n if self.random_seeds: \n self._validate_random_seeds()\n seed_iter = list(map(iter,self.random_seeds))\n nsamples = len(self.random_seeds[0])\n else:\n seed_iter = None\n nsamples = self.numsamples\n self._set_meta_features()\n for _ in tqdm(range(nsamples)):\n self._update_meta_features(seed_iter)\n self._sample()\n yield self._extract_features()","def makegenerators(self, adata, val_split, batch_size, splitseed):\n \n return countloader(adata.obsm[self.embed_name], adata.X[:, adata.var['Variance Type'] == self.mode], adata.obs['size factors'], \n val_split, batch_size, splitseed)","def next_simple_dataset(dataset, batch_size: int, datatype):\n while True:\n x_batch = []\n y_batch = []\n for i in range(batch_size):\n try:\n x, y, data_unit, index = create_xy(dataset, datatype)\n # x = normalize(x)\n x_batch.append(x)\n y_batch.append(y)\n except StopIteration:\n break\n x_batch, y_batch = np.array(x_batch), np.array(y_batch)\n if datatype != DataType.test:\n x_batch = SEQ_CVXTZ.augment_images(x_batch).astype(\"float32\")\n x_batch = np.array([normalize(x) for x in x_batch])\n # org_shape = x_batch.shape\n # org_width = x_batch.shape[1]\n # corner = int((org_width - ROI_IMAGE_SIZE) // 2)\n # print(f\"0: org_shape:{org_shape} x_batch:{x_batch.shape} corner:{corner}\")\n # x_batch = x_batch[:, corner:(org_width - corner), corner:(org_width - corner), :]\n # resized_x_batch = []\n # for x in x_batch:\n # img = Image.fromarray(np.uint8(x))\n # img = img.resize((IMAGE_SIZE, IMAGE_SIZE), Image.LANCZOS)\n # resized_x_batch.append(normalize(np.array(img)))\n # print(f\"1: org_shape:{org_shape} corner:{corner} x_batch:{x_batch.shape}\")\n # yield np.array(resized_x_batch), y_batch\n yield np.array(x_batch), y_batch","def data_source():\n dataset = [0.1, 0.2, 0.3, 0.4, 0.5]\n while True:\n time.sleep(2)\n yield random.choice(dataset)","def crop_generator(batches, crop_length):\n while True:\n batch_x, batch_y = next(batches)\n batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\n for i in range(batch_x.shape[0]):\n batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\n yield (batch_crops, batch_y)","def data_generator(batch_size, preprocessor, x, y):\n num_examples = len(x)\n examples = zip(x, y)\n examples = sorted(examples, key = lambda x: x[0].shape[0])\n end = num_examples - batch_size + 1\n batches = [examples[i:i+batch_size]\n for i in range(0, end, batch_size)]\n random.shuffle(batches)\n while True:\n for batch in batches:\n x, y = zip(*batch)\n yield preprocessor.process(x, y)","def batchwise_sample(gen, num_samples, batch_size):\n\n samples = []\n for i in range(int(ceil(num_samples/float(batch_size)))):\n samples.append(gen.sample(batch_size))\n\n return torch.cat(samples, 0)[:num_samples]","def corun(self, step:int=0):\n if step > 0:\n _range = range(self.current_step, self.current_step + step + 1)\n else: # run forever\n _range = itertools.count(self.current_step)\n for step_num in _range:\n self.config_template = (yield self.step()) or self.config_template","def sample(self, batch_size):\n raise NotImplementedError","def get_samples(self) -> McmcPtResult:","def _iterate_steps(self):\n mixture_size = self.parameters['fixed_mixture_size']\n if mixture_size is None:\n return 2 ** self.Ns\n else:\n return scipy.special.comb(self.Ns, mixture_size, exact=True)","def get_tf_dataset(bs=32,sample_type=\"mixed\"):\n train_ds = tf.data.Dataset.from_generator(\n lambda :gen(split=\"train\",sample_type=sample_type),\n (tf.float32,tf.float32),\n ((SEQ_LEN,SEQ_LEN,3),(2)))\n train_ds = train_ds.batch(bs,drop_remainder=True)\n\n val_ds = tf.data.Dataset.from_generator(\n lambda :gen(split=\"val\",sample_type=sample_type),\n (tf.float32,tf.float32),\n ((SEQ_LEN,SEQ_LEN,3),(2)))\n val_ds = val_ds.batch(bs,drop_remainder=True)\n return train_ds,val_ds","def generate(self, batch_size: int = 1) -> torch.Tensor:\n z = self.prior.sample((batch_size, self.latent_size))\n recon_mu, recon_sigma = self.decoder(z).chunk(2, dim=1)\n recon_sigma = softplus(recon_sigma)\n return recon_mu + recon_sigma * torch.rand_like(recon_sigma)","def get_volume_batch_generators(self):\n # volgeninfo = []\n def create_volgen(shape, w, padding, features, masks):\n w = np.asarray(w)\n padding = np.asarray(padding)\n W = w - padding * 2\n iters = np.int32(np.ceil((np.asarray([s for s in shape if s > 1]) + padding) * 1.0 / (W + padding)))\n for counts in counter_generator(iters):\n start = -padding + (w - padding) * counts\n end = (w - padding) * (counts + 1)\n subf, subm = self._extract_sample(features, masks, copy.deepcopy(start), copy.deepcopy(end), shape)\n ma = np.asarray([subm])\n fe = np.asarray([subf])\n if self.channels_first:\n ndims = len(fe.shape)\n neworder = [0, ndims - 1] + [i for i in range(1, ndims - 1)]\n fe = np.transpose(fe, neworder)\n ma = np.transpose(ma, neworder)\n yield fe, ma, start, end\n\n def volgeninfo(tps):\n for tp in tps:\n features, masks = self._get_features_and_masks(tp)\n spatial_shape = np.shape(features[0])\n volgen = create_volgen(spatial_shape, self.w, self.p, features, masks)\n yield [volgen, tp, spatial_shape, self.w, self.p]\n\n return volgeninfo(self.tps)","def generate_bootstrap_samples(num_samples, test_universe, test_set_sizes):\n for sample_idx, sample_size in zip(range(num_samples), cycle(test_set_sizes)):\n yield random.sample(test_universe, sample_size)","def get_batch_gen(self, config):\n\n ################\n # Def generators\n ################\n\n def random_balanced_gen():\n print('trying to generate batch series with ', self.num_train, 'shapes')\n\n # Initiate concatenation lists\n tp_list = [] # points\n tev_list = [] # eigen vectors\n tevt_list = [] # transposed eigen vectors\n tv_list = [] # eigen values\n tevf_list = [] # full eigen vectors for ground truth maps\n ti_list = [] # cloud indices\n\n batch_n = 0\n i_batch = 0\n\n gen_indices = np.random.permutation(int(self.num_train)) # initiate indices for the generator\n # if we had to test on this dataset we would need to introduce a test/val case with non-shuffled indices\n # print(gen_indices.shape, config.batch_num)\n # if config.split == 'test':\n # print('test setting here not fully supported')\n # n_shapes = self.num_test # has to be defined\n # gen_indices = []\n # for i in range(n_shapes - 1):\n # for j in range(i + 1, n_shapes):\n # gen_indices += [i, j] # put all the pairs in order\n # gen_indices = np.array(gen_indices)\n\n\n # Generator loop\n for p_i in gen_indices:\n\n # Get points and other input data\n new_points = self.input_points[p_i]\n new_evecs = self.input_evecs[p_i][:, :self.neig]\n new_evecs_trans = self.input_evecs_trans[p_i][:self.neig, :]\n new_evals = self.input_evals[p_i][:self.neig]\n\n new_evecs_full = self.input_evecs_full[p_i][:, :self.neig]\n\n n = new_points.shape[0]\n\n if i_batch == config.batch_num:\n\n yield (np.concatenate(tp_list, axis=0),\n np.concatenate(tev_list, axis=0),\n np.concatenate(tevt_list, axis=1),\n np.concatenate(tv_list, axis=1),\n np.concatenate(tevf_list, axis=0),\n np.array(ti_list, dtype=np.int32),\n np.array([tp.shape[0] for tp in tp_list]))\n\n tp_list = []\n tev_list = []\n tevt_list = []\n tv_list = []\n tevf_list = []\n ti_list = []\n\n batch_n = 0\n i_batch = 0\n\n # Add data to current batch\n tp_list += [new_points]\n tev_list += [new_evecs]\n tevt_list += [new_evecs_trans]\n tv_list += [new_evals]\n tevf_list += [new_evecs_full]\n ti_list += [p_i]\n\n # Update batch size\n batch_n += n\n i_batch += 1\n\n # yield the rest if necessary (it will not be a full batch and could lead to mistakes because of\n # shape matching needing pairs !!!!)\n yield (np.concatenate(tp_list, axis=0),\n np.concatenate(tev_list, axis=0),\n np.concatenate(tevt_list, axis=1),\n np.concatenate(tv_list, axis=1),\n np.concatenate(tevf_list, axis=0),\n np.array(ti_list, dtype=np.int32),\n np.array([tp.shape[0] for tp in tp_list]))\n\n ##################\n # Return generator\n ##################\n\n # Generator types and shapes\n gen_types = (tf.float32, tf.float32, tf.float32, tf.float32, tf.float32, tf.int32, tf.int32)\n gen_shapes = ([None, 3], [None, self.neig],\n [self.neig, None], [self.neig, None], [None, self.neig], [None], [None])\n\n return random_balanced_gen, gen_types, gen_shapes","def batch_train_generator(self, X, batch_size, seq_len):\n startidx = np.random.randint(0, len(X) - seq_len, batch_size)\n while True:\n batch_X = np.array([X[start:start + seq_len]\n for start in startidx])\n batch_y = np.array(\n [X[start:start + seq_len + self.config.shift] for start in startidx])\n batch_y = batch_y[:, -1]\n startidx = (startidx + seq_len) % (len(X) - seq_len)\n yield batch_X.reshape(batch_size, seq_len, 1), batch_y.reshape(batch_size, 1)","def build_sequences(dcm):\n dimension_organization_uid = '1.2.276.0.7230010.3.1.4.8323329.20175.1573232544.237437'\n ds0 = Dataset()\n ds0.DimensionOrganizationUID = dimension_organization_uid\n dcm.DimensionOrganizationSequence = Sequence([ds0])\n del ds0\n\n ds1 = Dataset()\n ds1.DimensionOrganizationUID = dimension_organization_uid\n ds1.DimensionIndexPointer = Tag(0x0048021E)\n ds1.FunctionalGroupPointer = Tag(0x0048021A)\n\n ds2 = Dataset()\n ds2.DimensionOrganizationUID = dimension_organization_uid\n ds2.DimensionIndexPointer = Tag(0x0048021F)\n ds2.FunctionalGroupPointer = Tag(0x0048021A)\n\n dcm.DimensionIndexSequence = Sequence([ds1, ds2])\n del ds1, ds2\n\n ds3 = Dataset()\n ds3.XOffsetInSlideCoordinateSystem = 20\n ds3.YOffsetInSlideCoordinateSystem = 40\n dcm.TotalPixelMatrixOriginSequence = Sequence([ds3])\n del ds3\n\n ds4 = Dataset()\n ds5 = Dataset()\n\n # IlluminationTypeCodeSequence\n ds4.CodingSchemeDesignator = 'DCM'\n ds4.CodeMeaning = 'Brightfield illumination'\n ds4.CodeValue = '111744'\n\n # IlluminationColorCodeSequence\n ds5.CodingSchemeDesignator = 'DCM'\n ds5.CodeMeaning = 'No filter'\n ds5.CodeValue = '111609'\n\n ds7 = Dataset()\n ds7.IlluminationTypeCodeSequence = Sequence([ds4])\n ds7.IlluminationColorCodeSequence = Sequence([ds5])\n # noinspection PyPep8,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection\n ds7.ICCProfile = b'\\x00\\x00\\x1b\\nlcms\\x020\\x00\\x00mntrRGB XYZ \\x07\\xd4\\x00\\x08\\x00\\r\\x00\\x0c\\x00\\x12\\x00\\x06acspMSFT\\x00\\x00\\x00\\x00lcms\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\xf6\\xd6\\x00\\x01\\x00\\x00\\x00\\x00\\xd3-lcms\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x0cdmnd\\x00\\x00\\x01\\x14\\x00\\x00\\x00jdesc\\x00\\x00\\x01\\x80\\x00\\x00\\x00hdmdd\\x00\\x00\\x01\\xe8\\x00\\x00\\x00hwtpt\\x00\\x00\\x02P\\x00\\x00\\x00\\x14rXYZ\\x00\\x00\\x02d\\x00\\x00\\x00\\x14bXYZ\\x00\\x00\\x02x\\x00\\x00\\x00\\x14gXYZ\\x00\\x00\\x02\\x8c\\x00\\x00\\x00\\x14rTRC\\x00\\x00\\x02\\xa0\\x00\\x00\\x08\\x0cgTRC\\x00\\x00\\n\\xac\\x00\\x00\\x08\\x0cbTRC\\x00\\x00\\x12\\xb8\\x00\\x00\\x08\\x0cchrm\\x00\\x00\\x1a\\xc4\\x00\\x00\\x00$cprt\\x00\\x00\\x1a\\xe8\\x00\\x00\\x00!desc\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x10lcms generated \\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00desc\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x05sRGB\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00desc\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x05sRGB\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00XYZ \\x00\\x00\\x00\\x00\\x00\\x00\\xf3=\\x00\\x01\\x00\\x00\\x00\\x01\\x16\\x98XYZ \\x00\\x00\\x00\\x00\\x00\\x00o\\x94\\x00\\x008\\xee\\x00\\x00\\x03\\x90XYZ \\x00\\x00\\x00\\x00\\x00\\x00$\\x9d\\x00\\x00\\x0f\\x83\\x00\\x00\\xb6\\xbeXYZ \\x00\\x00\\x00\\x00\\x00\\x00b\\xa5\\x00\\x00\\xb7\\x90\\x00\\x00\\x18\\xdecurv\\x00\\x00\\x00\\x00\\x00\\x00\\x04\\x00\\x00\\x00\\x00\\x05\\x00\\n\\x00\\x0f\\x00\\x14\\x00\\x19\\x00\\x1e\\x00#\\x00(\\x00-\\x002\\x007\\x00;\\x00@\\x00E\\x00J\\x00O\\x00T\\x00Y\\x00^\\x00c\\x00h\\x00m\\x00r\\x00w\\x00|\\x00\\x81\\x00\\x86\\x00\\x8b\\x00\\x90\\x00\\x95\\x00\\x9a\\x00\\x9f\\x00\\xa4\\x00\\xa9\\x00\\xae\\x00\\xb2\\x00\\xb7\\x00\\xbc\\x00\\xc1\\x00\\xc6\\x00\\xcb\\x00\\xd0\\x00\\xd5\\x00\\xdb\\x00\\xe0\\x00\\xe5\\x00\\xeb\\x00\\xf0\\x00\\xf6\\x00\\xfb\\x01\\x01\\x01\\x07\\x01\\r\\x01\\x13\\x01\\x19\\x01\\x1f\\x01%\\x01+\\x012\\x018\\x01>\\x01E\\x01L\\x01R\\x01Y\\x01`\\x01g\\x01n\\x01u\\x01|\\x01\\x83\\x01\\x8b\\x01\\x92\\x01\\x9a\\x01\\xa1\\x01\\xa9\\x01\\xb1\\x01\\xb9\\x01\\xc1\\x01\\xc9\\x01\\xd1\\x01\\xd9\\x01\\xe1\\x01\\xe9\\x01\\xf2\\x01\\xfa\\x02\\x03\\x02\\x0c\\x02\\x14\\x02\\x1d\\x02&\\x02/\\x028\\x02A\\x02K\\x02T\\x02]\\x02g\\x02q\\x02z\\x02\\x84\\x02\\x8e\\x02\\x98\\x02\\xa2\\x02\\xac\\x02\\xb6\\x02\\xc1\\x02\\xcb\\x02\\xd5\\x02\\xe0\\x02\\xeb\\x02\\xf5\\x03\\x00\\x03\\x0b\\x03\\x16\\x03!\\x03-\\x038\\x03C\\x03O\\x03Z\\x03f\\x03r\\x03~\\x03\\x8a\\x03\\x96\\x03\\xa2\\x03\\xae\\x03\\xba\\x03\\xc7\\x03\\xd3\\x03\\xe0\\x03\\xec\\x03\\xf9\\x04\\x06\\x04\\x13\\x04 \\x04-\\x04;\\x04H\\x04U\\x04c\\x04q\\x04~\\x04\\x8c\\x04\\x9a\\x04\\xa8\\x04\\xb6\\x04\\xc4\\x04\\xd3\\x04\\xe1\\x04\\xf0\\x04\\xfe\\x05\\r\\x05\\x1c\\x05+\\x05:\\x05I\\x05X\\x05g\\x05w\\x05\\x86\\x05\\x96\\x05\\xa6\\x05\\xb5\\x05\\xc5\\x05\\xd5\\x05\\xe5\\x05\\xf6\\x06\\x06\\x06\\x16\\x06\\'\\x067\\x06H\\x06Y\\x06j\\x06{\\x06\\x8c\\x06\\x9d\\x06\\xaf\\x06\\xc0\\x06\\xd1\\x06\\xe3\\x06\\xf5\\x07\\x07\\x07\\x19\\x07+\\x07=\\x07O\\x07a\\x07t\\x07\\x86\\x07\\x99\\x07\\xac\\x07\\xbf\\x07\\xd2\\x07\\xe5\\x07\\xf8\\x08\\x0b\\x08\\x1f\\x082\\x08F\\x08Z\\x08n\\x08\\x82\\x08\\x96\\x08\\xaa\\x08\\xbe\\x08\\xd2\\x08\\xe7\\x08\\xfb\\t\\x10\\t%\\t:\\tO\\td\\ty\\t\\x8f\\t\\xa4\\t\\xba\\t\\xcf\\t\\xe5\\t\\xfb\\n\\x11\\n\\'\\n=\\nT\\nj\\n\\x81\\n\\x98\\n\\xae\\n\\xc5\\n\\xdc\\n\\xf3\\x0b\\x0b\\x0b\"\\x0b9\\x0bQ\\x0bi\\x0b\\x80\\x0b\\x98\\x0b\\xb0\\x0b\\xc8\\x0b\\xe1\\x0b\\xf9\\x0c\\x12\\x0c*\\x0cC\\x0c\\\\\\x0cu\\x0c\\x8e\\x0c\\xa7\\x0c\\xc0\\x0c\\xd9\\x0c\\xf3\\r\\r\\r&\\r@\\rZ\\rt\\r\\x8e\\r\\xa9\\r\\xc3\\r\\xde\\r\\xf8\\x0e\\x13\\x0e.\\x0eI\\x0ed\\x0e\\x7f\\x0e\\x9b\\x0e\\xb6\\x0e\\xd2\\x0e\\xee\\x0f\\t\\x0f%\\x0fA\\x0f^\\x0fz\\x0f\\x96\\x0f\\xb3\\x0f\\xcf\\x0f\\xec\\x10\\t\\x10&\\x10C\\x10a\\x10~\\x10\\x9b\\x10\\xb9\\x10\\xd7\\x10\\xf5\\x11\\x13\\x111\\x11O\\x11m\\x11\\x8c\\x11\\xaa\\x11\\xc9\\x11\\xe8\\x12\\x07\\x12&\\x12E\\x12d\\x12\\x84\\x12\\xa3\\x12\\xc3\\x12\\xe3\\x13\\x03\\x13#\\x13C\\x13c\\x13\\x83\\x13\\xa4\\x13\\xc5\\x13\\xe5\\x14\\x06\\x14\\'\\x14I\\x14j\\x14\\x8b\\x14\\xad\\x14\\xce\\x14\\xf0\\x15\\x12\\x154\\x15V\\x15x\\x15\\x9b\\x15\\xbd\\x15\\xe0\\x16\\x03\\x16&\\x16I\\x16l\\x16\\x8f\\x16\\xb2\\x16\\xd6\\x16\\xfa\\x17\\x1d\\x17A\\x17e\\x17\\x89\\x17\\xae\\x17\\xd2\\x17\\xf7\\x18\\x1b\\x18@\\x18e\\x18\\x8a\\x18\\xaf\\x18\\xd5\\x18\\xfa\\x19 \\x19E\\x19k\\x19\\x91\\x19\\xb7\\x19\\xdd\\x1a\\x04\\x1a*\\x1aQ\\x1aw\\x1a\\x9e\\x1a\\xc5\\x1a\\xec\\x1b\\x14\\x1b;\\x1bc\\x1b\\x8a\\x1b\\xb2\\x1b\\xda\\x1c\\x02\\x1c*\\x1cR\\x1c{\\x1c\\xa3\\x1c\\xcc\\x1c\\xf5\\x1d\\x1e\\x1dG\\x1dp\\x1d\\x99\\x1d\\xc3\\x1d\\xec\\x1e\\x16\\x1e@\\x1ej\\x1e\\x94\\x1e\\xbe\\x1e\\xe9\\x1f\\x13\\x1f>\\x1fi\\x1f\\x94\\x1f\\xbf\\x1f\\xea \\x15 A l \\x98 \\xc4 \\xf0!\\x1c!H!u!\\xa1!\\xce!\\xfb\"\\'\"U\"\\x82\"\\xaf\"\\xdd#\\n#8#f#\\x94#\\xc2#\\xf0$\\x1f$M$|$\\xab$\\xda%\\t%8%h%\\x97%\\xc7%\\xf7&\\'&W&\\x87&\\xb7&\\xe8\\'\\x18\\'I\\'z\\'\\xab\\'\\xdc(\\r(?(q(\\xa2(\\xd4)\\x06)8)k)\\x9d)\\xd0*\\x02*5*h*\\x9b*\\xcf+\\x02+6+i+\\x9d+\\xd1,\\x05,9,n,\\xa2,\\xd7-\\x0c-A-v-\\xab-\\xe1.\\x16.L.\\x82.\\xb7.\\xee/$/Z/\\x91/\\xc7/\\xfe050l0\\xa40\\xdb1\\x121J1\\x821\\xba1\\xf22*2c2\\x9b2\\xd43\\r3F3\\x7f3\\xb83\\xf14+4e4\\x9e4\\xd85\\x135M5\\x875\\xc25\\xfd676r6\\xae6\\xe97$7`7\\x9c7\\xd78\\x148P8\\x8c8\\xc89\\x059B9\\x7f9\\xbc9\\xf9:6:t:\\xb2:\\xef;-;k;\\xaa;\\xe8<\\'<e<\\xa4<\\xe3=\"=a=\\xa1=\\xe0> >`>\\xa0>\\xe0?!?a?\\xa2?\\xe2@#@d@\\xa6@\\xe7A)AjA\\xacA\\xeeB0BrB\\xb5B\\xf7C:C}C\\xc0D\\x03DGD\\x8aD\\xceE\\x12EUE\\x9aE\\xdeF\"FgF\\xabF\\xf0G5G{G\\xc0H\\x05HKH\\x91H\\xd7I\\x1dIcI\\xa9I\\xf0J7J}J\\xc4K\\x0cKSK\\x9aK\\xe2L*LrL\\xbaM\\x02MJM\\x93M\\xdcN%NnN\\xb7O\\x00OIO\\x93O\\xddP\\'PqP\\xbbQ\\x06QPQ\\x9bQ\\xe6R1R|R\\xc7S\\x13S_S\\xaaS\\xf6TBT\\x8fT\\xdbU(UuU\\xc2V\\x0fV\\\\V\\xa9V\\xf7WDW\\x92W\\xe0X/X}X\\xcbY\\x1aYiY\\xb8Z\\x07ZVZ\\xa6Z\\xf5[E[\\x95[\\xe5\\\\5\\\\\\x86\\\\\\xd6]\\']x]\\xc9^\\x1a^l^\\xbd_\\x0f_a_\\xb3`\\x05`W`\\xaa`\\xfcaOa\\xa2a\\xf5bIb\\x9cb\\xf0cCc\\x97c\\xebd@d\\x94d\\xe9e=e\\x92e\\xe7f=f\\x92f\\xe8g=g\\x93g\\xe9h?h\\x96h\\xeciCi\\x9ai\\xf1jHj\\x9fj\\xf7kOk\\xa7k\\xfflWl\\xafm\\x08m`m\\xb9n\\x12nkn\\xc4o\\x1eoxo\\xd1p+p\\x86p\\xe0q:q\\x95q\\xf0rKr\\xa6s\\x01s]s\\xb8t\\x14tpt\\xccu(u\\x85u\\xe1v>v\\x9bv\\xf8wVw\\xb3x\\x11xnx\\xccy*y\\x89y\\xe7zFz\\xa5{\\x04{c{\\xc2|!|\\x81|\\xe1}A}\\xa1~\\x01~b~\\xc2\\x7f#\\x7f\\x84\\x7f\\xe5\\x80G\\x80\\xa8\\x81\\n\\x81k\\x81\\xcd\\x820\\x82\\x92\\x82\\xf4\\x83W\\x83\\xba\\x84\\x1d\\x84\\x80\\x84\\xe3\\x85G\\x85\\xab\\x86\\x0e\\x86r\\x86\\xd7\\x87;\\x87\\x9f\\x88\\x04\\x88i\\x88\\xce\\x893\\x89\\x99\\x89\\xfe\\x8ad\\x8a\\xca\\x8b0\\x8b\\x96\\x8b\\xfc\\x8cc\\x8c\\xca\\x8d1\\x8d\\x98\\x8d\\xff\\x8ef\\x8e\\xce\\x8f6\\x8f\\x9e\\x90\\x06\\x90n\\x90\\xd6\\x91?\\x91\\xa8\\x92\\x11\\x92z\\x92\\xe3\\x93M\\x93\\xb6\\x94 \\x94\\x8a\\x94\\xf4\\x95_\\x95\\xc9\\x964\\x96\\x9f\\x97\\n\\x97u\\x97\\xe0\\x98L\\x98\\xb8\\x99$\\x99\\x90\\x99\\xfc\\x9ah\\x9a\\xd5\\x9bB\\x9b\\xaf\\x9c\\x1c\\x9c\\x89\\x9c\\xf7\\x9dd\\x9d\\xd2\\x9e@\\x9e\\xae\\x9f\\x1d\\x9f\\x8b\\x9f\\xfa\\xa0i\\xa0\\xd8\\xa1G\\xa1\\xb6\\xa2&\\xa2\\x96\\xa3\\x06\\xa3v\\xa3\\xe6\\xa4V\\xa4\\xc7\\xa58\\xa5\\xa9\\xa6\\x1a\\xa6\\x8b\\xa6\\xfd\\xa7n\\xa7\\xe0\\xa8R\\xa8\\xc4\\xa97\\xa9\\xa9\\xaa\\x1c\\xaa\\x8f\\xab\\x02\\xabu\\xab\\xe9\\xac\\\\\\xac\\xd0\\xadD\\xad\\xb8\\xae-\\xae\\xa1\\xaf\\x16\\xaf\\x8b\\xb0\\x00\\xb0u\\xb0\\xea\\xb1`\\xb1\\xd6\\xb2K\\xb2\\xc2\\xb38\\xb3\\xae\\xb4%\\xb4\\x9c\\xb5\\x13\\xb5\\x8a\\xb6\\x01\\xb6y\\xb6\\xf0\\xb7h\\xb7\\xe0\\xb8Y\\xb8\\xd1\\xb9J\\xb9\\xc2\\xba;\\xba\\xb5\\xbb.\\xbb\\xa7\\xbc!\\xbc\\x9b\\xbd\\x15\\xbd\\x8f\\xbe\\n\\xbe\\x84\\xbe\\xff\\xbfz\\xbf\\xf5\\xc0p\\xc0\\xec\\xc1g\\xc1\\xe3\\xc2_\\xc2\\xdb\\xc3X\\xc3\\xd4\\xc4Q\\xc4\\xce\\xc5K\\xc5\\xc8\\xc6F\\xc6\\xc3\\xc7A\\xc7\\xbf\\xc8=\\xc8\\xbc\\xc9:\\xc9\\xb9\\xca8\\xca\\xb7\\xcb6\\xcb\\xb6\\xcc5\\xcc\\xb5\\xcd5\\xcd\\xb5\\xce6\\xce\\xb6\\xcf7\\xcf\\xb8\\xd09\\xd0\\xba\\xd1<\\xd1\\xbe\\xd2?\\xd2\\xc1\\xd3D\\xd3\\xc6\\xd4I\\xd4\\xcb\\xd5N\\xd5\\xd1\\xd6U\\xd6\\xd8\\xd7\\\\\\xd7\\xe0\\xd8d\\xd8\\xe8\\xd9l\\xd9\\xf1\\xdav\\xda\\xfb\\xdb\\x80\\xdc\\x05\\xdc\\x8a\\xdd\\x10\\xdd\\x96\\xde\\x1c\\xde\\xa2\\xdf)\\xdf\\xaf\\xe06\\xe0\\xbd\\xe1D\\xe1\\xcc\\xe2S\\xe2\\xdb\\xe3c\\xe3\\xeb\\xe4s\\xe4\\xfc\\xe5\\x84\\xe6\\r\\xe6\\x96\\xe7\\x1f\\xe7\\xa9\\xe82\\xe8\\xbc\\xe9F\\xe9\\xd0\\xea[\\xea\\xe5\\xebp\\xeb\\xfb\\xec\\x86\\xed\\x11\\xed\\x9c\\xee(\\xee\\xb4\\xef@\\xef\\xcc\\xf0X\\xf0\\xe5\\xf1r\\xf1\\xff\\xf2\\x8c\\xf3\\x19\\xf3\\xa7\\xf44\\xf4\\xc2\\xf5P\\xf5\\xde\\xf6m\\xf6\\xfb\\xf7\\x8a\\xf8\\x19\\xf8\\xa8\\xf98\\xf9\\xc7\\xfaW\\xfa\\xe7\\xfbw\\xfc\\x07\\xfc\\x98\\xfd)\\xfd\\xba\\xfeK\\xfe\\xdc\\xffm\\xff\\xffcurv\\x00\\x00\\x00\\x00\\x00\\x00\\x04\\x00\\x00\\x00\\x00\\x05\\x00\\n\\x00\\x0f\\x00\\x14\\x00\\x19\\x00\\x1e\\x00#\\x00(\\x00-\\x002\\x007\\x00;\\x00@\\x00E\\x00J\\x00O\\x00T\\x00Y\\x00^\\x00c\\x00h\\x00m\\x00r\\x00w\\x00|\\x00\\x81\\x00\\x86\\x00\\x8b\\x00\\x90\\x00\\x95\\x00\\x9a\\x00\\x9f\\x00\\xa4\\x00\\xa9\\x00\\xae\\x00\\xb2\\x00\\xb7\\x00\\xbc\\x00\\xc1\\x00\\xc6\\x00\\xcb\\x00\\xd0\\x00\\xd5\\x00\\xdb\\x00\\xe0\\x00\\xe5\\x00\\xeb\\x00\\xf0\\x00\\xf6\\x00\\xfb\\x01\\x01\\x01\\x07\\x01\\r\\x01\\x13\\x01\\x19\\x01\\x1f\\x01%\\x01+\\x012\\x018\\x01>\\x01E\\x01L\\x01R\\x01Y\\x01`\\x01g\\x01n\\x01u\\x01|\\x01\\x83\\x01\\x8b\\x01\\x92\\x01\\x9a\\x01\\xa1\\x01\\xa9\\x01\\xb1\\x01\\xb9\\x01\\xc1\\x01\\xc9\\x01\\xd1\\x01\\xd9\\x01\\xe1\\x01\\xe9\\x01\\xf2\\x01\\xfa\\x02\\x03\\x02\\x0c\\x02\\x14\\x02\\x1d\\x02&\\x02/\\x028\\x02A\\x02K\\x02T\\x02]\\x02g\\x02q\\x02z\\x02\\x84\\x02\\x8e\\x02\\x98\\x02\\xa2\\x02\\xac\\x02\\xb6\\x02\\xc1\\x02\\xcb\\x02\\xd5\\x02\\xe0\\x02\\xeb\\x02\\xf5\\x03\\x00\\x03\\x0b\\x03\\x16\\x03!\\x03-\\x038\\x03C\\x03O\\x03Z\\x03f\\x03r\\x03~\\x03\\x8a\\x03\\x96\\x03\\xa2\\x03\\xae\\x03\\xba\\x03\\xc7\\x03\\xd3\\x03\\xe0\\x03\\xec\\x03\\xf9\\x04\\x06\\x04\\x13\\x04 \\x04-\\x04;\\x04H\\x04U\\x04c\\x04q\\x04~\\x04\\x8c\\x04\\x9a\\x04\\xa8\\x04\\xb6\\x04\\xc4\\x04\\xd3\\x04\\xe1\\x04\\xf0\\x04\\xfe\\x05\\r\\x05\\x1c\\x05+\\x05:\\x05I\\x05X\\x05g\\x05w\\x05\\x86\\x05\\x96\\x05\\xa6\\x05\\xb5\\x05\\xc5\\x05\\xd5\\x05\\xe5\\x05\\xf6\\x06\\x06\\x06\\x16\\x06\\'\\x067\\x06H\\x06Y\\x06j\\x06{\\x06\\x8c\\x06\\x9d\\x06\\xaf\\x06\\xc0\\x06\\xd1\\x06\\xe3\\x06\\xf5\\x07\\x07\\x07\\x19\\x07+\\x07=\\x07O\\x07a\\x07t\\x07\\x86\\x07\\x99\\x07\\xac\\x07\\xbf\\x07\\xd2\\x07\\xe5\\x07\\xf8\\x08\\x0b\\x08\\x1f\\x082\\x08F\\x08Z\\x08n\\x08\\x82\\x08\\x96\\x08\\xaa\\x08\\xbe\\x08\\xd2\\x08\\xe7\\x08\\xfb\\t\\x10\\t%\\t:\\tO\\td\\ty\\t\\x8f\\t\\xa4\\t\\xba\\t\\xcf\\t\\xe5\\t\\xfb\\n\\x11\\n\\'\\n=\\nT\\nj\\n\\x81\\n\\x98\\n\\xae\\n\\xc5\\n\\xdc\\n\\xf3\\x0b\\x0b\\x0b\"\\x0b9\\x0bQ\\x0bi\\x0b\\x80\\x0b\\x98\\x0b\\xb0\\x0b\\xc8\\x0b\\xe1\\x0b\\xf9\\x0c\\x12\\x0c*\\x0cC\\x0c\\\\\\x0cu\\x0c\\x8e\\x0c\\xa7\\x0c\\xc0\\x0c\\xd9\\x0c\\xf3\\r\\r\\r&\\r@\\rZ\\rt\\r\\x8e\\r\\xa9\\r\\xc3\\r\\xde\\r\\xf8\\x0e\\x13\\x0e.\\x0eI\\x0ed\\x0e\\x7f\\x0e\\x9b\\x0e\\xb6\\x0e\\xd2\\x0e\\xee\\x0f\\t\\x0f%\\x0fA\\x0f^\\x0fz\\x0f\\x96\\x0f\\xb3\\x0f\\xcf\\x0f\\xec\\x10\\t\\x10&\\x10C\\x10a\\x10~\\x10\\x9b\\x10\\xb9\\x10\\xd7\\x10\\xf5\\x11\\x13\\x111\\x11O\\x11m\\x11\\x8c\\x11\\xaa\\x11\\xc9\\x11\\xe8\\x12\\x07\\x12&\\x12E\\x12d\\x12\\x84\\x12\\xa3\\x12\\xc3\\x12\\xe3\\x13\\x03\\x13#\\x13C\\x13c\\x13\\x83\\x13\\xa4\\x13\\xc5\\x13\\xe5\\x14\\x06\\x14\\'\\x14I\\x14j\\x14\\x8b\\x14\\xad\\x14\\xce\\x14\\xf0\\x15\\x12\\x154\\x15V\\x15x\\x15\\x9b\\x15\\xbd\\x15\\xe0\\x16\\x03\\x16&\\x16I\\x16l\\x16\\x8f\\x16\\xb2\\x16\\xd6\\x16\\xfa\\x17\\x1d\\x17A\\x17e\\x17\\x89\\x17\\xae\\x17\\xd2\\x17\\xf7\\x18\\x1b\\x18@\\x18e\\x18\\x8a\\x18\\xaf\\x18\\xd5\\x18\\xfa\\x19 \\x19E\\x19k\\x19\\x91\\x19\\xb7\\x19\\xdd\\x1a\\x04\\x1a*\\x1aQ\\x1aw\\x1a\\x9e\\x1a\\xc5\\x1a\\xec\\x1b\\x14\\x1b;\\x1bc\\x1b\\x8a\\x1b\\xb2\\x1b\\xda\\x1c\\x02\\x1c*\\x1cR\\x1c{\\x1c\\xa3\\x1c\\xcc\\x1c\\xf5\\x1d\\x1e\\x1dG\\x1dp\\x1d\\x99\\x1d\\xc3\\x1d\\xec\\x1e\\x16\\x1e@\\x1ej\\x1e\\x94\\x1e\\xbe\\x1e\\xe9\\x1f\\x13\\x1f>\\x1fi\\x1f\\x94\\x1f\\xbf\\x1f\\xea \\x15 A l \\x98 \\xc4 \\xf0!\\x1c!H!u!\\xa1!\\xce!\\xfb\"\\'\"U\"\\x82\"\\xaf\"\\xdd#\\n#8#f#\\x94#\\xc2#\\xf0$\\x1f$M$|$\\xab$\\xda%\\t%8%h%\\x97%\\xc7%\\xf7&\\'&W&\\x87&\\xb7&\\xe8\\'\\x18\\'I\\'z\\'\\xab\\'\\xdc(\\r(?(q(\\xa2(\\xd4)\\x06)8)k)\\x9d)\\xd0*\\x02*5*h*\\x9b*\\xcf+\\x02+6+i+\\x9d+\\xd1,\\x05,9,n,\\xa2,\\xd7-\\x0c-A-v-\\xab-\\xe1.\\x16.L.\\x82.\\xb7.\\xee/$/Z/\\x91/\\xc7/\\xfe050l0\\xa40\\xdb1\\x121J1\\x821\\xba1\\xf22*2c2\\x9b2\\xd43\\r3F3\\x7f3\\xb83\\xf14+4e4\\x9e4\\xd85\\x135M5\\x875\\xc25\\xfd676r6\\xae6\\xe97$7`7\\x9c7\\xd78\\x148P8\\x8c8\\xc89\\x059B9\\x7f9\\xbc9\\xf9:6:t:\\xb2:\\xef;-;k;\\xaa;\\xe8<\\'<e<\\xa4<\\xe3=\"=a=\\xa1=\\xe0> >`>\\xa0>\\xe0?!?a?\\xa2?\\xe2@#@d@\\xa6@\\xe7A)AjA\\xacA\\xeeB0BrB\\xb5B\\xf7C:C}C\\xc0D\\x03DGD\\x8aD\\xceE\\x12EUE\\x9aE\\xdeF\"FgF\\xabF\\xf0G5G{G\\xc0H\\x05HKH\\x91H\\xd7I\\x1dIcI\\xa9I\\xf0J7J}J\\xc4K\\x0cKSK\\x9aK\\xe2L*LrL\\xbaM\\x02MJM\\x93M\\xdcN%NnN\\xb7O\\x00OIO\\x93O\\xddP\\'PqP\\xbbQ\\x06QPQ\\x9bQ\\xe6R1R|R\\xc7S\\x13S_S\\xaaS\\xf6TBT\\x8fT\\xdbU(UuU\\xc2V\\x0fV\\\\V\\xa9V\\xf7WDW\\x92W\\xe0X/X}X\\xcbY\\x1aYiY\\xb8Z\\x07ZVZ\\xa6Z\\xf5[E[\\x95[\\xe5\\\\5\\\\\\x86\\\\\\xd6]\\']x]\\xc9^\\x1a^l^\\xbd_\\x0f_a_\\xb3`\\x05`W`\\xaa`\\xfcaOa\\xa2a\\xf5bIb\\x9cb\\xf0cCc\\x97c\\xebd@d\\x94d\\xe9e=e\\x92e\\xe7f=f\\x92f\\xe8g=g\\x93g\\xe9h?h\\x96h\\xeciCi\\x9ai\\xf1jHj\\x9fj\\xf7kOk\\xa7k\\xfflWl\\xafm\\x08m`m\\xb9n\\x12nkn\\xc4o\\x1eoxo\\xd1p+p\\x86p\\xe0q:q\\x95q\\xf0rKr\\xa6s\\x01s]s\\xb8t\\x14tpt\\xccu(u\\x85u\\xe1v>v\\x9bv\\xf8wVw\\xb3x\\x11xnx\\xccy*y\\x89y\\xe7zFz\\xa5{\\x04{c{\\xc2|!|\\x81|\\xe1}A}\\xa1~\\x01~b~\\xc2\\x7f#\\x7f\\x84\\x7f\\xe5\\x80G\\x80\\xa8\\x81\\n\\x81k\\x81\\xcd\\x820\\x82\\x92\\x82\\xf4\\x83W\\x83\\xba\\x84\\x1d\\x84\\x80\\x84\\xe3\\x85G\\x85\\xab\\x86\\x0e\\x86r\\x86\\xd7\\x87;\\x87\\x9f\\x88\\x04\\x88i\\x88\\xce\\x893\\x89\\x99\\x89\\xfe\\x8ad\\x8a\\xca\\x8b0\\x8b\\x96\\x8b\\xfc\\x8cc\\x8c\\xca\\x8d1\\x8d\\x98\\x8d\\xff\\x8ef\\x8e\\xce\\x8f6\\x8f\\x9e\\x90\\x06\\x90n\\x90\\xd6\\x91?\\x91\\xa8\\x92\\x11\\x92z\\x92\\xe3\\x93M\\x93\\xb6\\x94 \\x94\\x8a\\x94\\xf4\\x95_\\x95\\xc9\\x964\\x96\\x9f\\x97\\n\\x97u\\x97\\xe0\\x98L\\x98\\xb8\\x99$\\x99\\x90\\x99\\xfc\\x9ah\\x9a\\xd5\\x9bB\\x9b\\xaf\\x9c\\x1c\\x9c\\x89\\x9c\\xf7\\x9dd\\x9d\\xd2\\x9e@\\x9e\\xae\\x9f\\x1d\\x9f\\x8b\\x9f\\xfa\\xa0i\\xa0\\xd8\\xa1G\\xa1\\xb6\\xa2&\\xa2\\x96\\xa3\\x06\\xa3v\\xa3\\xe6\\xa4V\\xa4\\xc7\\xa58\\xa5\\xa9\\xa6\\x1a\\xa6\\x8b\\xa6\\xfd\\xa7n\\xa7\\xe0\\xa8R\\xa8\\xc4\\xa97\\xa9\\xa9\\xaa\\x1c\\xaa\\x8f\\xab\\x02\\xabu\\xab\\xe9\\xac\\\\\\xac\\xd0\\xadD\\xad\\xb8\\xae-\\xae\\xa1\\xaf\\x16\\xaf\\x8b\\xb0\\x00\\xb0u\\xb0\\xea\\xb1`\\xb1\\xd6\\xb2K\\xb2\\xc2\\xb38\\xb3\\xae\\xb4%\\xb4\\x9c\\xb5\\x13\\xb5\\x8a\\xb6\\x01\\xb6y\\xb6\\xf0\\xb7h\\xb7\\xe0\\xb8Y\\xb8\\xd1\\xb9J\\xb9\\xc2\\xba;\\xba\\xb5\\xbb.\\xbb\\xa7\\xbc!\\xbc\\x9b\\xbd\\x15\\xbd\\x8f\\xbe\\n\\xbe\\x84\\xbe\\xff\\xbfz\\xbf\\xf5\\xc0p\\xc0\\xec\\xc1g\\xc1\\xe3\\xc2_\\xc2\\xdb\\xc3X\\xc3\\xd4\\xc4Q\\xc4\\xce\\xc5K\\xc5\\xc8\\xc6F\\xc6\\xc3\\xc7A\\xc7\\xbf\\xc8=\\xc8\\xbc\\xc9:\\xc9\\xb9\\xca8\\xca\\xb7\\xcb6\\xcb\\xb6\\xcc5\\xcc\\xb5\\xcd5\\xcd\\xb5\\xce6\\xce\\xb6\\xcf7\\xcf\\xb8\\xd09\\xd0\\xba\\xd1<\\xd1\\xbe\\xd2?\\xd2\\xc1\\xd3D\\xd3\\xc6\\xd4I\\xd4\\xcb\\xd5N\\xd5\\xd1\\xd6U\\xd6\\xd8\\xd7\\\\\\xd7\\xe0\\xd8d\\xd8\\xe8\\xd9l\\xd9\\xf1\\xdav\\xda\\xfb\\xdb\\x80\\xdc\\x05\\xdc\\x8a\\xdd\\x10\\xdd\\x96\\xde\\x1c\\xde\\xa2\\xdf)\\xdf\\xaf\\xe06\\xe0\\xbd\\xe1D\\xe1\\xcc\\xe2S\\xe2\\xdb\\xe3c\\xe3\\xeb\\xe4s\\xe4\\xfc\\xe5\\x84\\xe6\\r\\xe6\\x96\\xe7\\x1f\\xe7\\xa9\\xe82\\xe8\\xbc\\xe9F\\xe9\\xd0\\xea[\\xea\\xe5\\xebp\\xeb\\xfb\\xec\\x86\\xed\\x11\\xed\\x9c\\xee(\\xee\\xb4\\xef@\\xef\\xcc\\xf0X\\xf0\\xe5\\xf1r\\xf1\\xff\\xf2\\x8c\\xf3\\x19\\xf3\\xa7\\xf44\\xf4\\xc2\\xf5P\\xf5\\xde\\xf6m\\xf6\\xfb\\xf7\\x8a\\xf8\\x19\\xf8\\xa8\\xf98\\xf9\\xc7\\xfaW\\xfa\\xe7\\xfbw\\xfc\\x07\\xfc\\x98\\xfd)\\xfd\\xba\\xfeK\\xfe\\xdc\\xffm\\xff\\xffcurv\\x00\\x00\\x00\\x00\\x00\\x00\\x04\\x00\\x00\\x00\\x00\\x05\\x00\\n\\x00\\x0f\\x00\\x14\\x00\\x19\\x00\\x1e\\x00#\\x00(\\x00-\\x002\\x007\\x00;\\x00@\\x00E\\x00J\\x00O\\x00T\\x00Y\\x00^\\x00c\\x00h\\x00m\\x00r\\x00w\\x00|\\x00\\x81\\x00\\x86\\x00\\x8b\\x00\\x90\\x00\\x95\\x00\\x9a\\x00\\x9f\\x00\\xa4\\x00\\xa9\\x00\\xae\\x00\\xb2\\x00\\xb7\\x00\\xbc\\x00\\xc1\\x00\\xc6\\x00\\xcb\\x00\\xd0\\x00\\xd5\\x00\\xdb\\x00\\xe0\\x00\\xe5\\x00\\xeb\\x00\\xf0\\x00\\xf6\\x00\\xfb\\x01\\x01\\x01\\x07\\x01\\r\\x01\\x13\\x01\\x19\\x01\\x1f\\x01%\\x01+\\x012\\x018\\x01>\\x01E\\x01L\\x01R\\x01Y\\x01`\\x01g\\x01n\\x01u\\x01|\\x01\\x83\\x01\\x8b\\x01\\x92\\x01\\x9a\\x01\\xa1\\x01\\xa9\\x01\\xb1\\x01\\xb9\\x01\\xc1\\x01\\xc9\\x01\\xd1\\x01\\xd9\\x01\\xe1\\x01\\xe9\\x01\\xf2\\x01\\xfa\\x02\\x03\\x02\\x0c\\x02\\x14\\x02\\x1d\\x02&\\x02/\\x028\\x02A\\x02K\\x02T\\x02]\\x02g\\x02q\\x02z\\x02\\x84\\x02\\x8e\\x02\\x98\\x02\\xa2\\x02\\xac\\x02\\xb6\\x02\\xc1\\x02\\xcb\\x02\\xd5\\x02\\xe0\\x02\\xeb\\x02\\xf5\\x03\\x00\\x03\\x0b\\x03\\x16\\x03!\\x03-\\x038\\x03C\\x03O\\x03Z\\x03f\\x03r\\x03~\\x03\\x8a\\x03\\x96\\x03\\xa2\\x03\\xae\\x03\\xba\\x03\\xc7\\x03\\xd3\\x03\\xe0\\x03\\xec\\x03\\xf9\\x04\\x06\\x04\\x13\\x04 \\x04-\\x04;\\x04H\\x04U\\x04c\\x04q\\x04~\\x04\\x8c\\x04\\x9a\\x04\\xa8\\x04\\xb6\\x04\\xc4\\x04\\xd3\\x04\\xe1\\x04\\xf0\\x04\\xfe\\x05\\r\\x05\\x1c\\x05+\\x05:\\x05I\\x05X\\x05g\\x05w\\x05\\x86\\x05\\x96\\x05\\xa6\\x05\\xb5\\x05\\xc5\\x05\\xd5\\x05\\xe5\\x05\\xf6\\x06\\x06\\x06\\x16\\x06\\'\\x067\\x06H\\x06Y\\x06j\\x06{\\x06\\x8c\\x06\\x9d\\x06\\xaf\\x06\\xc0\\x06\\xd1\\x06\\xe3\\x06\\xf5\\x07\\x07\\x07\\x19\\x07+\\x07=\\x07O\\x07a\\x07t\\x07\\x86\\x07\\x99\\x07\\xac\\x07\\xbf\\x07\\xd2\\x07\\xe5\\x07\\xf8\\x08\\x0b\\x08\\x1f\\x082\\x08F\\x08Z\\x08n\\x08\\x82\\x08\\x96\\x08\\xaa\\x08\\xbe\\x08\\xd2\\x08\\xe7\\x08\\xfb\\t\\x10\\t%\\t:\\tO\\td\\ty\\t\\x8f\\t\\xa4\\t\\xba\\t\\xcf\\t\\xe5\\t\\xfb\\n\\x11\\n\\'\\n=\\nT\\nj\\n\\x81\\n\\x98\\n\\xae\\n\\xc5\\n\\xdc\\n\\xf3\\x0b\\x0b\\x0b\"\\x0b9\\x0bQ\\x0bi\\x0b\\x80\\x0b\\x98\\x0b\\xb0\\x0b\\xc8\\x0b\\xe1\\x0b\\xf9\\x0c\\x12\\x0c*\\x0cC\\x0c\\\\\\x0cu\\x0c\\x8e\\x0c\\xa7\\x0c\\xc0\\x0c\\xd9\\x0c\\xf3\\r\\r\\r&\\r@\\rZ\\rt\\r\\x8e\\r\\xa9\\r\\xc3\\r\\xde\\r\\xf8\\x0e\\x13\\x0e.\\x0eI\\x0ed\\x0e\\x7f\\x0e\\x9b\\x0e\\xb6\\x0e\\xd2\\x0e\\xee\\x0f\\t\\x0f%\\x0fA\\x0f^\\x0fz\\x0f\\x96\\x0f\\xb3\\x0f\\xcf\\x0f\\xec\\x10\\t\\x10&\\x10C\\x10a\\x10~\\x10\\x9b\\x10\\xb9\\x10\\xd7\\x10\\xf5\\x11\\x13\\x111\\x11O\\x11m\\x11\\x8c\\x11\\xaa\\x11\\xc9\\x11\\xe8\\x12\\x07\\x12&\\x12E\\x12d\\x12\\x84\\x12\\xa3\\x12\\xc3\\x12\\xe3\\x13\\x03\\x13#\\x13C\\x13c\\x13\\x83\\x13\\xa4\\x13\\xc5\\x13\\xe5\\x14\\x06\\x14\\'\\x14I\\x14j\\x14\\x8b\\x14\\xad\\x14\\xce\\x14\\xf0\\x15\\x12\\x154\\x15V\\x15x\\x15\\x9b\\x15\\xbd\\x15\\xe0\\x16\\x03\\x16&\\x16I\\x16l\\x16\\x8f\\x16\\xb2\\x16\\xd6\\x16\\xfa\\x17\\x1d\\x17A\\x17e\\x17\\x89\\x17\\xae\\x17\\xd2\\x17\\xf7\\x18\\x1b\\x18@\\x18e\\x18\\x8a\\x18\\xaf\\x18\\xd5\\x18\\xfa\\x19 \\x19E\\x19k\\x19\\x91\\x19\\xb7\\x19\\xdd\\x1a\\x04\\x1a*\\x1aQ\\x1aw\\x1a\\x9e\\x1a\\xc5\\x1a\\xec\\x1b\\x14\\x1b;\\x1bc\\x1b\\x8a\\x1b\\xb2\\x1b\\xda\\x1c\\x02\\x1c*\\x1cR\\x1c{\\x1c\\xa3\\x1c\\xcc\\x1c\\xf5\\x1d\\x1e\\x1dG\\x1dp\\x1d\\x99\\x1d\\xc3\\x1d\\xec\\x1e\\x16\\x1e@\\x1ej\\x1e\\x94\\x1e\\xbe\\x1e\\xe9\\x1f\\x13\\x1f>\\x1fi\\x1f\\x94\\x1f\\xbf\\x1f\\xea \\x15 A l \\x98 \\xc4 \\xf0!\\x1c!H!u!\\xa1!\\xce!\\xfb\"\\'\"U\"\\x82\"\\xaf\"\\xdd#\\n#8#f#\\x94#\\xc2#\\xf0$\\x1f$M$|$\\xab$\\xda%\\t%8%h%\\x97%\\xc7%\\xf7&\\'&W&\\x87&\\xb7&\\xe8\\'\\x18\\'I\\'z\\'\\xab\\'\\xdc(\\r(?(q(\\xa2(\\xd4)\\x06)8)k)\\x9d)\\xd0*\\x02*5*h*\\x9b*\\xcf+\\x02+6+i+\\x9d+\\xd1,\\x05,9,n,\\xa2,\\xd7-\\x0c-A-v-\\xab-\\xe1.\\x16.L.\\x82.\\xb7.\\xee/$/Z/\\x91/\\xc7/\\xfe050l0\\xa40\\xdb1\\x121J1\\x821\\xba1\\xf22*2c2\\x9b2\\xd43\\r3F3\\x7f3\\xb83\\xf14+4e4\\x9e4\\xd85\\x135M5\\x875\\xc25\\xfd676r6\\xae6\\xe97$7`7\\x9c7\\xd78\\x148P8\\x8c8\\xc89\\x059B9\\x7f9\\xbc9\\xf9:6:t:\\xb2:\\xef;-;k;\\xaa;\\xe8<\\'<e<\\xa4<\\xe3=\"=a=\\xa1=\\xe0> >`>\\xa0>\\xe0?!?a?\\xa2?\\xe2@#@d@\\xa6@\\xe7A)AjA\\xacA\\xeeB0BrB\\xb5B\\xf7C:C}C\\xc0D\\x03DGD\\x8aD\\xceE\\x12EUE\\x9aE\\xdeF\"FgF\\xabF\\xf0G5G{G\\xc0H\\x05HKH\\x91H\\xd7I\\x1dIcI\\xa9I\\xf0J7J}J\\xc4K\\x0cKSK\\x9aK\\xe2L*LrL\\xbaM\\x02MJM\\x93M\\xdcN%NnN\\xb7O\\x00OIO\\x93O\\xddP\\'PqP\\xbbQ\\x06QPQ\\x9bQ\\xe6R1R|R\\xc7S\\x13S_S\\xaaS\\xf6TBT\\x8fT\\xdbU(UuU\\xc2V\\x0fV\\\\V\\xa9V\\xf7WDW\\x92W\\xe0X/X}X\\xcbY\\x1aYiY\\xb8Z\\x07ZVZ\\xa6Z\\xf5[E[\\x95[\\xe5\\\\5\\\\\\x86\\\\\\xd6]\\']x]\\xc9^\\x1a^l^\\xbd_\\x0f_a_\\xb3`\\x05`W`\\xaa`\\xfcaOa\\xa2a\\xf5bIb\\x9cb\\xf0cCc\\x97c\\xebd@d\\x94d\\xe9e=e\\x92e\\xe7f=f\\x92f\\xe8g=g\\x93g\\xe9h?h\\x96h\\xeciCi\\x9ai\\xf1jHj\\x9fj\\xf7kOk\\xa7k\\xfflWl\\xafm\\x08m`m\\xb9n\\x12nkn\\xc4o\\x1eoxo\\xd1p+p\\x86p\\xe0q:q\\x95q\\xf0rKr\\xa6s\\x01s]s\\xb8t\\x14tpt\\xccu(u\\x85u\\xe1v>v\\x9bv\\xf8wVw\\xb3x\\x11xnx\\xccy*y\\x89y\\xe7zFz\\xa5{\\x04{c{\\xc2|!|\\x81|\\xe1}A}\\xa1~\\x01~b~\\xc2\\x7f#\\x7f\\x84\\x7f\\xe5\\x80G\\x80\\xa8\\x81\\n\\x81k\\x81\\xcd\\x820\\x82\\x92\\x82\\xf4\\x83W\\x83\\xba\\x84\\x1d\\x84\\x80\\x84\\xe3\\x85G\\x85\\xab\\x86\\x0e\\x86r\\x86\\xd7\\x87;\\x87\\x9f\\x88\\x04\\x88i\\x88\\xce\\x893\\x89\\x99\\x89\\xfe\\x8ad\\x8a\\xca\\x8b0\\x8b\\x96\\x8b\\xfc\\x8cc\\x8c\\xca\\x8d1\\x8d\\x98\\x8d\\xff\\x8ef\\x8e\\xce\\x8f6\\x8f\\x9e\\x90\\x06\\x90n\\x90\\xd6\\x91?\\x91\\xa8\\x92\\x11\\x92z\\x92\\xe3\\x93M\\x93\\xb6\\x94 \\x94\\x8a\\x94\\xf4\\x95_\\x95\\xc9\\x964\\x96\\x9f\\x97\\n\\x97u\\x97\\xe0\\x98L\\x98\\xb8\\x99$\\x99\\x90\\x99\\xfc\\x9ah\\x9a\\xd5\\x9bB\\x9b\\xaf\\x9c\\x1c\\x9c\\x89\\x9c\\xf7\\x9dd\\x9d\\xd2\\x9e@\\x9e\\xae\\x9f\\x1d\\x9f\\x8b\\x9f\\xfa\\xa0i\\xa0\\xd8\\xa1G\\xa1\\xb6\\xa2&\\xa2\\x96\\xa3\\x06\\xa3v\\xa3\\xe6\\xa4V\\xa4\\xc7\\xa58\\xa5\\xa9\\xa6\\x1a\\xa6\\x8b\\xa6\\xfd\\xa7n\\xa7\\xe0\\xa8R\\xa8\\xc4\\xa97\\xa9\\xa9\\xaa\\x1c\\xaa\\x8f\\xab\\x02\\xabu\\xab\\xe9\\xac\\\\\\xac\\xd0\\xadD\\xad\\xb8\\xae-\\xae\\xa1\\xaf\\x16\\xaf\\x8b\\xb0\\x00\\xb0u\\xb0\\xea\\xb1`\\xb1\\xd6\\xb2K\\xb2\\xc2\\xb38\\xb3\\xae\\xb4%\\xb4\\x9c\\xb5\\x13\\xb5\\x8a\\xb6\\x01\\xb6y\\xb6\\xf0\\xb7h\\xb7\\xe0\\xb8Y\\xb8\\xd1\\xb9J\\xb9\\xc2\\xba;\\xba\\xb5\\xbb.\\xbb\\xa7\\xbc!\\xbc\\x9b\\xbd\\x15\\xbd\\x8f\\xbe\\n\\xbe\\x84\\xbe\\xff\\xbfz\\xbf\\xf5\\xc0p\\xc0\\xec\\xc1g\\xc1\\xe3\\xc2_\\xc2\\xdb\\xc3X\\xc3\\xd4\\xc4Q\\xc4\\xce\\xc5K\\xc5\\xc8\\xc6F\\xc6\\xc3\\xc7A\\xc7\\xbf\\xc8=\\xc8\\xbc\\xc9:\\xc9\\xb9\\xca8\\xca\\xb7\\xcb6\\xcb\\xb6\\xcc5\\xcc\\xb5\\xcd5\\xcd\\xb5\\xce6\\xce\\xb6\\xcf7\\xcf\\xb8\\xd09\\xd0\\xba\\xd1<\\xd1\\xbe\\xd2?\\xd2\\xc1\\xd3D\\xd3\\xc6\\xd4I\\xd4\\xcb\\xd5N\\xd5\\xd1\\xd6U\\xd6\\xd8\\xd7\\\\\\xd7\\xe0\\xd8d\\xd8\\xe8\\xd9l\\xd9\\xf1\\xdav\\xda\\xfb\\xdb\\x80\\xdc\\x05\\xdc\\x8a\\xdd\\x10\\xdd\\x96\\xde\\x1c\\xde\\xa2\\xdf)\\xdf\\xaf\\xe06\\xe0\\xbd\\xe1D\\xe1\\xcc\\xe2S\\xe2\\xdb\\xe3c\\xe3\\xeb\\xe4s\\xe4\\xfc\\xe5\\x84\\xe6\\r\\xe6\\x96\\xe7\\x1f\\xe7\\xa9\\xe82\\xe8\\xbc\\xe9F\\xe9\\xd0\\xea[\\xea\\xe5\\xebp\\xeb\\xfb\\xec\\x86\\xed\\x11\\xed\\x9c\\xee(\\xee\\xb4\\xef@\\xef\\xcc\\xf0X\\xf0\\xe5\\xf1r\\xf1\\xff\\xf2\\x8c\\xf3\\x19\\xf3\\xa7\\xf44\\xf4\\xc2\\xf5P\\xf5\\xde\\xf6m\\xf6\\xfb\\xf7\\x8a\\xf8\\x19\\xf8\\xa8\\xf98\\xf9\\xc7\\xfaW\\xfa\\xe7\\xfbw\\xfc\\x07\\xfc\\x98\\xfd)\\xfd\\xba\\xfeK\\xfe\\xdc\\xffm\\xff\\xffchrm\\x00\\x00\\x00\\x00\\x00\\x03\\x00\\x00\\x00\\x00\\xa3\\xd7\\x00\\x00T{\\x00\\x00L\\xcd\\x00\\x00\\x99\\x9a\\x00\\x00&f\\x00\\x00\\x0f\\\\text\\x00\\x00\\x00\\x00no copyright, use freely\\x00\\n'\n ds7.OpticalPathIdentifier = '1'\n # noinspection SpellCheckingInspection\n ds7.OpticalPathDescription = 'Brightfield'\n\n dcm.OpticalPathSequence = Sequence([ds7])\n del ds7, ds5, ds4\n\n dcm.AcquisitionContextSequence = Sequence([])\n\n ds0 = Dataset()\n ds0.LocalNamespaceEntityID = 'UNKNOWN'\n dcm.IssuerOfTheContainerIdentifierSequence = Sequence([ds0])\n del ds0\n\n ds0 = Dataset()\n\n ds0.SpecimenIdentifier = 'UNKNOWN'\n ds0.SpecimenPreparationSequence = Sequence([])\n ds0.SpecimenUID = generate_uid(prefix=None)\n ds0.IssuerOfTheSpecimenIdentifierSequence = Sequence([])\n dcm.SpecimenDescriptionSequence = Sequence([ds0])\n dcm.ContainerTypeCodeSequence = Sequence([])\n dcm.ContainerIdentifier = 'UNKNOWN'\n return dcm","def make_squiggle(sequence, model, std_multiplier=1.0):\n # Find k for kmers from model\n k = len(model.index.values[0])\n\n # number of events\n n = len(sequence) - k\n\n # prepare means\n means = np.zeros(n, dtype=\"float64\")\n stdvs = np.zeros(n, dtype=\"float64\")\n\n for i in range(n):\n kmer = sequence[i:i + k].values.tostring()\n means[i] = model.ix[kmer][\"level_mean\"]\n stdvs[i] = model.ix[kmer][\"level_stdv\"]\n x = np.random.normal(means, stdvs * std_multiplier)\n return x","def random_crop_generator(batches, crop_length):\n while True:\n batch_x, batch_y = next(batches)\n batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\n for i in range(batch_x.shape[0]):\n batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\n yield (batch_crops, batch_y)","def generate_model (d):\n return np.random.rand (d+1, 1)","def make_data_iterator(dataset, batch_size):\n \n if dataset == '8gaussians':\n scale = 2.\n centers = [\n (1, 0),\n (-1, 0),\n (0, 1),\n (0, -1),\n (1. / np.sqrt(2), 1. / np.sqrt(2)),\n (1. / np.sqrt(2), -1. / np.sqrt(2)),\n (-1. / np.sqrt(2), 1. / np.sqrt(2)),\n (-1. / np.sqrt(2), -1. / np.sqrt(2))\n ]\n centers = [(scale * x, scale * y) for x, y in centers]\n while True:\n dataset = []\n for i in range(batch_size):\n point = np.random.randn(2) * .2\n center = random.choice(centers)\n point[0] += center[0]\n point[1] += center[1]\n dataset.append(point)\n dataset = torch.Tensor(dataset)\n dataset /= 1.414 # stdev\n yield dataset\n \n elif dataset == 'sine':\n while True:\n noise = 0.2\n x = torch.linspace(-4, 4, batch_size, dtype=torch.float32)\n y = np.sin(x) + noise*np.random.randn(*x.shape)\n yield torch.stack([x, y], dim=1)\n \n elif dataset == 'heteroscedastic':\n theta = torch.linspace(0, 2, batch_size)\n x = np.exp(theta)*np.tan(0.1*theta)\n while True:\n b = (0.001 + 0.5 * np.abs(x)) * np.random.normal(1, 1, batch_size)\n y = np.exp(theta)*np.sin(0.1*theta) + b\n yield torch.stack([x, y], dim=1)\n \n elif dataset == 'moon':\n noise = 0.1\n while True:\n data, _ = sklearn.datasets.make_moons(n_samples=batch_size,\n noise=noise)\n yield torch.Tensor(data)\n \n elif dataset == 'helix':\n noise = 0.2\n while True:\n t = torch.linspace(0, 20, batch_size)\n x = np.cos(t)\n x2 = np.sin(t) + noise * np.random.randn(*x.shape)\n \n yield torch.stack([x, x2, t], dim=1)\n \n elif dataset == 'circle':\n while True:\n t = np.random.random(batch_size) * 2 * np.pi - np.pi\n length = 1 - np.random.random(batch_size)*0.4\n x = torch.Tensor(np.multiply(np.cos(t), length))\n y = torch.Tensor(np.multiply(np.sin(t), length))\n \n yield torch.stack([x, y], dim=1)\n\n elif dataset == '2spirals':\n while True:\n z = torch.randn(batch_size, 2)\n n = torch.sqrt(torch.rand(batch_size // 2)) * 540 * (2 * math.pi) / 360\n d1x = - torch.cos(n) * n + torch.rand(batch_size // 2) * 0.5\n d1y = torch.sin(n) * n + torch.rand(batch_size // 2) * 0.5\n x = torch.cat([torch.stack([ d1x, d1y], dim=1),\n torch.stack([-d1x, -d1y], dim=1)], dim=0) / 3\n yield x + 0.1*z","def batches(self, batch_size): \n if self.shuffle:\n idx = np.arange(len(dataset.train_x))\n np.random.shuffle(idx)\n self.train_x = self.train_x[idx]\n \n n_batches = len(self.train_x) // batch_size\n for ii in range(0, len(self.train_x), batch_size):\n x = self.train_x[ii:ii+batch_size]\n \n yield self.scaler(x)","def generate_multi_type2(self, num_data, velocity, num_step, num_dim, test=False, visualize=False):\n num_vel = len(velocity)\n if not test:\n # if pow(num_vel, num_step) < num_data:\n # vel_list = np.asarray(list(itertools.product(np.arange(num_vel), repeat=num_step)))\n # num_vel_list = len(vel_list)\n #\n # div, rem = num_data // num_vel_list, num_data % num_vel_list\n # vel_idx = np.vstack((np.tile(vel_list, [div, 1]), vel_list[np.random.choice(num_vel_list, size=rem)]))\n # np.random.shuffle(vel_idx)\n # else:\n vel_idx = np.random.choice(num_vel, size=[num_data, num_step])\n\n vel_grid = np.take(velocity, vel_idx, axis=0)\n vel = vel_grid * self.interval_length\n\n vel_grid_cumsum = np.cumsum(vel_grid, axis=1)\n mu_max = np.fmin(self.num_interval, np.min(self.num_interval - vel_grid_cumsum, axis=1))\n mu_min = np.fmax(0, np.max(-vel_grid_cumsum, axis=1))\n mu_start = np.random.sample(size=[num_data, num_dim])\n mu_start = np.expand_dims(np.round(mu_start * (mu_max - mu_min) + mu_min - 0.5), axis=1)\n mu_seq = np.concatenate((mu_start, mu_start + vel_grid_cumsum), axis=1)\n else:\n if visualize:\n mu_start = np.reshape([4, 4], newshape=(1, 1, 2))\n vel_pool = np.where((velocity[:, 0] >= -1) & (velocity[:, 1] >= -1))\n vel_idx = np.random.choice(vel_pool[0], size=[num_data * 10, num_step])\n\n vel_grid_cumsum = np.cumsum(np.take(velocity, vel_idx, axis=0), axis=1)\n mu_seq = np.concatenate((np.tile(mu_start, [num_data * 10, 1, 1]), vel_grid_cumsum + mu_start), axis=1)\n mu_seq_new, vel_idx_new = [], []\n for i in range(len(mu_seq)):\n mu_seq_sub = mu_seq[i]\n if len(np.unique(mu_seq_sub, axis=0)) == len(mu_seq_sub):\n mu_seq_new.append(mu_seq[i])\n vel_idx_new.append(vel_idx[i])\n mu_seq, vel_idx = np.stack(mu_seq_new, axis=0), np.stack(vel_idx_new, axis=0)\n mu_seq_rs = np.reshape(mu_seq, [-1, (num_step + 1) * 2])\n select_idx = np.where(np.sum(mu_seq_rs >= self.num_interval, axis=1) == 0)[0][:num_data]\n vel_idx = vel_idx[select_idx]\n mu_seq = mu_seq[select_idx]\n vel = np.take(velocity, vel_idx, axis=0) * self.interval_length\n else:\n vel_idx = np.random.choice(num_vel, size=[num_data * num_dim, num_step])\n vel_grid_cumsum = np.cumsum(np.take(velocity, vel_idx, axis=0), axis=1)\n mu_max = np.fmin(self.num_interval, np.min(self.num_interval - vel_grid_cumsum, axis=1))\n mu_min = np.fmax(0, np.max(-vel_grid_cumsum, axis=1))\n\n select_idx = np.where(np.sum(mu_max < mu_min, axis=1) == 0)[0][:num_data]\n vel_idx, vel_grid_cumsum = vel_idx[select_idx], vel_grid_cumsum[select_idx]\n vel_grid = np.take(velocity, vel_idx, axis=0)\n mu_max, mu_min = mu_max[select_idx], mu_min[select_idx]\n mu_start = np.random.sample(size=[num_data, num_dim])\n mu_start = np.expand_dims(np.round(mu_start * (mu_max - mu_min) + mu_min - 0.5), axis=1)\n mu_seq = np.concatenate((mu_start, mu_start + vel_grid_cumsum), axis=1)\n vel = vel_grid * self.interval_length\n\n # sns.distplot(vel, rug=True, hist=False)\n # plt.show()\n\n place_seq = {'seq': mu_seq, 'vel': vel, 'vel_idx': vel_idx}\n return place_seq","def sample(self, num_samples, current_device):\n z = torch.randn(num_samples, self.latent_dim).to(current_device)\n samples = self.decode(z)\n return samples","def generator(features, labels, batch_size):\n \n # Create empty arrays to contain batch of features and labels#\n batch_features = np.zeros((batch_size, 160, 320, 3))\n batch_labels = np.zeros((batch_size, 1))\n while True:\n for i in range(batch_size):\n # choose random index in features\n index = random.choice(range(len(features)))\n batch_features[i] = features[index]\n batch_labels[i] = labels[index]\n yield batch_features, batch_labels","def _samples(self):\n finite_types = \\\n [QuiverMutationType(t) for t in [['A', 1], ['A', 5], ['B', 2], ['B', 5],\n ['C', 3], ['C', 5], ['D', 2], ['D', 5],\n [\"E\", 6], [\"E\", 7], [\"E\", 8], [\"F\", 4],\n [\"G\", 2]]]\n affine_types = \\\n [QuiverMutationType(t) for t in [['A', [1,1], 1], ['A', [4,5], 1], ['D', 4, 1], ['BB', 5, 1]]]\n elliptic_types = \\\n [QuiverMutationType(t) for t in [['E', 6, [1,1]], ['E', 7, [1,1]]]]\n mutation_finite_types = \\\n [QuiverMutationType(t) for t in [['R2',(1,5)], ['R2',(3,5)]]]\n mutation_infinite_types = \\\n [QuiverMutationType(t) for t in [['E',10], ['BE',5], ['GR',(3,10)], ['T',(3,3,4)]]]\n\n return finite_types + affine_types + elliptic_types + mutation_finite_types + mutation_infinite_types","def ptb_iterator(raw_data, batch_size, num_steps, augment=False):\n raw_data = np.array(raw_data, dtype=np.int32)\n\n if augment:\n # https://github.com/cooijmanstim/recurrent-batch-normalization/blob/master/penntreebank.py#L93\n offset = np.random.randint(num_steps)\n raw_data = raw_data[offset:]\n\n data_len = len(raw_data)\n batch_len = data_len // batch_size\n data = np.zeros([batch_size, batch_len], dtype=np.int32)\n for i in range(batch_size):\n data[i] = raw_data[batch_len * i:batch_len * (i + 1)]\n\n\n epoch_size = (batch_len - 1) // num_steps\n\n if epoch_size == 0:\n raise ValueError(\"epoch_size == 0, decrease batch_size or num_steps\")\n\n for i in range(epoch_size):\n x = data[:, i*num_steps:(i+1)*num_steps]\n y = data[:, i*num_steps+1:(i+1)*num_steps+1]\n yield (x, y)","def createGenerator(seed, channels):\n model = tf.keras.Sequential()\n model.add(layers.Dense(4 * 4 * 256, activation = \"relu\", input_dim = seed))\n model.add(layers.Reshape((4, 4, 256)))\n\n model.add(layers.UpSampling2D())\n model.add(layers.Conv2D(256, kernel_size = 3,padding = \"same\"))\n model.add(layers.BatchNormalization(momentum = 0.8))\n model.add(layers.Activation(\"relu\"))\n\n model.add(layers.UpSampling2D())\n model.add(layers.Conv2D(256, kernel_size = 3, padding = \"same\"))\n model.add(layers.BatchNormalization(momentum = 0.8))\n model.add(layers.Activation(\"relu\"))\n\n model.add(layers.UpSampling2D())\n model.add(layers.Conv2D(128, kernel_size = 3, padding = \"same\"))\n model.add(layers.BatchNormalization(momentum = 0.8))\n model.add(layers.Activation(\"relu\"))\n #check desired resolution to adjust output size and add complexity\n if GENERATE_RES > 1:\n model.add(layers.UpSampling2D(size=(GENERATE_RES, GENERATE_RES)))\n model.add(layers.Conv2D(128, kernel_size = 3, padding = \"same\"))\n model.add(layers.BatchNormalization(momentum = 0.8))\n model.add(layers.Activation(\"relu\"))\n #if()\n\n #final Convolutional NN layer\n model.add(layers.Conv2D(channels, kernel_size = 3, padding = \"same\"))\n model.add(layers.Activation(\"tanh\"))\n\n return model","def get_cd_samples(self):\n \n if \"PCD\" in self.algorithm:\n \n input_vars = []\n \n given_vars = []\n \n else:\n \n input_vars = [self.minibatch_set]\n \n given_vars = {self.x_gibbs: self.train_inputs[self.minibatch_set,:]} \n \n get_samples = theano.function(inputs = input_vars,\n outputs = [self.p_xi_given_x_[-1], \n self.gibbs_samples[-1]\n ], \n givens = given_vars,\n #start the chain at the data distribution\n updates = self.gibbs_updates)\n \n return get_samples","def _build_runlist(self):\n\n if self.seed is not None:\n np.random.seed(self.seed)\n\n for i in moves.range(self.num_samples):\n sample = []\n for key, meta in iteritems(self.get_desvar_metadata()):\n nval = meta['size']\n values = []\n for k in range(nval):\n\n low = meta['lower']\n high = meta['upper']\n if isinstance(low, np.ndarray):\n low = low[k]\n if isinstance(high, np.ndarray):\n high = high[k]\n\n values.append(np.random.uniform(low, high))\n sample.append([key, np.array(values)])\n\n yield sample","def enhancer_iterator(self, data, labels, batch_size, num_steps):\n def seq_to_ints(seq):\n return [self.vocab.word_to_index[c] for c in seq]\n\n # Map raw data to array of ints. if all sequences are the same length L, \n # raw_data will be N-by-L\n mdata = np.array([seq_to_ints(i) for i in data], dtype=np.int32)\n num_batches = len(mdata) // batch_size\n \n # data will have batch_len elements, each of size batch_size\n # ASSUME FIXED SEQUENCE LENGTHS OFF 1000 FOR NOW (5/20/16)\n # Just grab middle self.config.num_steps nucleotides\n a = int(len(mdata[0,:])/2-self.config.num_steps/2)\n b = int(len(mdata[0,:])/2+self.config.num_steps/2)\n for i in range(num_batches):\n x = mdata[batch_size*i:batch_size*(i+1),a:b]\n if labels is not None:\n y = labels[batch_size*i:batch_size*(i+1)]\n else:\n y = None\n yield(x,y)","def flow(self, batch_size=32, output='both', crops=0):\n while True:\n for dataset in self.input_sets:\n X = self.training_set['input/'+dataset]\n y = self.training_set['target/'+dataset]\n y_seg = self.training_set['seg_map/'+dataset]\n\n for i in range(int(math.ceil(X.shape[0]/2000))):\n index = list(range(0,X.shape[0]))\n sample = random.sample(index, batch_size)\n sample.sort()\n X_batch = X[sample, ...]\n y_batch = y[sample, ...]\n y_seg_batch = y_seg[sample, ...]\n X_batch = self.augment(X_batch)\n\n if crops > 0:\n (X_batch, y_batch,\n y_seg_batch) = _augmentors.random_crops(\n X_batch, y_batch, y_seg_batch, n_crops=crops, crop_dim=20)\n\n if output=='both':\n yield (X_batch, [y_batch, y_seg_batch])\n elif output=='seg':\n yield (X_batch, y_seg)\n elif output=='density':\n yield (X_batch, y_batch)\n else:\n raise Exception('output must be \"density\", \"seg\" or \"both\"')","def samples(self):\n pass","def fixture_samples(sample_single) -> Iterator[dict]:\n _samples = []\n sample_id = sample_single[\"sample_id\"]\n for number in range(3):\n sample = copy.deepcopy(sample_single)\n sample[\"sample_id\"] = \"_\".join([sample_id, str(number)])\n _samples.append(sample)\n return _samples","def to_dataset(sound_inputs, chunk_size=None, increment=None):\n\n if chunk_size is None:\n nrows = len(sound_inputs)\n ncols = np.prod(sound_inputs[0].shape)\n else:\n get_nchunks = lambda dur: np.ceil(float(dur) / int(self.chunk_size * self.stride))\n # Compute the total number of vectorized samples in the list of sound_inputs\n nrows = np.sum([get_nchunks(s.sound.annotations[\"data_shape\"][1]) for s in sound_inputs])\n ncols = sound_inputs[0].shape[0] * chunk_size\n\n mean = np.zeros(data_shape[1])\n std = np.ones(data_shape[1])\n if self.zscore:\n for s in sound_inputs:\n data = s.data.ravel()\n s.clear_cache()\n mean += data\n std += data ** 2\n std = np.sqrt(std / len(sound_inputs) - mean ** 2 / len(sound_inputs))\n mean = mean / len(sound_inputs)\n\n\n with h5py.File(self.ds_filename, \"w\") as hf:\n ds = hf.create_dataset(\"input\",\n data_shape,\n chunks=(batch_size, data_shape[1]))\n data = list()\n start = 0\n for s in sound_inputs:\n data.append(s.data.ravel())\n s.clear_cache()\n if len(data) == batch_size:\n ds[start: start + batch_size] = (np.vstack(data) - mean) / std\n start += batch_size\n data = list()\n if len(data):\n ds[start: start + len(data)] = np.vstack(data)\n\n return self.ds_filename","def generate_mog_dataset():\n\n n_per_class = 100\n dim = 2\n n_gaussians = 4\n mus = [(0, 1), (-1, 0), (0, -1), (1, 0)]\n mus = [torch.tensor(m) for m in mus]\n var = 0.05\n\n inputs, labels = [], []\n\n for id in range(n_gaussians):\n # Generate input data by mu + x @ sqrt(cov)\n cov = np.sqrt(var) * torch.eye(dim)\n mu = mus[id]\n inputs.append(mu + torch.randn(n_per_class, dim) @ cov)\n\n # Labels\n labels.append(torch.tensor(n_per_class * [1.0 if id < 2 else 0.0]))\n\n return torch.cat(inputs, dim=0), torch.cat(labels, dim=0)","def generate_samples(self, config, num_samples):\n tic = time.time()\n\n generator = GMM(**config)\n weights = torch.rand(config.num_components)\n generator.component_weights.set_(weights / weights.sum())\n generator.gaussian.means.set_(torch.randn(config.num_components, config.num_features))\n\n if config.covariance == 'diag':\n generator.gaussian.covars.set_(torch.rand(config.num_components, config.num_features))\n\n samples = generator.sample(num_samples)\n\n toc = time.time()\n print(f\"Generated {num_samples:,} samples in {toc-tic:.2f} seconds.\")\n\n return samples","def generate_data(example_size):\n\n\n # A placeholder for data.\n x = np.zeros((example_size, 2))\n\n # Randomly selects one of two classes for each example.\n class_id = np.random.randint(2, size=example_size)\n\n # Generates data for the class 0.\n class_0_idx = np.where(class_id == 0)\n mean0 = [0.0, 1.0]\n cov0 = [[0.4, 0.0], [0.0, 1.0]]\n x[class_0_idx[0], :] = np.random.multivariate_normal(\n mean0, cov0, class_0_idx[0].shape[0])\n\n # Generates data for the class 0.\n class_1_idx = np.where(class_id == 1)\n mean1 = [1.0, 2.0]\n cov1 = [[1.0, 0.0], [0.0, 0.4]]\n x[class_1_idx[0], :] = np.random.multivariate_normal(\n mean1, cov1, class_1_idx[0].shape[0])\n\n return (x, class_id)","def __iter__(self):\n for sample in self.samples:\n yield sample","def chunks(X, y, batch_size=32, augmentation_times=4, thickness=0,\n data_generator=ImageDataGenerator(dim_ordering=\"th\"), is_training=True):\n while 1:\n prct_pop, prct1 = 0.2, 0.2 # (1) of all the training set, how much we keep (2) % of 1's\n idx_1 = [i for i in range(len(y)) if y[i] == 1]\n idx_1 = random.sample(idx_1, int(prct_pop * len(idx_1)))\n idx_0 = [i for i in range(len(y)) if y[i] == 0]\n idx_0 = random.sample(idx_0, int(len(idx_1) / prct1))\n selected_samples = idx_0 + idx_1\n random.shuffle(selected_samples)\n logging.info(\"Final downsampled dataset stats: TP:%d, FP:%d\" % (\n sum(y[selected_samples]), len(y[selected_samples]) - sum(y[selected_samples])))\n\n i, good = 0, 0\n lenX = len(selected_samples)\n for X_batch, y_batch in data_generator.flow(X[selected_samples], y[selected_samples], batch_size=batch_size,\n shuffle=is_training):\n i += 1\n if good * batch_size > lenX * augmentation_times or i > 100: # stop when we have augmented enough the batch\n break\n if X_batch.shape[0] != batch_size: # ensure correct batch size\n continue\n good += 1\n yield X_batch, y_batch","def step(self, chunk: th.Tensor) -> th.Tensor:\n for conv1d in self.enc_layers:\n chunk = conv1d(chunk)\n return chunk","def sample(self, num_samples, current_device, **kwargs):\n z = torch.randn(num_samples, self.latent_dim)\n z = z.to(current_device)\n samples = self.decode(z)\n\n return samples","def mscoco_generator(data_dir,\n tmp_dir,\n training,\n how_many,\n start_from=0,\n eos_list=None,\n vocab_filename=None):\n eos_list = [1] if eos_list is None else eos_list\n def get_vocab():\n \"\"\"Get vocab for caption text encoder.\"\"\"\n if data_dir is not None and vocab_filename is not None:\n vocab_filepath = os.path.join(data_dir, vocab_filename)\n if tf.gfile.Exists(vocab_filepath):\n tf.logging.info(\"Found vocab file: %s\", vocab_filepath)\n vocab_symbolizer = text_encoder.SubwordTextEncoder(vocab_filepath)\n return vocab_symbolizer\n else:\n raise ValueError(\"Vocab file does not exist: %s\" % vocab_filepath)\n return None\n\n vocab_symbolizer = get_vocab()\n _get_mscoco(tmp_dir)\n caption_filepath = (\n _MSCOCO_TRAIN_CAPTION_FILE if training else _MSCOCO_EVAL_CAPTION_FILE)\n caption_filepath = os.path.join(tmp_dir, caption_filepath)\n prefix = _MSCOCO_TRAIN_PREFIX if training else _MSCOCO_EVAL_PREFIX\n caption_file = io.open(caption_filepath)\n caption_json = json.load(caption_file)\n # Dictionary from image_id to ((filename, height, width), captions).\n image_dict = {}\n for image in caption_json[\"images\"]:\n image_dict[image[\"id\"]] = [(image[\"file_name\"], image[\"height\"],\n image[\"width\"]), []]\n annotations = caption_json[\"annotations\"]\n annotation_count = len(annotations)\n image_count = len(image_dict)\n tf.logging.info(\"Processing %d images and %d labels\\n\" % (image_count,\n annotation_count))\n for annotation in annotations:\n image_id = annotation[\"image_id\"]\n image_dict[image_id][1].append(annotation[\"caption\"])\n\n data = list(image_dict.values())[start_from:start_from + how_many]\n random.shuffle(data)\n for image_info, labels in data:\n image_filename = image_info[0]\n image_filepath = os.path.join(tmp_dir, prefix, image_filename)\n with tf.gfile.Open(image_filepath, \"rb\") as f:\n encoded_image_data = f.read()\n height, width = image_info[1], image_info[2]\n for label in labels:\n if vocab_filename is None or vocab_symbolizer is None:\n label = [ord(c) for c in label] + eos_list\n else:\n label = vocab_symbolizer.encode(label) + eos_list\n yield {\n \"image/encoded\": [encoded_image_data],\n \"image/format\": [\"jpeg\"],\n \"image/class/label\": label,\n \"image/height\": [height],\n \"image/width\": [width]\n }","def sample(self, detections):\n\n dist_mean = []\n dist_covar = []\n num_det = len(detections)\n timestamp = next(iter(detections)).timestamp\n for detection in detections:\n ndim_state = detection.measurement_model.ndim_state\n ndim_meas = detection.measurement_model.ndim\n if isinstance(detection.measurement_model, LinearModel):\n if ndim_state > ndim_meas:\n mapping = detection.measurement_model.mapping\n mapping_matrix = np.zeros((ndim_state, ndim_meas))\n mapping_index = np.linspace(0, len(mapping)-1, ndim_meas, dtype=int)\n mapping_matrix[mapping, mapping_index] \\\n = 1\n dist_mean.append(mapping_matrix @ detection.state_vector)\n dist_covar.append(mapping_matrix @\n detection.measurement_model.noise_covar @\n mapping_matrix.T)\n else:\n dist_mean.append(detection.state_vector)\n dist_covar.append(detection.measurement_model.noise_covar)\n else:\n tmp_mean = detection.measurement_model.inverse_function(detection)\n jac = jacobian(detection.measurement_model.inverse_function, detection)\n tmp_covar = jac @ detection.measurement_model.noise_covar @ jac.T\n dist_mean.append(tmp_mean)\n dist_covar.append(tmp_covar)\n\n weights = self.get_weight(num_det)\n\n samples = gm_sample(means=dist_mean,\n covars=dist_covar,\n weights=weights,\n size=self.nsamples)\n\n particles = ParticleState(state_vector=StateVectors(samples),\n weight=np.array([1 / self.nsamples] * self.nsamples),\n timestamp=timestamp)\n return particles","def generate_samples(data, root_path, batch_size=128):\n while True:\n # Generate random batch of indices\n indices = np.random.permutation(data.count()[0])\n\n for batch in range(0, len(indices), batch_size):\n batch_i = indices[batch:(batch + batch_size)]\n\n x = np.empty([0, img_h, img_w, img_c], dtype=np.float32)\n y = np.empty([0], dtype=np.float32)\n\n x, y = augment_data(x, y, data, root_path, batch_i)\n x, y = flip_images(x, y)\n\n yield (x, y)","def generate(\n self, models, sample: Dict[str, Dict[str, Tensor]], **kwargs\n ) -> List[List[Dict[str, Tensor]]]:\n return self._generate(sample, **kwargs)","def _get_chunk_data(self, inputs: Iterable, chunk_size: int):\n inputs_iter = iter(inputs)\n while True:\n try:\n chunk_data = []\n for _ in range(chunk_size):\n processed_data = next(inputs_iter)\n chunk_data.append(processed_data)\n yield chunk_data\n except StopIteration:\n if chunk_data:\n yield chunk_data\n break","def sample_from_cone(self, cone, num_samples=1):\n num_faces = cone.shape[1]\n v_samples = np.empty((num_samples, 3))\n for i in range(num_samples):\n lambdas = np.random.gamma(self.dir_prior, self.dir_prior, num_faces)\n lambdas = lambdas / sum(lambdas)\n v_sample = lambdas * cone\n v_samples[i, :] = np.sum(v_sample, 1)\n return v_samples","def test_categorical(self):\n with Model() as model:\n Categorical('x', np.array([0.25, 0.75]))\n steps = assign_step_methods(model, [])\n assert isinstance(steps, BinaryGibbsMetropolis)\n with Model() as model:\n Categorical('y', np.array([0.25, 0.70, 0.05]))\n steps = assign_step_methods(model, [])\n assert isinstance(steps, CategoricalGibbsMetropolis)","def trainval_generators(indices, indices_aug, model_type, folder, batch_size, labels, kfold_bool=False):\n #which data to load\n if model_type == \"aug_padding\":\n file_data = os.path.join(absPath, 'data/', folder, 'aug_data.h5')\n indices = indices_aug\n else:\n file_data = os.path.join(absPath, 'data/', folder, 'data.h5')\n h5f = h5py.File(file_data, 'r')\n #now creating batches\n if kfold_bool == False:\n i_train, i_val, i_test = indices\n train_generator = batch_generator(batch_size, file_data, model_type, i_train, labels)\n val_generator = batch_generator(batch_size, file_data, model_type, i_val, labels)\n generators = (train_generator, val_generator)\n else:\n generators = []\n for k_fold in indices:\n i_train, i_val, i_test = k_fold\n train_generator = batch_generator(batch_size, file_data, model_type, i_train, labels)\n val_generator = batch_generator(batch_size, file_data, model_type, i_val, labels)\n generators.append((train_generator, val_generator))\n return generators","def generator_input(filenames, chunk_size, batch_size=64):\n\n feature_cols = None\n while True:\n input_reader = pd.read_csv(\n tf.gfile.Open(filenames[0]),\n names=CSV_COLUMNS,\n chunksize=chunk_size,\n na_values=' ?')\n\n for input_data in input_reader:\n input_data = input_data.dropna()\n # Pop off all of the columns we want to predict and concatenate them\n labels = pd.concat([input_data.pop(x) for x in LABEL_COLUMNS], 1)\n\n input_data = to_numeric_features(input_data, feature_cols)\n\n # Retains schema for next chunk processing.\n if feature_cols is None:\n feature_cols = input_data.columns\n\n idx_len = input_data.shape[0]\n for index in range(0, idx_len, batch_size):\n yield (input_data.iloc[index:min(idx_len, index + batch_size)],\n labels.iloc[index:min(idx_len, index + batch_size)])","def generator(samples, batch_size=32):\n num_samples = len(samples)\n while 1: # Loop forever so the generator never terminates\n samples = sklearn.utils.shuffle(samples)\n for offset in range(0, num_samples, batch_size):\n batch_samples = samples[offset:offset+batch_size]\n\n images = []\n angles = []\n for batch_sample in batch_samples:\n #Because the file path in two folders are different, a if-else is needed.\n if len(batch_sample[0].split('/')) == 2:\n name = './data/IMG/'+batch_sample[0].split('/')[-1]\n else:\n name =batch_sample[0]\n originalImage = cv2.imread(name)\n image = cv2.cvtColor(originalImage, cv2.COLOR_BGR2RGB)\n images.append(image)\n measurement = float(line[3])\n angles.append(measurement)\n \n # Flipping\n images.append(cv2.flip(image,1))\n angles.append(measurement*(-1.0))\n\n # trim image to only see section with road\n inputs = np.array(images)\n outputs = np.array(angles)\n yield sklearn.utils.shuffle(inputs, outputs)"],"string":"[\n \"def _sample_mixtures(self, steps=None, dtype=np.uint):\\n if steps is None:\\n steps = self._sample_steps\\n \\n return _sample_binary_mixtures(self, steps, dtype)\",\n \"def _iterate_mixtures(self):\\n \\n if self._iterate_steps > self.parameters['max_steps']:\\n raise RuntimeError('The iteration would take more than %g steps'\\n % self.parameters['max_steps'])\\n \\n hi = self.commonness\\n Jij = self.correlations\\n\\n mixture_size = self.parameters['fixed_mixture_size']\\n if mixture_size is None:\\n # iterate over all mixtures\\n for c in itertools.product((0, 1), repeat=self.Ns):\\n c = np.array(c, np.uint8)\\n weight_c = np.exp(np.dot(np.dot(Jij, c) + hi, c))\\n yield c, weight_c\\n \\n elif mixture_size == 0:\\n # special case which is not covered by the iteration below\\n yield np.zeros(self.Ns, np.uint8), 1\\n \\n elif mixture_size == self.Ns:\\n # special case which is not covered by the iteration below\\n yield np.ones(self.Ns, np.uint8), 1\\n \\n else:\\n # iterate over all mixtures with constant number of substrates\\n c = np.zeros(self.Ns, np.uint8)\\n for nz in itertools.combinations(range(self.Ns), mixture_size):\\n c[:] = 0\\n c[np.array(nz)] = 1\\n weight_c = np.exp(np.dot(np.dot(Jij, c) + hi, c))\\n yield c, weight_c\",\n \"def data_gen(voc_size, batch, nbatches, seq_len = 15):\\r\\n for i in range(nbatches):\\r\\n # (batch_size, seq_len)\\r\\n data = torch.from_numpy(\\r\\n np.random.randint(1, voc_size, size=(batch, seq_len)))\\r\\n data[:, 0] = 1 # add start token\\r\\n src = Variable(data, requires_grad=False)\\r\\n tgt = Variable(data, requires_grad=False)\\r\\n yield Batch(src, tgt, 0) # Accessed by next function one by one\\r\",\n \"def generate_data(model, n_batches=5, samples_per_batch=200):\\n\\tcalcium, spec, yn_samples, yb_samples = [], [], [], []\\n\\twith torch.no_grad():\\n\\t\\tfor i in range(n_batches):\\n\\t\\t\\tz_sample = torch.randn(samples_per_batch,1,1,model.z_dim).to(model.device)\\n\\t\\t\\tyn_sample = model.sample_yn(z_sample)\\n\\t\\t\\tyb_sample = model.sample_yb(z_sample)\\n\\t\\t\\tc_μ = model.decode_calcium(yn_sample).squeeze()\\n\\t\\t\\tif model.model_type == 'sparse_poe_finch':\\n\\t\\t\\t\\tspec_rec, _ = model.decode_spec(yb_sample)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tspec_rec = model.decode_spec(yb_sample)\\n\\t\\t\\tspec_rec = spec_rec.squeeze()\\n\\t\\t\\tcalcium.append(c_μ)\\n\\t\\t\\tspec.append(spec_rec)\\n\\t\\t\\tyn_samples.append(yn_sample.squeeze(1).squeeze(1))\\n\\t\\t\\tyb_samples.append(yb_sample.squeeze(1).squeeze(1))\\n\\t\\tcalcium = torch.cat(calcium, dim=0).detach().cpu().numpy()\\n\\t\\tspec = torch.cat(spec, dim=0).detach().cpu().numpy()\\n\\t\\tyn_samples = torch.cat(yn_samples, dim=0).detach().cpu().numpy()\\n\\t\\tyb_samples = torch.cat(yb_samples, dim=0).detach().cpu().numpy()\\n\\treturn calcium, spec, yn_samples, yb_samples\",\n \"def data_generator(delta=1, batch_size=32):\\n while True:\\n yield generate_samples(delta=delta, n=batch_size)\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_samples(self, n_samples):\",\n \"def seq_data_iter_sequential(corpus, batch_size, num_steps):\\n # Start with a random offset to partition a sequence\\n offset = random.randint(0, num_steps)\\n num_tokens = ((len(corpus) - offset - 1) // batch_size) * batch_size\\n Xs = torch.tensor(corpus[offset: offset + num_tokens])\\n Ys = torch.tensor(corpus[offset + 1: offset + 1 + num_tokens])\\n Xs, Ys = Xs.reshape(batch_size, -1), Ys.reshape(batch_size, -1)\\n num_batches = Xs.shape[1] // num_steps\\n for i in range(0, num_steps * num_batches, num_steps):\\n X = Xs[:, i: i + num_steps]\\n Y = Ys[:, i: i + num_steps]\\n yield X, Y\",\n \"def _sample_steps(self):\\n mixture_size = self.parameters['fixed_mixture_size']\\n if not self.is_correlated_mixture and mixture_size is None:\\n return self.get_steps('monte_carlo')\\n else:\\n return self.get_steps('metropolis')\",\n \"def seq_data_iter_random(corpus, batch_size, num_steps): #@save\\n # Start with a random offset (inclusive of `num_steps - 1`) to partition a\\n # sequence\\n corpus = corpus[random.randint(0, num_steps - 1):]\\n # Subtract 1 since we need to account for labels\\n num_subseqs = (len(corpus) - 1) // num_steps\\n # The starting indices for subsequences of length `num_steps`\\n initial_indices = list(range(0, num_subseqs * num_steps, num_steps))\\n # In random sampling, the subsequences from two adjacent random\\n # minibatches during iteration are not necessarily adjacent on the\\n # original sequence\\n random.shuffle(initial_indices)\\n\\n def data(pos):\\n # Return a sequence of length `num_steps` starting from `pos`\\n return corpus[pos: pos + num_steps]\\n\\n num_batches = num_subseqs // batch_size\\n for i in range(0, batch_size * num_batches, batch_size):\\n # Here, `initial_indices` contains randomized starting indices for\\n # subsequences\\n initial_indices_per_batch = initial_indices[i: i + batch_size]\\n X = [data(j) for j in initial_indices_per_batch]\\n Y = [data(j + 1) for j in initial_indices_per_batch]\\n yield torch.tensor(X), torch.tensor(Y)\",\n \"def create_mixture_csv(data_type):\\n \\n workspace = config.workspace\\n data_dir = config.data_dir\\n speech_dir = os.path.join(data_dir,'{}_speech'.format(data_type))\\n noise_dir = os.path.join(data_dir,'{}_noise'.format(data_type)) \\n magnification = config.magnification\\n fs = config.sample_rate\\n \\n speech_names = [na for na in os.listdir(speech_dir) if na.lower().endswith(\\\".wav\\\")]\\n noise_names = [na for na in os.listdir(noise_dir) if na.lower().endswith(\\\".wav\\\")]\\n \\n rs = np.random.RandomState(0)\\n out_csv_path = os.path.join(workspace, \\\"mixture_csvs\\\", \\\"%s.csv\\\" % data_type)\\n create_folder(os.path.dirname(out_csv_path))\\n \\n cnt = 0\\n f = open(out_csv_path, 'w')\\n f.write(\\\"%s\\\\t%s\\\\t%s\\\\t%s\\\\n\\\" % (\\\"speech_name\\\", \\\"noise_name\\\", \\\"noise_onset\\\", \\\"noise_offset\\\"))\\n for speech_na in speech_names:\\n # Read speech. \\n speech_path = os.path.join(speech_dir, speech_na)\\n (speech_audio, _) = read_audio(speech_path)\\n len_speech = len(speech_audio)\\n \\n # For training data, mix each speech with randomly picked #magnification noises. \\n if data_type == 'train':\\n selected_noise_names = rs.choice(noise_names, size=magnification, replace=False)\\n # For test data, mix each speech with all noises. \\n elif data_type == 'test':\\n selected_noise_names = noise_names\\n else:\\n raise Exception(\\\"data_type must be train | test!\\\")\\n\\n # Mix one speech with different noises many times. \\n for noise_na in selected_noise_names:\\n noise_path = os.path.join(noise_dir, noise_na)\\n (noise_audio, _) = read_audio(noise_path)\\n \\n len_noise = len(noise_audio)\\n\\n if len_noise <= len_speech:\\n noise_onset = 0\\n nosie_offset = len_speech\\n # If noise longer than speech then randomly select a segment of noise. \\n else:\\n noise_onset = rs.randint(0, len_noise - len_speech, size=1)[0]\\n nosie_offset = noise_onset + len_speech\\n \\n if cnt % 100 == 0:\\n print(cnt)\\n \\n cnt += 1\\n f.write(\\\"%s\\\\t%s\\\\t%d\\\\t%d\\\\n\\\" % (speech_na, noise_na, noise_onset, nosie_offset))\\n f.close()\\n print(out_csv_path)\\n print(\\\"Create %s mixture csv finished!\\\" % data_type)\",\n \"def trainDataGenerator(num_epochs):\\r\\n samples, all_files = get_filenames()\\r\\n for num in range(num_epochs):\\r\\n for i in range(len(samples)):\\r\\n sample = samples[i]\\r\\n for file in all_files[i]:\\r\\n ohvs, Y = prepData(sample, file)\\r\\n if (ohvs == []):\\r\\n continue\\r\\n X = np.array([ohvs[:800]])\\r\\n yield X, Y\\r\\n # for i in range(0, len(ohvs), 400):\\r\\n # X = np.array([ohvs[i : i+400]])\\r\\n # print(\\\"\\\\tX shape =\\\", X.shape)\\r\\n # yield X, Y\\r\",\n \"def create_step_samples(self):\\n pass # Deferred to subclasses\\n\\n \\\"\\\"\\\" Example using pod height:\\n start_value = self.sim.pod.last_height\\n end_value = self.sim.pod.height\\n\\n # Lerp values to get samples\\n samples = start_value + self.step_lerp_pcts * (end_value - start_value) # Or use self.lerp(start_value, end_value), but doing it directly is faster since no function call\\n if self.noise_scale > 0:\\n # Add gaussian noise if specified\\n return samples + np.random.normal(0.0, noise_scale, len(samples))\\n else:\\n # No noise\\n return samples \\n \\\"\\\"\\\"\",\n \"def calculate_mixture_features(data_type):\\n workspace = config.workspace\\n data_dir = config.data_dir\\n speech_dir = os.path.join(data_dir,'{}_speech'.format(data_type))\\n noise_dir = os.path.join(data_dir,'{}_noise'.format(data_type)) \\n \\n fs = config.sample_rate\\n \\n if data_type == 'train':\\n snr = config.Tr_SNR\\n elif data_type == 'test':\\n snr = config.Te_SNR \\n else:\\n raise Exception(\\\"data_type must be train | test!\\\")\\n \\n \\n # Open mixture csv. \\n mixture_csv_path = os.path.join(workspace, \\\"mixture_csvs\\\", \\\"%s.csv\\\" % data_type)\\n with open(mixture_csv_path, 'r') as f:\\n reader = csv.reader(f, delimiter='\\\\t')\\n lis = list(reader)\\n \\n t1 = time.time()\\n cnt = 0\\n for i1 in range(1, len(lis)):\\n [speech_na, noise_na, noise_onset, noise_offset] = lis[i1]\\n noise_onset = int(noise_onset)\\n noise_offset = int(noise_offset)\\n \\n # Read speech audio. \\n speech_path = os.path.join(speech_dir, speech_na)\\n (speech_audio, _) = read_audio(speech_path, target_fs=fs)\\n \\n # Read noise audio. \\n noise_path = os.path.join(noise_dir, noise_na)\\n (noise_audio, _) = read_audio(noise_path, target_fs=fs)\\n \\n # Repeat noise to the same length as speech. \\n if len(noise_audio) < len(speech_audio):\\n n_repeat = int(np.ceil(float(len(speech_audio)) / float(len(noise_audio))))\\n noise_audio_ex = np.tile(noise_audio, n_repeat)\\n noise_audio = noise_audio_ex[0 : len(speech_audio)]\\n # Truncate noise to the same length as speech. \\n else:\\n noise_audio = noise_audio[noise_onset : noise_offset]\\n \\n # Scale speech to given snr. \\n scaler = get_amplitude_scaling_factor(speech_audio, noise_audio, snr=snr)\\n speech_audio *= scaler\\n \\n # Get normalized mixture, speech, noise. \\n (mixed_audio, speech_audio, noise_audio, alpha) = additive_mixing(speech_audio, noise_audio)\\n\\n # Write out mixed audio. \\n out_bare_na = os.path.join(\\\"%s.%s\\\" % \\n (os.path.splitext(speech_na)[0], os.path.splitext(noise_na)[0]))\\n out_audio_path = os.path.join(workspace, \\\"mixed_audios\\\", \\\"spectrogram\\\", \\n data_type, \\\"%ddb\\\" % int(snr), \\\"%s.wav\\\" % out_bare_na)\\n create_folder(os.path.dirname(out_audio_path))\\n write_audio(out_audio_path, mixed_audio, fs)\\n\\n # Extract spectrogram. \\n mixed_complx_x = calc_sp(mixed_audio, mode='complex')\\n speech_x = calc_sp(speech_audio, mode='magnitude')\\n noise_x = calc_sp(noise_audio, mode='magnitude')\\n\\n # Write out features. \\n out_feat_path = os.path.join(workspace, \\\"features\\\", \\\"spectrogram\\\", \\n data_type, \\\"%ddb\\\" % int(snr), \\\"%s.p\\\" % out_bare_na)\\n create_folder(os.path.dirname(out_feat_path))\\n data = [mixed_complx_x, speech_x, noise_x, alpha, out_bare_na]\\n pickle.dump(data, open(out_feat_path, 'wb'), protocol=pickle.HIGHEST_PROTOCOL)\\n \\n # Print. \\n if cnt % 100 == 0:\\n print(cnt)\\n \\n cnt += 1\\n\\n print(\\\"Extracting feature time: %s\\\" % (time.time() - t1))\",\n \"def sample(model, x, steps, temperature=1.0, sample=False, top_k=None):\\n block_size = model.get_block_size()\\n model.eval()\\n for k in range(steps):\\n x_cond = x if x.size(1) <= block_size else x[:, -block_size:] # crop context if needed\\n logits, _ = model(x_cond)\\n # pluck the logits at the final step and scale by temperature\\n logits = logits[:, -1, :] / temperature\\n # optionally crop probabilities to only the top k options\\n if top_k is not None:\\n logits = top_k_logits(logits, top_k)\\n # apply softmax to convert to probabilities\\n probs = F.softmax(logits, dim=-1)\\n # sample from the distribution or take the most likely\\n if sample:\\n ix = torch.multinomial(probs, num_samples=1)\\n else:\\n _, ix = torch.topk(probs, k=1, dim=-1)\\n # append to the sequence and continue\\n x = torch.cat((x, ix), dim=1)\\n\\n return x\",\n \"def gen(num_batches,\\n batch_size,\\n seq_width,\\n min_len,\\n max_len):\\n for batch_num in range(num_batches):\\n\\n # All batches have the same sequence length\\n seq_len = random.randint(min_len, max_len)\\n seq = np.random.binomial(1, 0.5, (seq_len, batch_size, seq_width))\\n seq = Variable(torch.from_numpy(seq))\\n\\n # The input includes an additional channel used for the delimiter\\n inp = Variable(torch.zeros(seq_len + 1, batch_size, seq_width + 1))\\n inp[:seq_len, :, :seq_width] = seq\\n inp[seq_len, :, seq_width] = 1.0 # delimiter in our control channel\\n outp = seq.clone()\\n\\n yield batch_num+1, inp.float().to(params.device), outp.float().to(params.device)\",\n \"def gen_mixture():\\n npr.seed(0)\\n num_exp = int(1e4)\\n x_dim = 2\\n z_dim = 2\\n mu1 = [5, 5,]\\n mu2 = [-5, -5]\\n theta = np.array([[2,1],[-1,-2]])\\n sigma = 0.1\\n u = npr.uniform((num_exp,))\\n z = np.zeros((num_exp, z_dim))\\n cov = np.zeros((z_dim, z_dim))\\n np.fill_diagonal(cov, 1)\\n sz = int(num_exp/2)\\n z[:sz, ]= npr.multivariate_normal(mu1, cov,sz)\\n z[sz:, ] = npr.multivariate_normal(mu2,cov,sz)\\n mu_x = theta@z.transpose()\\n\\n x = np.zeros((num_exp, x_dim))\\n for i in range(num_exp):\\n x[i,:] = npr.multivariate_normal(mu_x[:,i], sigma*cov)\\n print(x.shape)\\n np.save('data/syn_mixture.npy', x)\",\n \"def bootstrap_sample_generator_3D(samples: Union[NumpyFloatArray, NumpyIntArray]):\\n n_samples = samples.shape[1]\\n array_shape = samples.shape[1:]\\n num_cols = samples.shape[2]\\n cols = np.arange(num_cols)\\n\\n while True:\\n _indices = np.random.randint(0, high=n_samples, size=array_shape)\\n\\n yield samples[:, _indices, cols]\",\n \"def generate(model, n_samples, device, shape, levels):\\n channels, height, width = shape[1], shape[2], shape[3]\\n x_shapes = create_x_shapes(channels, height, width, levels)\\n temperature = 0.7\\n x_sample = []\\n for ch, h, w in x_shapes:\\n x_random = torch.randn(n_samples, ch, h, w) * temperature\\n x_sample.append(x_random.to(device))\\n x = model.reverse(x_sample)\\n #x /= 0.6 # attempt to make it brighter, seen as rescaling it to reverse the effect of using temperature\\n return x\",\n \"def generate_samples(model, num_samples, latent):\\n\\n noise = tf.random.normal([num_samples, latent])\\n samples = model(noise)[:, :, 0]\\n return np.array(samples)\",\n \"def data_gen(\\n v: int, batch: int, nbatches: int, device: torch.device = torch.device(\\\"cpu\\\")\\n) -> Iterator[Batch]: # TODO bad name\\n for i in range(nbatches):\\n data = np.random.randint(1, v, size=(batch, 10))\\n data[:, 0] = 1\\n src: LongTensorType = torch.from_numpy(data)\\n tgt: LongTensorType = torch.from_numpy(data)\\n src, tgt = src.to(device), tgt.to(device)\\n yield Batch(src, tgt, 0)\",\n \"def generate(self, num_steps):\\n music = []\\n with tf.variable_scope('batch_size'):\\n batch_size = tf.shape(self._inputs)[0]\\n\\n intro_states = []\\n # Generators' forward pass\\n for i in range(self.num_tracks):\\n with tf.variable_scope(f'inputs/{self.tracks[i]}'):\\n inputs = tf.concat([self._x_encoded[i], self._x_feedback], axis=-1)\\n\\n with tf.variable_scope(f'intro_state/{self.tracks[i]}'):\\n state = self.generators[i].steps(inputs)\\n intro_states.append(state)\\n\\n #\\n with tf.variable_scope('feedback_sampler'):\\n samples_h, _, _ = tf.scan(\\n self._feedback_recurrence,\\n tf.zeros((num_steps, 1)),\\n initializer=(\\n tf.zeros((batch_size, self._num_dims_generator, self.num_tracks)),\\n intro_states,\\n self._feedback_final_state)\\n )\\n\\n with tf.variable_scope('samples/encoded/'):\\n samples_h = tf.unstack(tf.transpose(samples_h, [1, 0, 2, 3]), axis=-1)\\n\\n for i in range(self.num_tracks):\\n # Decoding inputs into the original format\\n with tf.variable_scope(f'samples/{self.tracks[i]}/'):\\n _, samples = self.encoders[i].decode(samples_h[i])\\n\\n music.append(samples)\\n\\n with tf.variable_scope('samples/'):\\n return tf.stack(music, axis=3, name='music')\",\n \"def generate_fake_samples(generator_model : Model, dataset : np.ndarray, patch_shape : int) -> np.ndarray:\\n X = generator_model.predict(dataset)\\n y = generate_patch_labels(len(X), patch_shape, label=0)\\n return X, y\",\n \"def __getitem__(self, item):\\n c_ex = self.examples[item]\\n # randomly select ref mic\\n mics = [x for x in c_ex.keys()]\\n if self.train:\\n np.random.shuffle(mics) # randomly permute during training to change ref mics\\n\\n mixtures = []\\n sources = []\\n for i in range(len(mics)):\\n c_mic = c_ex[mics[i]]\\n\\n if self.segment:\\n offset = 0\\n if c_mic[\\\"length\\\"] > int(self.segment * self.sample_rate):\\n offset = np.random.randint(\\n 0, c_mic[\\\"length\\\"] - int(self.segment * self.sample_rate)\\n )\\n\\n # we load mixture\\n mixture, fs = sf.read(\\n c_mic[\\\"mixture\\\"],\\n start=offset,\\n stop=offset + int(self.segment * self.sample_rate),\\n dtype=\\\"float32\\\",\\n )\\n spk1, fs = sf.read(\\n c_mic[\\\"spk1\\\"],\\n start=offset,\\n stop=offset + int(self.segment * self.sample_rate),\\n dtype=\\\"float32\\\",\\n )\\n spk2, fs = sf.read(\\n c_mic[\\\"spk2\\\"],\\n start=offset,\\n stop=offset + int(self.segment * self.sample_rate),\\n dtype=\\\"float32\\\",\\n )\\n else:\\n mixture, fs = sf.read(c_mic[\\\"mixture\\\"], dtype=\\\"float32\\\") # load all\\n spk1, fs = sf.read(c_mic[\\\"spk1\\\"], dtype=\\\"float32\\\")\\n spk2, fs = sf.read(c_mic[\\\"spk2\\\"], dtype=\\\"float32\\\")\\n\\n mixture = torch.from_numpy(mixture).unsqueeze(0)\\n spk1 = torch.from_numpy(spk1).unsqueeze(0)\\n spk2 = torch.from_numpy(spk2).unsqueeze(0)\\n\\n assert fs == self.sample_rate\\n mixtures.append(mixture)\\n sources.append(torch.cat((spk1, spk2), 0))\\n\\n mixtures = torch.cat(mixtures, 0)\\n sources = torch.stack(sources)\\n # we pad till max_mic\\n valid_mics = mixtures.shape[0]\\n if mixtures.shape[0] < self.max_mics:\\n dummy = torch.zeros((self.max_mics - mixtures.shape[0], mixtures.shape[-1]))\\n mixtures = torch.cat((mixtures, dummy), 0)\\n sources = torch.cat((sources, dummy.unsqueeze(1).repeat(1, sources.shape[1], 1)), 0)\\n return mixtures, sources, valid_mics\",\n \"def batch_generator(batch_size, sequence_length,\\n x_train_scaled, y_train_scaled, num_x_signals, num_y_signals, num_train):\\n # Infinite loop.\\n while True:\\n # Allocate a new array for the batch of input-signals.\\n x_shape = (batch_size, sequence_length, num_x_signals)\\n x_batch = np.zeros(shape=x_shape, dtype=np.float16)\\n\\n # Allocate a new array for the batch of output-signals.\\n y_shape = (batch_size, sequence_length, num_y_signals)\\n y_batch = np.zeros(shape=y_shape, dtype=np.float16)\\n\\n # Fill the batch with random sequences of data.\\n for i in range(batch_size):\\n # Get a random start-index.\\n # This points somewhere into the training-data.\\n idx = np.random.randint(num_train - sequence_length)\\n\\n # Copy the sequences of data starting at this index.\\n x_batch[i] = x_train_scaled[idx:idx + sequence_length]\\n y_batch[i] = y_train_scaled[idx:idx + sequence_length]\\n yield x_batch, y_batch\\n # return x_batch, y_batch\",\n \"def my_generator(batch_size, img_dir):\\n cat_dirs = glob.glob(img_dir + \\\"/*\\\")\\n counter = 0\\n while True:\\n input_images = np.zeros(\\n (batch_size, config.height, config.width, 3 * 5))\\n output_images = np.zeros((batch_size, config.height, config.width, 3))\\n random.shuffle(cat_dirs)\\n if (counter+batch_size >= len(cat_dirs)):\\n counter = 0\\n for i in range(batch_size):\\n input_imgs = glob.glob(cat_dirs[counter + i] + \\\"/cat_[0-4]*\\\") \\n imgs = [Image.open(img) for img in sorted(input_imgs)]\\n input_images[i] = np.concatenate(imgs, axis=2)\\n output_imgs = glob.glob(cat_dirs[counter + i] + \\\"/cat_[5-7]*\\\")\\n imgs = [Image.open(img) for img in sorted(output_imgs)]\\n output_images[i] = np.concatenate(imgs, axis=1)\\n input_images[i] /= 255.\\n output_images[i] /= 255.\\n yield (input_images, output_images)\\n counter += batch_size\",\n \"def generate_samples(mu1,cov,number_of_samples):\\n samples = np.random.multivariate_normal(mu1, cov,number_of_samples)\\n return samples\",\n \"def collect_data(self, cue_size=10, sigma=0.1, test_factors=[2], \\n cue_offset=9*pi/8, **kwargs):\\n self.results['cue_size'] = cue_size = (pi/180) * cue_size\\n self.results['cue_offset'] = cue_offset\\n self.results['test_factors'] = test_factors = [0, 1] + test_factors\\n self.results['sigma'] = sigma\\n \\n # Set up model parameters\\n pdict = dict( N_outputs=500, \\n N_theta=1000,\\n C_W=0.05,\\n N_cues_local=1, \\n N_cues_distal=1, \\n local_cue_std=cue_size,\\n cue_offset=cue_offset,\\n init_random=False,\\n gamma_distal=0, \\n num_trials=2*len(test_factors),\\n monitoring=True )\\n pdict.update(kwargs)\\n \\n # Create the simulation object and save the cue peak (gamma)\\n self.out('Running training simulation...')\\n model = VMONoiseModel(**pdict)\\n if 'T' in kwargs:\\n model.T = kwargs['T']\\n cue_gamma = model.gamma_local\\n \\n # Simulate the phase noise test trials without, then with, cue\\n for gamma in 0.0, cue_gamma:\\n model.gamma_local = gamma\\n for factor in test_factors:\\n model.sigma = sigma * factor\\n model.advance()\\n \\n # Compute responses and save session data\\n self.out('Computing and saving session data files...')\\n sessions = VMOSession.get_session_list(model)\\n VMOSession.save_session_list(sessions, os.path.join(self.datadir, 'sessions'))\\n \\n # Save raw simulation data file and clean up\\n model.post_mortem().tofile(os.path.join(self.datadir, 'data'))\\n \\n # Compute population and population lap matrices and save to data directory\\n self.out('Computing and saving population responses...')\\n clusts = np.arange(pdict['N_outputs'])\\n R = [SD.get_population_matrix(clusters=clusts, inplace=True) for SD in sessions]\\n R_laps = [SD.get_population_lap_matrix(clusters=clusts, inplace=True) for SD in sessions]\\n np.save(os.path.join(self.datadir, 'R_session'), np.asarray(R))\\n np.save(os.path.join(self.datadir, 'R_laps'), np.asarray(R_laps))\\n \\n # All done!\\n self.out('Good bye!')\",\n \"def generator(data_dir, samples, batch_size=32):\\n num_samples = len(samples)\\n while 1:\\n sklearn.utils.shuffle(samples)\\n for offset in range(0, num_samples, batch_size):\\n batch_samples = samples[offset:offset+batch_size]\\n\\n images = []\\n measurements = []\\n for batch_sample in batch_samples:\\n filename = csv_log_to_image_filename(data_dir,\\n batch_sample[0])\\n image = cv2.imread(filename)\\n if image is not None:\\n images.append(image)\\n measurements.append(batch_sample[1])\\n else:\\n print(\\\"File \\\" + filename + \\\" is missing.\\\")\\n\\n X_data = np.array(images)\\n y_data = np.array(measurements)\\n yield sklearn.utils.shuffle(X_data, y_data)\",\n \"def _generate(self, **kwargs):\\n self._samples = numpy.array(list(itertools.product(*self.parameter_schema.values())), dtype=object)\\n super()._generate()\",\n \"def cal_samples(self):\\n max_omega = max(\\n abs(2 * np.pi * self.u.fundamental),\\n abs(2 * np.pi * self.v.fundamental),\\n abs(2 * np.pi * self.w.fundamental),\\n )\\n max_freq = max_omega / (2 * np.pi)\\n self.fake_samples_number = (\\n (max_freq ** 2) * 6 * self.u.data.shape[0] / self.u.sampling_rate\\n )\",\n \"def _encode_samples(self, batch_size):\\n return np.array(random.choices(self.data,\\n [i[1] for i in self.data],\\n k=batch_size))\",\n \"def _get_samples(batch_shape, state_dim, transitions, sample_shape) -> np.ndarray:\\n ssm, _ = StateSpaceModelBuilder(batch_shape, state_dim, transitions).build()\\n\\n return ssm.sample(sample_shape).numpy()\",\n \"def pc_sampler(model):\\n with torch.no_grad():\\n # Initial sample\\n x = sde.prior_sampling(shape).to(device)\\n timesteps = torch.linspace(1, eps, sde.N, device=device)\\n\\n for i in range(sde.N):\\n t = timesteps[i]\\n vec_t = torch.ones(shape[0], device=t.device) * t\\n x, x_mean = corrector_update_fn(x, vec_t, model=model)\\n x, x_mean = predictor_update_fn(x, vec_t, model=model)\\n\\n return x_mean if denoise else x, sde.N * (n_steps + 1)\",\n \"def signal_generator(patient_generator, frame_size=2048, samples_per_patient=1):\\n for _, (signal, _) in patient_generator:\\n num_segments, segment_size = signal.shape\\n for _ in range(samples_per_patient):\\n # randomly choose a frame that lies within the segment i.e. no zero-padding is necessary\\n segment_index = np.random.randint(num_segments)\\n frame_start = np.random.randint(segment_size - frame_size)\\n frame_end = frame_start + frame_size\\n x = signal[segment_index, frame_start:frame_end]\\n x = np.expand_dims(x, axis=1) # add channel dimension\\n yield x\",\n \"def varying_noise_continuous_ndim_without_category(self, figure, iteration, order, total_continuous_dim, result_path):\\n\\n continuous_sample_points = np.linspace(-2.0, 2.0, 20)\\n #a specific noise factor will be varied with 10 steps.\\n\\n num_points, steps = 10, len(continuous_sample_points)\\n # each step has points with randomly-sampled other noise factor\\n\\n\\n continuous_noise = []\\n for _ in range(num_points):\\n cur_sample = np.random.normal(size=[1, total_continuous_dim])\\n continuous_noise.extend([cur_sample]*steps)\\n continuous_noise = np.concatenate(continuous_noise)\\n\\n varying_factor = np.tile(continuous_sample_points, num_points)\\n continuous_noise[:, order] = varying_factor \\n continuous_noise = np.float32(continuous_noise)\\n \\n display_images = []\\n with variable_scope.variable_scope(self.gen_scope.name, reuse = True):\\n varying_data = self.generator(continuous_noise)\\n\\n #colors = cm.rainbow(np.linspace(0, 1, len(continuous_sample_points)))\\n colors = [ ( 1/(i%steps + 1), 0, (i%steps + 1)/steps, 1) for i in range( continuous_noise.shape[0] )] #red to green\\n\\n scales = [ (1.1**(i%steps + 1))*10 for i in range( continuous_noise.shape[0] )]\\n\\n gen_data_test = self.sess.run(varying_data)\\n ax1 = figure\\n ax1.scatter(gen_data_test[:, 0], gen_data_test[:, 1], s=scales, c=(0, 0, 0))\\n\\n for i, factor in enumerate(continuous_noise[:, order]):\\n ax1.annotate(str(round(factor, 2)), (gen_data_test[i, 0], gen_data_test[i, 1]), color=colors[i])\",\n \"def concoct_dataset(n_per_label, feat_specs, sigma=0, shuffle=True):\\n samples = dict((label, [list() for i in range(n)]) for (label,n) in enumerate(n_per_label))\\n for feat_spec in feat_specs:\\n for (label, breakdown) in enumerate(feat_spec):\\n if shuffle: random.shuffle(samples[label])\\n s = 0\\n for (value, n_per_value) in enumerate(breakdown):\\n if s+n_per_value > len(samples[label]): raise Exception(str(feat_spec)+' has too many samples')\\n for i in range(n_per_value):\\n samples[label][s+i].append(np.random.normal(value, sigma))\\n s += n_per_value\\n if s < len(samples[label]): raise Exception(str(feat_spec)+' has too few samples')\\n print(samples)\\n return [ExpressionProfile(str(i),str(label),values) for (label, value_sets) in samples.items() for (i,values) in enumerate(value_sets)]\",\n \"def sample_for_inception(model, encoder, batch_size, dataloader, device):\\n\\n captions = []\\n gen_imgs = []\\n # get sample captions\\n done = False\\n while not done:\\n for (_, labels_batch, captions_batch) in dataloader:\\n captions += captions_batch\\n conditional_embeddings = encoder(labels_batch.to(device), captions)\\n imgs = model.sample(conditional_embeddings).cpu()\\n gen_imgs.append(imgs)\\n\\n if len(captions) > batch_size:\\n done = True\\n break\\n\\n gen_imgs = torch.cat(gen_imgs).numpy()\\n gen_imgs = np.clip(gen_imgs, 0, 1)\\n return(gen_imgs)\",\n \"def sample_mcd(model: 'BaseModel', data: Dict[str, torch.Tensor], n_samples: int,\\n scaler: Dict[str, Union[pd.Series, xarray.Dataset]]) -> Dict[str, torch.Tensor]:\\n setup = _SamplingSetup(model, data, model.cfg.head)\\n\\n # force model into train mode for mc_dropout:\\n if setup.mc_dropout:\\n model.train()\\n\\n # sample for different frequencies and targets:\\n samples = {}\\n for freq_suffix in setup.freq_suffixes:\\n sample_points = []\\n frequency_last_n = setup._get_frequency_last_n(freq_suffix=freq_suffix)\\n\\n for nth_target in range(setup.number_of_targets):\\n # unbound sampling:\\n def _sample_values(ids: List[int]) -> torch.Tensor:\\n # The ids are used for location-specific resampling for 'truncation' in '_handle_negative_values'\\n target_values = torch.zeros(len(ids), frequency_last_n, n_samples)\\n for i in range(n_samples): # forward-pass for each frequency separately to guarantee independence\\n prediction = model(data)\\n value_buffer = prediction[f'y_hat{freq_suffix}'][:, -frequency_last_n:, 0]\\n target_values[ids, -frequency_last_n:, i] = value_buffer.detach().cpu()\\n return target_values\\n\\n ids = list(range(data[f'x_d{freq_suffix}'].shape[0]))\\n values = _sample_values(ids)\\n\\n # bind values and add to sample_points:\\n values = _handle_negative_values(setup.cfg, values, _sample_values, scaler, nth_target)\\n sample_points.append(values)\\n\\n # add sample_points to dictionary of samples:\\n freq_key = f'y_hat{freq_suffix}'\\n samples.update({freq_key: torch.stack(sample_points, 2)})\\n\\n return samples\",\n \"def generate_continuous_data_and_targets(\\n n_dim,\\n n_samples,\\n mixing_factor=0.025,\\n frac_positive=0.1):\\n cov = generate_positive_semi_definite_matrix(n_dim)\\n X = np.random.multivariate_normal(\\n mean=np.zeros(n_dim),\\n cov=cov,\\n size=n_samples)\\n weights = np.random.randn(n_dim)\\n y_probs = sigmoid(mixing_factor * np.dot(X, weights))\\n y = np.random.binomial(1, p=y_probs)\\n X, y = subsample(X, y, frac_positive)\\n return X, y\",\n \"def trainCartGenerator(self,):\\n return tf.data.Dataset.from_generator(self.trainDataCart, \\\\\\n output_types=(tf.float32, tf.float32, tf.float32), \\\\\\n output_shapes=(tf.TensorShape(self.config_model[\\\"input_shape\\\"]), \\\\\\n tf.TensorShape(list(self.cart_shape[1:3]) + \\\\\\n [len(self.anchor_boxes_cart)] + \\\\\\n [len(self.config_data[\\\"all_classes\\\"]) + 5]), \\n tf.TensorShape([self.config_data[\\\"max_boxes_per_frame\\\"], 5]) \\\\\\n ), )\",\n \"def generate_batch(self, batch_size=8, shuffle=True):\\n if self._contour_dicom_folder:\\n contour_files = glob(os.path.join(self._contour_dicom_folder, \\\"*.h5\\\"))\\n if shuffle:\\n contour_files = np.random.permutation(contour_files)\\n contours_generator = self._contour_folder_gen(contour_files)\\n else:\\n contours_generator = self._contour_dicom_generator\\n\\n x_batch, y_batch, sources_batch = [], [], []\\n batch_idx = 0\\n for idx, (dataset, sources) in enumerate(contours_generator):\\n if batch_idx > 0 and batch_idx % batch_size == 0:\\n if self._include_sources:\\n yield sources_batch, np.array(x_batch), np.array(y_batch)\\n else:\\n yield np.array(x_batch), np.array(y_batch)\\n x_batch, y_batch, sources_batch = [], [], []\\n batch_idx = 0\\n try:\\n x_data = self._parse_channels(dataset, self.x_channels)\\n y_data = self._parse_channels(dataset, self.y_channels)\\n x_batch.append(x_data)\\n y_batch.append(y_data)\\n sources_batch.append(sources)\\n batch_idx += 1\\n except ValueError:\\n # Log Error\\n err_msg = \\\"Missing all channels in {}\\\".format(sources[\\\"filename\\\"])\\n self._log_error(err_msg)\\n\\n if self._include_sources:\\n yield sources_batch, np.array(x_batch), np.array(y_batch)\\n else:\\n yield np.array(x_batch), np.array(y_batch)\",\n \"def generate_train_data(comps: List[pd.DataFrame], concen_upper_bound=1000, num_per_combination=1000):\\n cps = [to_int_index(c) for c in comps]\\n cps = [zero_end_interpolation(c) for c in comps]\\n cps = alignment(cps)\\n cps = [scale_dataframe(c) for c in cps]\\n\\n samples = []\\n for n_class in range(1, len(cps) + 1):\\n comps_roller = ComponentRoller(cps, n_class)\\n concen_roller = ConcentrationRoller(1, concen_upper_bound, n_class)\\n for i in range(num_per_combination):\\n picked_comps, label = comps_roller.roll()\\n concen_vector = concen_roller.roll_unique(label)\\n the_sample = pd.Series(name=label, data=np.sum(picked_comps * concen_vector, axis=1))\\n samples.append(the_sample)\\n if i % 100 == 0:\\n print('组合数{}: 第{}个样本 --- 标签{}，浓度比{}'.format(n_class, i, label, concen_vector))\\n df = pd.concat(samples, axis=1)\\n return df.values.T, np.array(_to_vectors(df.columns.tolist()))\",\n \"def testCartGenerator(self,):\\n return tf.data.Dataset.from_generator(self.testDataCart, \\\\\\n output_types=(tf.float32, tf.float32, tf.float32), \\\\\\n output_shapes=(tf.TensorShape(self.config_model[\\\"input_shape\\\"]), \\\\\\n tf.TensorShape(list(self.cart_shape[1:3]) + \\\\\\n [len(self.anchor_boxes_cart)] + \\\\\\n [len(self.config_data[\\\"all_classes\\\"]) + 5]), \\n tf.TensorShape([self.config_data[\\\"max_boxes_per_frame\\\"], 5]) \\\\\\n ), )\",\n \"def sample(self, batchsize, *args, **kwargs):\\n raise NotImplementedError\",\n \"def RandomDataloader(num_batches,\\n batch_size,\\n seq_width,\\n min_len,\\n max_len):\\n for batch_num in range(num_batches):\\n\\n # All batches have the same sequence length\\n seq_len = random.randint(min_len, max_len)\\n seq = np.random.binomial(1, 0.5, (seq_len, batch_size, seq_width))\\n seq = torch.from_numpy(seq)\\n\\n # The input includes an additional channel used for the delimiter\\n inp = torch.zeros(seq_len + 1, batch_size, seq_width + 1)\\n inp[:seq_len, :, :seq_width] = seq\\n inp[seq_len, :, seq_width] = 1.0 # delimiter in our control channel\\n outp = seq.clone()\\n\\n yield inp.float(), outp.float()\",\n \"def next_sample(self, batch_size=1):\\n\\n X = []\\n y = []\\n\\n for count in range(batch_size):\\n #check for abrupt drift\\n if count % self.abrupt_drift_rate == 0:\\n dimfaks = [round(np.random.rand() * 4, 1) for _ in range(self.dims)]\\n dimpots = [1 + round(np.random.rand() * 2) for _ in range(self.dims)]\\n dimvars = [np.random.rand() * self.var for _ in range(self.dims)]\\n dimmeans = [5 + np.random.rand() * 10 for _ in range(self.dims)]\\n print(\\\"Random Polynomconcept: \\\", end=\\\"\\\")\\n for i in range(self.dims):\\n print(dimfaks[i],\\\" * x\\\", i+1, \\\"^\\\", dimpots[i], \\\" + \\\",end=\\\"\\\", sep=\\\"\\\")\\n print()\\n\\n value = 0\\n sample = []\\n for i in range(self.dims):\\n sample.append(np.random.normal(loc=dimmeans[i], scale=dimvars[i]))\\n value += dimfaks[i] * (sample[i] ** dimpots[i])\\n \\n X.append(sample)\\n y.append(value)\\n\\n self._x_idx += batch_size\\n\\n return (X, y)\",\n \"def get_data(self):\\n if self.random_seeds: \\n self._validate_random_seeds()\\n seed_iter = list(map(iter,self.random_seeds))\\n nsamples = len(self.random_seeds[0])\\n else:\\n seed_iter = None\\n nsamples = self.numsamples\\n self._set_meta_features()\\n for _ in tqdm(range(nsamples)):\\n self._update_meta_features(seed_iter)\\n self._sample()\\n yield self._extract_features()\",\n \"def makegenerators(self, adata, val_split, batch_size, splitseed):\\n \\n return countloader(adata.obsm[self.embed_name], adata.X[:, adata.var['Variance Type'] == self.mode], adata.obs['size factors'], \\n val_split, batch_size, splitseed)\",\n \"def next_simple_dataset(dataset, batch_size: int, datatype):\\n while True:\\n x_batch = []\\n y_batch = []\\n for i in range(batch_size):\\n try:\\n x, y, data_unit, index = create_xy(dataset, datatype)\\n # x = normalize(x)\\n x_batch.append(x)\\n y_batch.append(y)\\n except StopIteration:\\n break\\n x_batch, y_batch = np.array(x_batch), np.array(y_batch)\\n if datatype != DataType.test:\\n x_batch = SEQ_CVXTZ.augment_images(x_batch).astype(\\\"float32\\\")\\n x_batch = np.array([normalize(x) for x in x_batch])\\n # org_shape = x_batch.shape\\n # org_width = x_batch.shape[1]\\n # corner = int((org_width - ROI_IMAGE_SIZE) // 2)\\n # print(f\\\"0: org_shape:{org_shape} x_batch:{x_batch.shape} corner:{corner}\\\")\\n # x_batch = x_batch[:, corner:(org_width - corner), corner:(org_width - corner), :]\\n # resized_x_batch = []\\n # for x in x_batch:\\n # img = Image.fromarray(np.uint8(x))\\n # img = img.resize((IMAGE_SIZE, IMAGE_SIZE), Image.LANCZOS)\\n # resized_x_batch.append(normalize(np.array(img)))\\n # print(f\\\"1: org_shape:{org_shape} corner:{corner} x_batch:{x_batch.shape}\\\")\\n # yield np.array(resized_x_batch), y_batch\\n yield np.array(x_batch), y_batch\",\n \"def data_source():\\n dataset = [0.1, 0.2, 0.3, 0.4, 0.5]\\n while True:\\n time.sleep(2)\\n yield random.choice(dataset)\",\n \"def crop_generator(batches, crop_length):\\n while True:\\n batch_x, batch_y = next(batches)\\n batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\\n for i in range(batch_x.shape[0]):\\n batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\\n yield (batch_crops, batch_y)\",\n \"def data_generator(batch_size, preprocessor, x, y):\\n num_examples = len(x)\\n examples = zip(x, y)\\n examples = sorted(examples, key = lambda x: x[0].shape[0])\\n end = num_examples - batch_size + 1\\n batches = [examples[i:i+batch_size]\\n for i in range(0, end, batch_size)]\\n random.shuffle(batches)\\n while True:\\n for batch in batches:\\n x, y = zip(*batch)\\n yield preprocessor.process(x, y)\",\n \"def batchwise_sample(gen, num_samples, batch_size):\\n\\n samples = []\\n for i in range(int(ceil(num_samples/float(batch_size)))):\\n samples.append(gen.sample(batch_size))\\n\\n return torch.cat(samples, 0)[:num_samples]\",\n \"def corun(self, step:int=0):\\n if step > 0:\\n _range = range(self.current_step, self.current_step + step + 1)\\n else: # run forever\\n _range = itertools.count(self.current_step)\\n for step_num in _range:\\n self.config_template = (yield self.step()) or self.config_template\",\n \"def sample(self, batch_size):\\n raise NotImplementedError\",\n \"def get_samples(self) -> McmcPtResult:\",\n \"def _iterate_steps(self):\\n mixture_size = self.parameters['fixed_mixture_size']\\n if mixture_size is None:\\n return 2 ** self.Ns\\n else:\\n return scipy.special.comb(self.Ns, mixture_size, exact=True)\",\n \"def get_tf_dataset(bs=32,sample_type=\\\"mixed\\\"):\\n train_ds = tf.data.Dataset.from_generator(\\n lambda :gen(split=\\\"train\\\",sample_type=sample_type),\\n (tf.float32,tf.float32),\\n ((SEQ_LEN,SEQ_LEN,3),(2)))\\n train_ds = train_ds.batch(bs,drop_remainder=True)\\n\\n val_ds = tf.data.Dataset.from_generator(\\n lambda :gen(split=\\\"val\\\",sample_type=sample_type),\\n (tf.float32,tf.float32),\\n ((SEQ_LEN,SEQ_LEN,3),(2)))\\n val_ds = val_ds.batch(bs,drop_remainder=True)\\n return train_ds,val_ds\",\n \"def generate(self, batch_size: int = 1) -> torch.Tensor:\\n z = self.prior.sample((batch_size, self.latent_size))\\n recon_mu, recon_sigma = self.decoder(z).chunk(2, dim=1)\\n recon_sigma = softplus(recon_sigma)\\n return recon_mu + recon_sigma * torch.rand_like(recon_sigma)\",\n \"def get_volume_batch_generators(self):\\n # volgeninfo = []\\n def create_volgen(shape, w, padding, features, masks):\\n w = np.asarray(w)\\n padding = np.asarray(padding)\\n W = w - padding * 2\\n iters = np.int32(np.ceil((np.asarray([s for s in shape if s > 1]) + padding) * 1.0 / (W + padding)))\\n for counts in counter_generator(iters):\\n start = -padding + (w - padding) * counts\\n end = (w - padding) * (counts + 1)\\n subf, subm = self._extract_sample(features, masks, copy.deepcopy(start), copy.deepcopy(end), shape)\\n ma = np.asarray([subm])\\n fe = np.asarray([subf])\\n if self.channels_first:\\n ndims = len(fe.shape)\\n neworder = [0, ndims - 1] + [i for i in range(1, ndims - 1)]\\n fe = np.transpose(fe, neworder)\\n ma = np.transpose(ma, neworder)\\n yield fe, ma, start, end\\n\\n def volgeninfo(tps):\\n for tp in tps:\\n features, masks = self._get_features_and_masks(tp)\\n spatial_shape = np.shape(features[0])\\n volgen = create_volgen(spatial_shape, self.w, self.p, features, masks)\\n yield [volgen, tp, spatial_shape, self.w, self.p]\\n\\n return volgeninfo(self.tps)\",\n \"def generate_bootstrap_samples(num_samples, test_universe, test_set_sizes):\\n for sample_idx, sample_size in zip(range(num_samples), cycle(test_set_sizes)):\\n yield random.sample(test_universe, sample_size)\",\n \"def get_batch_gen(self, config):\\n\\n ################\\n # Def generators\\n ################\\n\\n def random_balanced_gen():\\n print('trying to generate batch series with ', self.num_train, 'shapes')\\n\\n # Initiate concatenation lists\\n tp_list = [] # points\\n tev_list = [] # eigen vectors\\n tevt_list = [] # transposed eigen vectors\\n tv_list = [] # eigen values\\n tevf_list = [] # full eigen vectors for ground truth maps\\n ti_list = [] # cloud indices\\n\\n batch_n = 0\\n i_batch = 0\\n\\n gen_indices = np.random.permutation(int(self.num_train)) # initiate indices for the generator\\n # if we had to test on this dataset we would need to introduce a test/val case with non-shuffled indices\\n # print(gen_indices.shape, config.batch_num)\\n # if config.split == 'test':\\n # print('test setting here not fully supported')\\n # n_shapes = self.num_test # has to be defined\\n # gen_indices = []\\n # for i in range(n_shapes - 1):\\n # for j in range(i + 1, n_shapes):\\n # gen_indices += [i, j] # put all the pairs in order\\n # gen_indices = np.array(gen_indices)\\n\\n\\n # Generator loop\\n for p_i in gen_indices:\\n\\n # Get points and other input data\\n new_points = self.input_points[p_i]\\n new_evecs = self.input_evecs[p_i][:, :self.neig]\\n new_evecs_trans = self.input_evecs_trans[p_i][:self.neig, :]\\n new_evals = self.input_evals[p_i][:self.neig]\\n\\n new_evecs_full = self.input_evecs_full[p_i][:, :self.neig]\\n\\n n = new_points.shape[0]\\n\\n if i_batch == config.batch_num:\\n\\n yield (np.concatenate(tp_list, axis=0),\\n np.concatenate(tev_list, axis=0),\\n np.concatenate(tevt_list, axis=1),\\n np.concatenate(tv_list, axis=1),\\n np.concatenate(tevf_list, axis=0),\\n np.array(ti_list, dtype=np.int32),\\n np.array([tp.shape[0] for tp in tp_list]))\\n\\n tp_list = []\\n tev_list = []\\n tevt_list = []\\n tv_list = []\\n tevf_list = []\\n ti_list = []\\n\\n batch_n = 0\\n i_batch = 0\\n\\n # Add data to current batch\\n tp_list += [new_points]\\n tev_list += [new_evecs]\\n tevt_list += [new_evecs_trans]\\n tv_list += [new_evals]\\n tevf_list += [new_evecs_full]\\n ti_list += [p_i]\\n\\n # Update batch size\\n batch_n += n\\n i_batch += 1\\n\\n # yield the rest if necessary (it will not be a full batch and could lead to mistakes because of\\n # shape matching needing pairs !!!!)\\n yield (np.concatenate(tp_list, axis=0),\\n np.concatenate(tev_list, axis=0),\\n np.concatenate(tevt_list, axis=1),\\n np.concatenate(tv_list, axis=1),\\n np.concatenate(tevf_list, axis=0),\\n np.array(ti_list, dtype=np.int32),\\n np.array([tp.shape[0] for tp in tp_list]))\\n\\n ##################\\n # Return generator\\n ##################\\n\\n # Generator types and shapes\\n gen_types = (tf.float32, tf.float32, tf.float32, tf.float32, tf.float32, tf.int32, tf.int32)\\n gen_shapes = ([None, 3], [None, self.neig],\\n [self.neig, None], [self.neig, None], [None, self.neig], [None], [None])\\n\\n return random_balanced_gen, gen_types, gen_shapes\",\n \"def batch_train_generator(self, X, batch_size, seq_len):\\n startidx = np.random.randint(0, len(X) - seq_len, batch_size)\\n while True:\\n batch_X = np.array([X[start:start + seq_len]\\n for start in startidx])\\n batch_y = np.array(\\n [X[start:start + seq_len + self.config.shift] for start in startidx])\\n batch_y = batch_y[:, -1]\\n startidx = (startidx + seq_len) % (len(X) - seq_len)\\n yield batch_X.reshape(batch_size, seq_len, 1), batch_y.reshape(batch_size, 1)\",\n \"def build_sequences(dcm):\\n dimension_organization_uid = '1.2.276.0.7230010.3.1.4.8323329.20175.1573232544.237437'\\n ds0 = Dataset()\\n ds0.DimensionOrganizationUID = dimension_organization_uid\\n dcm.DimensionOrganizationSequence = Sequence([ds0])\\n del ds0\\n\\n ds1 = Dataset()\\n ds1.DimensionOrganizationUID = dimension_organization_uid\\n ds1.DimensionIndexPointer = Tag(0x0048021E)\\n ds1.FunctionalGroupPointer = Tag(0x0048021A)\\n\\n ds2 = Dataset()\\n ds2.DimensionOrganizationUID = dimension_organization_uid\\n ds2.DimensionIndexPointer = Tag(0x0048021F)\\n ds2.FunctionalGroupPointer = Tag(0x0048021A)\\n\\n dcm.DimensionIndexSequence = Sequence([ds1, ds2])\\n del ds1, ds2\\n\\n ds3 = Dataset()\\n ds3.XOffsetInSlideCoordinateSystem = 20\\n ds3.YOffsetInSlideCoordinateSystem = 40\\n dcm.TotalPixelMatrixOriginSequence = Sequence([ds3])\\n del ds3\\n\\n ds4 = Dataset()\\n ds5 = Dataset()\\n\\n # IlluminationTypeCodeSequence\\n ds4.CodingSchemeDesignator = 'DCM'\\n ds4.CodeMeaning = 'Brightfield illumination'\\n ds4.CodeValue = '111744'\\n\\n # IlluminationColorCodeSequence\\n ds5.CodingSchemeDesignator = 'DCM'\\n ds5.CodeMeaning = 'No filter'\\n ds5.CodeValue = '111609'\\n\\n ds7 = Dataset()\\n ds7.IlluminationTypeCodeSequence = Sequence([ds4])\\n ds7.IlluminationColorCodeSequence = Sequence([ds5])\\n # noinspection PyPep8,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection,SpellCheckingInspection\\n ds7.ICCProfile = b'\\\\x00\\\\x00\\\\x1b\\\\nlcms\\\\x020\\\\x00\\\\x00mntrRGB XYZ \\\\x07\\\\xd4\\\\x00\\\\x08\\\\x00\\\\r\\\\x00\\\\x0c\\\\x00\\\\x12\\\\x00\\\\x06acspMSFT\\\\x00\\\\x00\\\\x00\\\\x00lcms\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\xf6\\\\xd6\\\\x00\\\\x01\\\\x00\\\\x00\\\\x00\\\\x00\\\\xd3-lcms\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x0cdmnd\\\\x00\\\\x00\\\\x01\\\\x14\\\\x00\\\\x00\\\\x00jdesc\\\\x00\\\\x00\\\\x01\\\\x80\\\\x00\\\\x00\\\\x00hdmdd\\\\x00\\\\x00\\\\x01\\\\xe8\\\\x00\\\\x00\\\\x00hwtpt\\\\x00\\\\x00\\\\x02P\\\\x00\\\\x00\\\\x00\\\\x14rXYZ\\\\x00\\\\x00\\\\x02d\\\\x00\\\\x00\\\\x00\\\\x14bXYZ\\\\x00\\\\x00\\\\x02x\\\\x00\\\\x00\\\\x00\\\\x14gXYZ\\\\x00\\\\x00\\\\x02\\\\x8c\\\\x00\\\\x00\\\\x00\\\\x14rTRC\\\\x00\\\\x00\\\\x02\\\\xa0\\\\x00\\\\x00\\\\x08\\\\x0cgTRC\\\\x00\\\\x00\\\\n\\\\xac\\\\x00\\\\x00\\\\x08\\\\x0cbTRC\\\\x00\\\\x00\\\\x12\\\\xb8\\\\x00\\\\x00\\\\x08\\\\x0cchrm\\\\x00\\\\x00\\\\x1a\\\\xc4\\\\x00\\\\x00\\\\x00$cprt\\\\x00\\\\x00\\\\x1a\\\\xe8\\\\x00\\\\x00\\\\x00!desc\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x10lcms generated \\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00desc\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x05sRGB\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00desc\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x05sRGB\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00XYZ \\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\xf3=\\\\x00\\\\x01\\\\x00\\\\x00\\\\x00\\\\x01\\\\x16\\\\x98XYZ \\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00o\\\\x94\\\\x00\\\\x008\\\\xee\\\\x00\\\\x00\\\\x03\\\\x90XYZ \\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00$\\\\x9d\\\\x00\\\\x00\\\\x0f\\\\x83\\\\x00\\\\x00\\\\xb6\\\\xbeXYZ \\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00b\\\\xa5\\\\x00\\\\x00\\\\xb7\\\\x90\\\\x00\\\\x00\\\\x18\\\\xdecurv\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x04\\\\x00\\\\x00\\\\x00\\\\x00\\\\x05\\\\x00\\\\n\\\\x00\\\\x0f\\\\x00\\\\x14\\\\x00\\\\x19\\\\x00\\\\x1e\\\\x00#\\\\x00(\\\\x00-\\\\x002\\\\x007\\\\x00;\\\\x00@\\\\x00E\\\\x00J\\\\x00O\\\\x00T\\\\x00Y\\\\x00^\\\\x00c\\\\x00h\\\\x00m\\\\x00r\\\\x00w\\\\x00|\\\\x00\\\\x81\\\\x00\\\\x86\\\\x00\\\\x8b\\\\x00\\\\x90\\\\x00\\\\x95\\\\x00\\\\x9a\\\\x00\\\\x9f\\\\x00\\\\xa4\\\\x00\\\\xa9\\\\x00\\\\xae\\\\x00\\\\xb2\\\\x00\\\\xb7\\\\x00\\\\xbc\\\\x00\\\\xc1\\\\x00\\\\xc6\\\\x00\\\\xcb\\\\x00\\\\xd0\\\\x00\\\\xd5\\\\x00\\\\xdb\\\\x00\\\\xe0\\\\x00\\\\xe5\\\\x00\\\\xeb\\\\x00\\\\xf0\\\\x00\\\\xf6\\\\x00\\\\xfb\\\\x01\\\\x01\\\\x01\\\\x07\\\\x01\\\\r\\\\x01\\\\x13\\\\x01\\\\x19\\\\x01\\\\x1f\\\\x01%\\\\x01+\\\\x012\\\\x018\\\\x01>\\\\x01E\\\\x01L\\\\x01R\\\\x01Y\\\\x01`\\\\x01g\\\\x01n\\\\x01u\\\\x01|\\\\x01\\\\x83\\\\x01\\\\x8b\\\\x01\\\\x92\\\\x01\\\\x9a\\\\x01\\\\xa1\\\\x01\\\\xa9\\\\x01\\\\xb1\\\\x01\\\\xb9\\\\x01\\\\xc1\\\\x01\\\\xc9\\\\x01\\\\xd1\\\\x01\\\\xd9\\\\x01\\\\xe1\\\\x01\\\\xe9\\\\x01\\\\xf2\\\\x01\\\\xfa\\\\x02\\\\x03\\\\x02\\\\x0c\\\\x02\\\\x14\\\\x02\\\\x1d\\\\x02&\\\\x02/\\\\x028\\\\x02A\\\\x02K\\\\x02T\\\\x02]\\\\x02g\\\\x02q\\\\x02z\\\\x02\\\\x84\\\\x02\\\\x8e\\\\x02\\\\x98\\\\x02\\\\xa2\\\\x02\\\\xac\\\\x02\\\\xb6\\\\x02\\\\xc1\\\\x02\\\\xcb\\\\x02\\\\xd5\\\\x02\\\\xe0\\\\x02\\\\xeb\\\\x02\\\\xf5\\\\x03\\\\x00\\\\x03\\\\x0b\\\\x03\\\\x16\\\\x03!\\\\x03-\\\\x038\\\\x03C\\\\x03O\\\\x03Z\\\\x03f\\\\x03r\\\\x03~\\\\x03\\\\x8a\\\\x03\\\\x96\\\\x03\\\\xa2\\\\x03\\\\xae\\\\x03\\\\xba\\\\x03\\\\xc7\\\\x03\\\\xd3\\\\x03\\\\xe0\\\\x03\\\\xec\\\\x03\\\\xf9\\\\x04\\\\x06\\\\x04\\\\x13\\\\x04 \\\\x04-\\\\x04;\\\\x04H\\\\x04U\\\\x04c\\\\x04q\\\\x04~\\\\x04\\\\x8c\\\\x04\\\\x9a\\\\x04\\\\xa8\\\\x04\\\\xb6\\\\x04\\\\xc4\\\\x04\\\\xd3\\\\x04\\\\xe1\\\\x04\\\\xf0\\\\x04\\\\xfe\\\\x05\\\\r\\\\x05\\\\x1c\\\\x05+\\\\x05:\\\\x05I\\\\x05X\\\\x05g\\\\x05w\\\\x05\\\\x86\\\\x05\\\\x96\\\\x05\\\\xa6\\\\x05\\\\xb5\\\\x05\\\\xc5\\\\x05\\\\xd5\\\\x05\\\\xe5\\\\x05\\\\xf6\\\\x06\\\\x06\\\\x06\\\\x16\\\\x06\\\\'\\\\x067\\\\x06H\\\\x06Y\\\\x06j\\\\x06{\\\\x06\\\\x8c\\\\x06\\\\x9d\\\\x06\\\\xaf\\\\x06\\\\xc0\\\\x06\\\\xd1\\\\x06\\\\xe3\\\\x06\\\\xf5\\\\x07\\\\x07\\\\x07\\\\x19\\\\x07+\\\\x07=\\\\x07O\\\\x07a\\\\x07t\\\\x07\\\\x86\\\\x07\\\\x99\\\\x07\\\\xac\\\\x07\\\\xbf\\\\x07\\\\xd2\\\\x07\\\\xe5\\\\x07\\\\xf8\\\\x08\\\\x0b\\\\x08\\\\x1f\\\\x082\\\\x08F\\\\x08Z\\\\x08n\\\\x08\\\\x82\\\\x08\\\\x96\\\\x08\\\\xaa\\\\x08\\\\xbe\\\\x08\\\\xd2\\\\x08\\\\xe7\\\\x08\\\\xfb\\\\t\\\\x10\\\\t%\\\\t:\\\\tO\\\\td\\\\ty\\\\t\\\\x8f\\\\t\\\\xa4\\\\t\\\\xba\\\\t\\\\xcf\\\\t\\\\xe5\\\\t\\\\xfb\\\\n\\\\x11\\\\n\\\\'\\\\n=\\\\nT\\\\nj\\\\n\\\\x81\\\\n\\\\x98\\\\n\\\\xae\\\\n\\\\xc5\\\\n\\\\xdc\\\\n\\\\xf3\\\\x0b\\\\x0b\\\\x0b\\\"\\\\x0b9\\\\x0bQ\\\\x0bi\\\\x0b\\\\x80\\\\x0b\\\\x98\\\\x0b\\\\xb0\\\\x0b\\\\xc8\\\\x0b\\\\xe1\\\\x0b\\\\xf9\\\\x0c\\\\x12\\\\x0c*\\\\x0cC\\\\x0c\\\\\\\\\\\\x0cu\\\\x0c\\\\x8e\\\\x0c\\\\xa7\\\\x0c\\\\xc0\\\\x0c\\\\xd9\\\\x0c\\\\xf3\\\\r\\\\r\\\\r&\\\\r@\\\\rZ\\\\rt\\\\r\\\\x8e\\\\r\\\\xa9\\\\r\\\\xc3\\\\r\\\\xde\\\\r\\\\xf8\\\\x0e\\\\x13\\\\x0e.\\\\x0eI\\\\x0ed\\\\x0e\\\\x7f\\\\x0e\\\\x9b\\\\x0e\\\\xb6\\\\x0e\\\\xd2\\\\x0e\\\\xee\\\\x0f\\\\t\\\\x0f%\\\\x0fA\\\\x0f^\\\\x0fz\\\\x0f\\\\x96\\\\x0f\\\\xb3\\\\x0f\\\\xcf\\\\x0f\\\\xec\\\\x10\\\\t\\\\x10&\\\\x10C\\\\x10a\\\\x10~\\\\x10\\\\x9b\\\\x10\\\\xb9\\\\x10\\\\xd7\\\\x10\\\\xf5\\\\x11\\\\x13\\\\x111\\\\x11O\\\\x11m\\\\x11\\\\x8c\\\\x11\\\\xaa\\\\x11\\\\xc9\\\\x11\\\\xe8\\\\x12\\\\x07\\\\x12&\\\\x12E\\\\x12d\\\\x12\\\\x84\\\\x12\\\\xa3\\\\x12\\\\xc3\\\\x12\\\\xe3\\\\x13\\\\x03\\\\x13#\\\\x13C\\\\x13c\\\\x13\\\\x83\\\\x13\\\\xa4\\\\x13\\\\xc5\\\\x13\\\\xe5\\\\x14\\\\x06\\\\x14\\\\'\\\\x14I\\\\x14j\\\\x14\\\\x8b\\\\x14\\\\xad\\\\x14\\\\xce\\\\x14\\\\xf0\\\\x15\\\\x12\\\\x154\\\\x15V\\\\x15x\\\\x15\\\\x9b\\\\x15\\\\xbd\\\\x15\\\\xe0\\\\x16\\\\x03\\\\x16&\\\\x16I\\\\x16l\\\\x16\\\\x8f\\\\x16\\\\xb2\\\\x16\\\\xd6\\\\x16\\\\xfa\\\\x17\\\\x1d\\\\x17A\\\\x17e\\\\x17\\\\x89\\\\x17\\\\xae\\\\x17\\\\xd2\\\\x17\\\\xf7\\\\x18\\\\x1b\\\\x18@\\\\x18e\\\\x18\\\\x8a\\\\x18\\\\xaf\\\\x18\\\\xd5\\\\x18\\\\xfa\\\\x19 \\\\x19E\\\\x19k\\\\x19\\\\x91\\\\x19\\\\xb7\\\\x19\\\\xdd\\\\x1a\\\\x04\\\\x1a*\\\\x1aQ\\\\x1aw\\\\x1a\\\\x9e\\\\x1a\\\\xc5\\\\x1a\\\\xec\\\\x1b\\\\x14\\\\x1b;\\\\x1bc\\\\x1b\\\\x8a\\\\x1b\\\\xb2\\\\x1b\\\\xda\\\\x1c\\\\x02\\\\x1c*\\\\x1cR\\\\x1c{\\\\x1c\\\\xa3\\\\x1c\\\\xcc\\\\x1c\\\\xf5\\\\x1d\\\\x1e\\\\x1dG\\\\x1dp\\\\x1d\\\\x99\\\\x1d\\\\xc3\\\\x1d\\\\xec\\\\x1e\\\\x16\\\\x1e@\\\\x1ej\\\\x1e\\\\x94\\\\x1e\\\\xbe\\\\x1e\\\\xe9\\\\x1f\\\\x13\\\\x1f>\\\\x1fi\\\\x1f\\\\x94\\\\x1f\\\\xbf\\\\x1f\\\\xea \\\\x15 A l \\\\x98 \\\\xc4 \\\\xf0!\\\\x1c!H!u!\\\\xa1!\\\\xce!\\\\xfb\\\"\\\\'\\\"U\\\"\\\\x82\\\"\\\\xaf\\\"\\\\xdd#\\\\n#8#f#\\\\x94#\\\\xc2#\\\\xf0$\\\\x1f$M$|$\\\\xab$\\\\xda%\\\\t%8%h%\\\\x97%\\\\xc7%\\\\xf7&\\\\'&W&\\\\x87&\\\\xb7&\\\\xe8\\\\'\\\\x18\\\\'I\\\\'z\\\\'\\\\xab\\\\'\\\\xdc(\\\\r(?(q(\\\\xa2(\\\\xd4)\\\\x06)8)k)\\\\x9d)\\\\xd0*\\\\x02*5*h*\\\\x9b*\\\\xcf+\\\\x02+6+i+\\\\x9d+\\\\xd1,\\\\x05,9,n,\\\\xa2,\\\\xd7-\\\\x0c-A-v-\\\\xab-\\\\xe1.\\\\x16.L.\\\\x82.\\\\xb7.\\\\xee/$/Z/\\\\x91/\\\\xc7/\\\\xfe050l0\\\\xa40\\\\xdb1\\\\x121J1\\\\x821\\\\xba1\\\\xf22*2c2\\\\x9b2\\\\xd43\\\\r3F3\\\\x7f3\\\\xb83\\\\xf14+4e4\\\\x9e4\\\\xd85\\\\x135M5\\\\x875\\\\xc25\\\\xfd676r6\\\\xae6\\\\xe97$7`7\\\\x9c7\\\\xd78\\\\x148P8\\\\x8c8\\\\xc89\\\\x059B9\\\\x7f9\\\\xbc9\\\\xf9:6:t:\\\\xb2:\\\\xef;-;k;\\\\xaa;\\\\xe8<\\\\'<e<\\\\xa4<\\\\xe3=\\\"=a=\\\\xa1=\\\\xe0> >`>\\\\xa0>\\\\xe0?!?a?\\\\xa2?\\\\xe2@#@d@\\\\xa6@\\\\xe7A)AjA\\\\xacA\\\\xeeB0BrB\\\\xb5B\\\\xf7C:C}C\\\\xc0D\\\\x03DGD\\\\x8aD\\\\xceE\\\\x12EUE\\\\x9aE\\\\xdeF\\\"FgF\\\\xabF\\\\xf0G5G{G\\\\xc0H\\\\x05HKH\\\\x91H\\\\xd7I\\\\x1dIcI\\\\xa9I\\\\xf0J7J}J\\\\xc4K\\\\x0cKSK\\\\x9aK\\\\xe2L*LrL\\\\xbaM\\\\x02MJM\\\\x93M\\\\xdcN%NnN\\\\xb7O\\\\x00OIO\\\\x93O\\\\xddP\\\\'PqP\\\\xbbQ\\\\x06QPQ\\\\x9bQ\\\\xe6R1R|R\\\\xc7S\\\\x13S_S\\\\xaaS\\\\xf6TBT\\\\x8fT\\\\xdbU(UuU\\\\xc2V\\\\x0fV\\\\\\\\V\\\\xa9V\\\\xf7WDW\\\\x92W\\\\xe0X/X}X\\\\xcbY\\\\x1aYiY\\\\xb8Z\\\\x07ZVZ\\\\xa6Z\\\\xf5[E[\\\\x95[\\\\xe5\\\\\\\\5\\\\\\\\\\\\x86\\\\\\\\\\\\xd6]\\\\']x]\\\\xc9^\\\\x1a^l^\\\\xbd_\\\\x0f_a_\\\\xb3`\\\\x05`W`\\\\xaa`\\\\xfcaOa\\\\xa2a\\\\xf5bIb\\\\x9cb\\\\xf0cCc\\\\x97c\\\\xebd@d\\\\x94d\\\\xe9e=e\\\\x92e\\\\xe7f=f\\\\x92f\\\\xe8g=g\\\\x93g\\\\xe9h?h\\\\x96h\\\\xeciCi\\\\x9ai\\\\xf1jHj\\\\x9fj\\\\xf7kOk\\\\xa7k\\\\xfflWl\\\\xafm\\\\x08m`m\\\\xb9n\\\\x12nkn\\\\xc4o\\\\x1eoxo\\\\xd1p+p\\\\x86p\\\\xe0q:q\\\\x95q\\\\xf0rKr\\\\xa6s\\\\x01s]s\\\\xb8t\\\\x14tpt\\\\xccu(u\\\\x85u\\\\xe1v>v\\\\x9bv\\\\xf8wVw\\\\xb3x\\\\x11xnx\\\\xccy*y\\\\x89y\\\\xe7zFz\\\\xa5{\\\\x04{c{\\\\xc2|!|\\\\x81|\\\\xe1}A}\\\\xa1~\\\\x01~b~\\\\xc2\\\\x7f#\\\\x7f\\\\x84\\\\x7f\\\\xe5\\\\x80G\\\\x80\\\\xa8\\\\x81\\\\n\\\\x81k\\\\x81\\\\xcd\\\\x820\\\\x82\\\\x92\\\\x82\\\\xf4\\\\x83W\\\\x83\\\\xba\\\\x84\\\\x1d\\\\x84\\\\x80\\\\x84\\\\xe3\\\\x85G\\\\x85\\\\xab\\\\x86\\\\x0e\\\\x86r\\\\x86\\\\xd7\\\\x87;\\\\x87\\\\x9f\\\\x88\\\\x04\\\\x88i\\\\x88\\\\xce\\\\x893\\\\x89\\\\x99\\\\x89\\\\xfe\\\\x8ad\\\\x8a\\\\xca\\\\x8b0\\\\x8b\\\\x96\\\\x8b\\\\xfc\\\\x8cc\\\\x8c\\\\xca\\\\x8d1\\\\x8d\\\\x98\\\\x8d\\\\xff\\\\x8ef\\\\x8e\\\\xce\\\\x8f6\\\\x8f\\\\x9e\\\\x90\\\\x06\\\\x90n\\\\x90\\\\xd6\\\\x91?\\\\x91\\\\xa8\\\\x92\\\\x11\\\\x92z\\\\x92\\\\xe3\\\\x93M\\\\x93\\\\xb6\\\\x94 \\\\x94\\\\x8a\\\\x94\\\\xf4\\\\x95_\\\\x95\\\\xc9\\\\x964\\\\x96\\\\x9f\\\\x97\\\\n\\\\x97u\\\\x97\\\\xe0\\\\x98L\\\\x98\\\\xb8\\\\x99$\\\\x99\\\\x90\\\\x99\\\\xfc\\\\x9ah\\\\x9a\\\\xd5\\\\x9bB\\\\x9b\\\\xaf\\\\x9c\\\\x1c\\\\x9c\\\\x89\\\\x9c\\\\xf7\\\\x9dd\\\\x9d\\\\xd2\\\\x9e@\\\\x9e\\\\xae\\\\x9f\\\\x1d\\\\x9f\\\\x8b\\\\x9f\\\\xfa\\\\xa0i\\\\xa0\\\\xd8\\\\xa1G\\\\xa1\\\\xb6\\\\xa2&\\\\xa2\\\\x96\\\\xa3\\\\x06\\\\xa3v\\\\xa3\\\\xe6\\\\xa4V\\\\xa4\\\\xc7\\\\xa58\\\\xa5\\\\xa9\\\\xa6\\\\x1a\\\\xa6\\\\x8b\\\\xa6\\\\xfd\\\\xa7n\\\\xa7\\\\xe0\\\\xa8R\\\\xa8\\\\xc4\\\\xa97\\\\xa9\\\\xa9\\\\xaa\\\\x1c\\\\xaa\\\\x8f\\\\xab\\\\x02\\\\xabu\\\\xab\\\\xe9\\\\xac\\\\\\\\\\\\xac\\\\xd0\\\\xadD\\\\xad\\\\xb8\\\\xae-\\\\xae\\\\xa1\\\\xaf\\\\x16\\\\xaf\\\\x8b\\\\xb0\\\\x00\\\\xb0u\\\\xb0\\\\xea\\\\xb1`\\\\xb1\\\\xd6\\\\xb2K\\\\xb2\\\\xc2\\\\xb38\\\\xb3\\\\xae\\\\xb4%\\\\xb4\\\\x9c\\\\xb5\\\\x13\\\\xb5\\\\x8a\\\\xb6\\\\x01\\\\xb6y\\\\xb6\\\\xf0\\\\xb7h\\\\xb7\\\\xe0\\\\xb8Y\\\\xb8\\\\xd1\\\\xb9J\\\\xb9\\\\xc2\\\\xba;\\\\xba\\\\xb5\\\\xbb.\\\\xbb\\\\xa7\\\\xbc!\\\\xbc\\\\x9b\\\\xbd\\\\x15\\\\xbd\\\\x8f\\\\xbe\\\\n\\\\xbe\\\\x84\\\\xbe\\\\xff\\\\xbfz\\\\xbf\\\\xf5\\\\xc0p\\\\xc0\\\\xec\\\\xc1g\\\\xc1\\\\xe3\\\\xc2_\\\\xc2\\\\xdb\\\\xc3X\\\\xc3\\\\xd4\\\\xc4Q\\\\xc4\\\\xce\\\\xc5K\\\\xc5\\\\xc8\\\\xc6F\\\\xc6\\\\xc3\\\\xc7A\\\\xc7\\\\xbf\\\\xc8=\\\\xc8\\\\xbc\\\\xc9:\\\\xc9\\\\xb9\\\\xca8\\\\xca\\\\xb7\\\\xcb6\\\\xcb\\\\xb6\\\\xcc5\\\\xcc\\\\xb5\\\\xcd5\\\\xcd\\\\xb5\\\\xce6\\\\xce\\\\xb6\\\\xcf7\\\\xcf\\\\xb8\\\\xd09\\\\xd0\\\\xba\\\\xd1<\\\\xd1\\\\xbe\\\\xd2?\\\\xd2\\\\xc1\\\\xd3D\\\\xd3\\\\xc6\\\\xd4I\\\\xd4\\\\xcb\\\\xd5N\\\\xd5\\\\xd1\\\\xd6U\\\\xd6\\\\xd8\\\\xd7\\\\\\\\\\\\xd7\\\\xe0\\\\xd8d\\\\xd8\\\\xe8\\\\xd9l\\\\xd9\\\\xf1\\\\xdav\\\\xda\\\\xfb\\\\xdb\\\\x80\\\\xdc\\\\x05\\\\xdc\\\\x8a\\\\xdd\\\\x10\\\\xdd\\\\x96\\\\xde\\\\x1c\\\\xde\\\\xa2\\\\xdf)\\\\xdf\\\\xaf\\\\xe06\\\\xe0\\\\xbd\\\\xe1D\\\\xe1\\\\xcc\\\\xe2S\\\\xe2\\\\xdb\\\\xe3c\\\\xe3\\\\xeb\\\\xe4s\\\\xe4\\\\xfc\\\\xe5\\\\x84\\\\xe6\\\\r\\\\xe6\\\\x96\\\\xe7\\\\x1f\\\\xe7\\\\xa9\\\\xe82\\\\xe8\\\\xbc\\\\xe9F\\\\xe9\\\\xd0\\\\xea[\\\\xea\\\\xe5\\\\xebp\\\\xeb\\\\xfb\\\\xec\\\\x86\\\\xed\\\\x11\\\\xed\\\\x9c\\\\xee(\\\\xee\\\\xb4\\\\xef@\\\\xef\\\\xcc\\\\xf0X\\\\xf0\\\\xe5\\\\xf1r\\\\xf1\\\\xff\\\\xf2\\\\x8c\\\\xf3\\\\x19\\\\xf3\\\\xa7\\\\xf44\\\\xf4\\\\xc2\\\\xf5P\\\\xf5\\\\xde\\\\xf6m\\\\xf6\\\\xfb\\\\xf7\\\\x8a\\\\xf8\\\\x19\\\\xf8\\\\xa8\\\\xf98\\\\xf9\\\\xc7\\\\xfaW\\\\xfa\\\\xe7\\\\xfbw\\\\xfc\\\\x07\\\\xfc\\\\x98\\\\xfd)\\\\xfd\\\\xba\\\\xfeK\\\\xfe\\\\xdc\\\\xffm\\\\xff\\\\xffcurv\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x04\\\\x00\\\\x00\\\\x00\\\\x00\\\\x05\\\\x00\\\\n\\\\x00\\\\x0f\\\\x00\\\\x14\\\\x00\\\\x19\\\\x00\\\\x1e\\\\x00#\\\\x00(\\\\x00-\\\\x002\\\\x007\\\\x00;\\\\x00@\\\\x00E\\\\x00J\\\\x00O\\\\x00T\\\\x00Y\\\\x00^\\\\x00c\\\\x00h\\\\x00m\\\\x00r\\\\x00w\\\\x00|\\\\x00\\\\x81\\\\x00\\\\x86\\\\x00\\\\x8b\\\\x00\\\\x90\\\\x00\\\\x95\\\\x00\\\\x9a\\\\x00\\\\x9f\\\\x00\\\\xa4\\\\x00\\\\xa9\\\\x00\\\\xae\\\\x00\\\\xb2\\\\x00\\\\xb7\\\\x00\\\\xbc\\\\x00\\\\xc1\\\\x00\\\\xc6\\\\x00\\\\xcb\\\\x00\\\\xd0\\\\x00\\\\xd5\\\\x00\\\\xdb\\\\x00\\\\xe0\\\\x00\\\\xe5\\\\x00\\\\xeb\\\\x00\\\\xf0\\\\x00\\\\xf6\\\\x00\\\\xfb\\\\x01\\\\x01\\\\x01\\\\x07\\\\x01\\\\r\\\\x01\\\\x13\\\\x01\\\\x19\\\\x01\\\\x1f\\\\x01%\\\\x01+\\\\x012\\\\x018\\\\x01>\\\\x01E\\\\x01L\\\\x01R\\\\x01Y\\\\x01`\\\\x01g\\\\x01n\\\\x01u\\\\x01|\\\\x01\\\\x83\\\\x01\\\\x8b\\\\x01\\\\x92\\\\x01\\\\x9a\\\\x01\\\\xa1\\\\x01\\\\xa9\\\\x01\\\\xb1\\\\x01\\\\xb9\\\\x01\\\\xc1\\\\x01\\\\xc9\\\\x01\\\\xd1\\\\x01\\\\xd9\\\\x01\\\\xe1\\\\x01\\\\xe9\\\\x01\\\\xf2\\\\x01\\\\xfa\\\\x02\\\\x03\\\\x02\\\\x0c\\\\x02\\\\x14\\\\x02\\\\x1d\\\\x02&\\\\x02/\\\\x028\\\\x02A\\\\x02K\\\\x02T\\\\x02]\\\\x02g\\\\x02q\\\\x02z\\\\x02\\\\x84\\\\x02\\\\x8e\\\\x02\\\\x98\\\\x02\\\\xa2\\\\x02\\\\xac\\\\x02\\\\xb6\\\\x02\\\\xc1\\\\x02\\\\xcb\\\\x02\\\\xd5\\\\x02\\\\xe0\\\\x02\\\\xeb\\\\x02\\\\xf5\\\\x03\\\\x00\\\\x03\\\\x0b\\\\x03\\\\x16\\\\x03!\\\\x03-\\\\x038\\\\x03C\\\\x03O\\\\x03Z\\\\x03f\\\\x03r\\\\x03~\\\\x03\\\\x8a\\\\x03\\\\x96\\\\x03\\\\xa2\\\\x03\\\\xae\\\\x03\\\\xba\\\\x03\\\\xc7\\\\x03\\\\xd3\\\\x03\\\\xe0\\\\x03\\\\xec\\\\x03\\\\xf9\\\\x04\\\\x06\\\\x04\\\\x13\\\\x04 \\\\x04-\\\\x04;\\\\x04H\\\\x04U\\\\x04c\\\\x04q\\\\x04~\\\\x04\\\\x8c\\\\x04\\\\x9a\\\\x04\\\\xa8\\\\x04\\\\xb6\\\\x04\\\\xc4\\\\x04\\\\xd3\\\\x04\\\\xe1\\\\x04\\\\xf0\\\\x04\\\\xfe\\\\x05\\\\r\\\\x05\\\\x1c\\\\x05+\\\\x05:\\\\x05I\\\\x05X\\\\x05g\\\\x05w\\\\x05\\\\x86\\\\x05\\\\x96\\\\x05\\\\xa6\\\\x05\\\\xb5\\\\x05\\\\xc5\\\\x05\\\\xd5\\\\x05\\\\xe5\\\\x05\\\\xf6\\\\x06\\\\x06\\\\x06\\\\x16\\\\x06\\\\'\\\\x067\\\\x06H\\\\x06Y\\\\x06j\\\\x06{\\\\x06\\\\x8c\\\\x06\\\\x9d\\\\x06\\\\xaf\\\\x06\\\\xc0\\\\x06\\\\xd1\\\\x06\\\\xe3\\\\x06\\\\xf5\\\\x07\\\\x07\\\\x07\\\\x19\\\\x07+\\\\x07=\\\\x07O\\\\x07a\\\\x07t\\\\x07\\\\x86\\\\x07\\\\x99\\\\x07\\\\xac\\\\x07\\\\xbf\\\\x07\\\\xd2\\\\x07\\\\xe5\\\\x07\\\\xf8\\\\x08\\\\x0b\\\\x08\\\\x1f\\\\x082\\\\x08F\\\\x08Z\\\\x08n\\\\x08\\\\x82\\\\x08\\\\x96\\\\x08\\\\xaa\\\\x08\\\\xbe\\\\x08\\\\xd2\\\\x08\\\\xe7\\\\x08\\\\xfb\\\\t\\\\x10\\\\t%\\\\t:\\\\tO\\\\td\\\\ty\\\\t\\\\x8f\\\\t\\\\xa4\\\\t\\\\xba\\\\t\\\\xcf\\\\t\\\\xe5\\\\t\\\\xfb\\\\n\\\\x11\\\\n\\\\'\\\\n=\\\\nT\\\\nj\\\\n\\\\x81\\\\n\\\\x98\\\\n\\\\xae\\\\n\\\\xc5\\\\n\\\\xdc\\\\n\\\\xf3\\\\x0b\\\\x0b\\\\x0b\\\"\\\\x0b9\\\\x0bQ\\\\x0bi\\\\x0b\\\\x80\\\\x0b\\\\x98\\\\x0b\\\\xb0\\\\x0b\\\\xc8\\\\x0b\\\\xe1\\\\x0b\\\\xf9\\\\x0c\\\\x12\\\\x0c*\\\\x0cC\\\\x0c\\\\\\\\\\\\x0cu\\\\x0c\\\\x8e\\\\x0c\\\\xa7\\\\x0c\\\\xc0\\\\x0c\\\\xd9\\\\x0c\\\\xf3\\\\r\\\\r\\\\r&\\\\r@\\\\rZ\\\\rt\\\\r\\\\x8e\\\\r\\\\xa9\\\\r\\\\xc3\\\\r\\\\xde\\\\r\\\\xf8\\\\x0e\\\\x13\\\\x0e.\\\\x0eI\\\\x0ed\\\\x0e\\\\x7f\\\\x0e\\\\x9b\\\\x0e\\\\xb6\\\\x0e\\\\xd2\\\\x0e\\\\xee\\\\x0f\\\\t\\\\x0f%\\\\x0fA\\\\x0f^\\\\x0fz\\\\x0f\\\\x96\\\\x0f\\\\xb3\\\\x0f\\\\xcf\\\\x0f\\\\xec\\\\x10\\\\t\\\\x10&\\\\x10C\\\\x10a\\\\x10~\\\\x10\\\\x9b\\\\x10\\\\xb9\\\\x10\\\\xd7\\\\x10\\\\xf5\\\\x11\\\\x13\\\\x111\\\\x11O\\\\x11m\\\\x11\\\\x8c\\\\x11\\\\xaa\\\\x11\\\\xc9\\\\x11\\\\xe8\\\\x12\\\\x07\\\\x12&\\\\x12E\\\\x12d\\\\x12\\\\x84\\\\x12\\\\xa3\\\\x12\\\\xc3\\\\x12\\\\xe3\\\\x13\\\\x03\\\\x13#\\\\x13C\\\\x13c\\\\x13\\\\x83\\\\x13\\\\xa4\\\\x13\\\\xc5\\\\x13\\\\xe5\\\\x14\\\\x06\\\\x14\\\\'\\\\x14I\\\\x14j\\\\x14\\\\x8b\\\\x14\\\\xad\\\\x14\\\\xce\\\\x14\\\\xf0\\\\x15\\\\x12\\\\x154\\\\x15V\\\\x15x\\\\x15\\\\x9b\\\\x15\\\\xbd\\\\x15\\\\xe0\\\\x16\\\\x03\\\\x16&\\\\x16I\\\\x16l\\\\x16\\\\x8f\\\\x16\\\\xb2\\\\x16\\\\xd6\\\\x16\\\\xfa\\\\x17\\\\x1d\\\\x17A\\\\x17e\\\\x17\\\\x89\\\\x17\\\\xae\\\\x17\\\\xd2\\\\x17\\\\xf7\\\\x18\\\\x1b\\\\x18@\\\\x18e\\\\x18\\\\x8a\\\\x18\\\\xaf\\\\x18\\\\xd5\\\\x18\\\\xfa\\\\x19 \\\\x19E\\\\x19k\\\\x19\\\\x91\\\\x19\\\\xb7\\\\x19\\\\xdd\\\\x1a\\\\x04\\\\x1a*\\\\x1aQ\\\\x1aw\\\\x1a\\\\x9e\\\\x1a\\\\xc5\\\\x1a\\\\xec\\\\x1b\\\\x14\\\\x1b;\\\\x1bc\\\\x1b\\\\x8a\\\\x1b\\\\xb2\\\\x1b\\\\xda\\\\x1c\\\\x02\\\\x1c*\\\\x1cR\\\\x1c{\\\\x1c\\\\xa3\\\\x1c\\\\xcc\\\\x1c\\\\xf5\\\\x1d\\\\x1e\\\\x1dG\\\\x1dp\\\\x1d\\\\x99\\\\x1d\\\\xc3\\\\x1d\\\\xec\\\\x1e\\\\x16\\\\x1e@\\\\x1ej\\\\x1e\\\\x94\\\\x1e\\\\xbe\\\\x1e\\\\xe9\\\\x1f\\\\x13\\\\x1f>\\\\x1fi\\\\x1f\\\\x94\\\\x1f\\\\xbf\\\\x1f\\\\xea \\\\x15 A l \\\\x98 \\\\xc4 \\\\xf0!\\\\x1c!H!u!\\\\xa1!\\\\xce!\\\\xfb\\\"\\\\'\\\"U\\\"\\\\x82\\\"\\\\xaf\\\"\\\\xdd#\\\\n#8#f#\\\\x94#\\\\xc2#\\\\xf0$\\\\x1f$M$|$\\\\xab$\\\\xda%\\\\t%8%h%\\\\x97%\\\\xc7%\\\\xf7&\\\\'&W&\\\\x87&\\\\xb7&\\\\xe8\\\\'\\\\x18\\\\'I\\\\'z\\\\'\\\\xab\\\\'\\\\xdc(\\\\r(?(q(\\\\xa2(\\\\xd4)\\\\x06)8)k)\\\\x9d)\\\\xd0*\\\\x02*5*h*\\\\x9b*\\\\xcf+\\\\x02+6+i+\\\\x9d+\\\\xd1,\\\\x05,9,n,\\\\xa2,\\\\xd7-\\\\x0c-A-v-\\\\xab-\\\\xe1.\\\\x16.L.\\\\x82.\\\\xb7.\\\\xee/$/Z/\\\\x91/\\\\xc7/\\\\xfe050l0\\\\xa40\\\\xdb1\\\\x121J1\\\\x821\\\\xba1\\\\xf22*2c2\\\\x9b2\\\\xd43\\\\r3F3\\\\x7f3\\\\xb83\\\\xf14+4e4\\\\x9e4\\\\xd85\\\\x135M5\\\\x875\\\\xc25\\\\xfd676r6\\\\xae6\\\\xe97$7`7\\\\x9c7\\\\xd78\\\\x148P8\\\\x8c8\\\\xc89\\\\x059B9\\\\x7f9\\\\xbc9\\\\xf9:6:t:\\\\xb2:\\\\xef;-;k;\\\\xaa;\\\\xe8<\\\\'<e<\\\\xa4<\\\\xe3=\\\"=a=\\\\xa1=\\\\xe0> >`>\\\\xa0>\\\\xe0?!?a?\\\\xa2?\\\\xe2@#@d@\\\\xa6@\\\\xe7A)AjA\\\\xacA\\\\xeeB0BrB\\\\xb5B\\\\xf7C:C}C\\\\xc0D\\\\x03DGD\\\\x8aD\\\\xceE\\\\x12EUE\\\\x9aE\\\\xdeF\\\"FgF\\\\xabF\\\\xf0G5G{G\\\\xc0H\\\\x05HKH\\\\x91H\\\\xd7I\\\\x1dIcI\\\\xa9I\\\\xf0J7J}J\\\\xc4K\\\\x0cKSK\\\\x9aK\\\\xe2L*LrL\\\\xbaM\\\\x02MJM\\\\x93M\\\\xdcN%NnN\\\\xb7O\\\\x00OIO\\\\x93O\\\\xddP\\\\'PqP\\\\xbbQ\\\\x06QPQ\\\\x9bQ\\\\xe6R1R|R\\\\xc7S\\\\x13S_S\\\\xaaS\\\\xf6TBT\\\\x8fT\\\\xdbU(UuU\\\\xc2V\\\\x0fV\\\\\\\\V\\\\xa9V\\\\xf7WDW\\\\x92W\\\\xe0X/X}X\\\\xcbY\\\\x1aYiY\\\\xb8Z\\\\x07ZVZ\\\\xa6Z\\\\xf5[E[\\\\x95[\\\\xe5\\\\\\\\5\\\\\\\\\\\\x86\\\\\\\\\\\\xd6]\\\\']x]\\\\xc9^\\\\x1a^l^\\\\xbd_\\\\x0f_a_\\\\xb3`\\\\x05`W`\\\\xaa`\\\\xfcaOa\\\\xa2a\\\\xf5bIb\\\\x9cb\\\\xf0cCc\\\\x97c\\\\xebd@d\\\\x94d\\\\xe9e=e\\\\x92e\\\\xe7f=f\\\\x92f\\\\xe8g=g\\\\x93g\\\\xe9h?h\\\\x96h\\\\xeciCi\\\\x9ai\\\\xf1jHj\\\\x9fj\\\\xf7kOk\\\\xa7k\\\\xfflWl\\\\xafm\\\\x08m`m\\\\xb9n\\\\x12nkn\\\\xc4o\\\\x1eoxo\\\\xd1p+p\\\\x86p\\\\xe0q:q\\\\x95q\\\\xf0rKr\\\\xa6s\\\\x01s]s\\\\xb8t\\\\x14tpt\\\\xccu(u\\\\x85u\\\\xe1v>v\\\\x9bv\\\\xf8wVw\\\\xb3x\\\\x11xnx\\\\xccy*y\\\\x89y\\\\xe7zFz\\\\xa5{\\\\x04{c{\\\\xc2|!|\\\\x81|\\\\xe1}A}\\\\xa1~\\\\x01~b~\\\\xc2\\\\x7f#\\\\x7f\\\\x84\\\\x7f\\\\xe5\\\\x80G\\\\x80\\\\xa8\\\\x81\\\\n\\\\x81k\\\\x81\\\\xcd\\\\x820\\\\x82\\\\x92\\\\x82\\\\xf4\\\\x83W\\\\x83\\\\xba\\\\x84\\\\x1d\\\\x84\\\\x80\\\\x84\\\\xe3\\\\x85G\\\\x85\\\\xab\\\\x86\\\\x0e\\\\x86r\\\\x86\\\\xd7\\\\x87;\\\\x87\\\\x9f\\\\x88\\\\x04\\\\x88i\\\\x88\\\\xce\\\\x893\\\\x89\\\\x99\\\\x89\\\\xfe\\\\x8ad\\\\x8a\\\\xca\\\\x8b0\\\\x8b\\\\x96\\\\x8b\\\\xfc\\\\x8cc\\\\x8c\\\\xca\\\\x8d1\\\\x8d\\\\x98\\\\x8d\\\\xff\\\\x8ef\\\\x8e\\\\xce\\\\x8f6\\\\x8f\\\\x9e\\\\x90\\\\x06\\\\x90n\\\\x90\\\\xd6\\\\x91?\\\\x91\\\\xa8\\\\x92\\\\x11\\\\x92z\\\\x92\\\\xe3\\\\x93M\\\\x93\\\\xb6\\\\x94 \\\\x94\\\\x8a\\\\x94\\\\xf4\\\\x95_\\\\x95\\\\xc9\\\\x964\\\\x96\\\\x9f\\\\x97\\\\n\\\\x97u\\\\x97\\\\xe0\\\\x98L\\\\x98\\\\xb8\\\\x99$\\\\x99\\\\x90\\\\x99\\\\xfc\\\\x9ah\\\\x9a\\\\xd5\\\\x9bB\\\\x9b\\\\xaf\\\\x9c\\\\x1c\\\\x9c\\\\x89\\\\x9c\\\\xf7\\\\x9dd\\\\x9d\\\\xd2\\\\x9e@\\\\x9e\\\\xae\\\\x9f\\\\x1d\\\\x9f\\\\x8b\\\\x9f\\\\xfa\\\\xa0i\\\\xa0\\\\xd8\\\\xa1G\\\\xa1\\\\xb6\\\\xa2&\\\\xa2\\\\x96\\\\xa3\\\\x06\\\\xa3v\\\\xa3\\\\xe6\\\\xa4V\\\\xa4\\\\xc7\\\\xa58\\\\xa5\\\\xa9\\\\xa6\\\\x1a\\\\xa6\\\\x8b\\\\xa6\\\\xfd\\\\xa7n\\\\xa7\\\\xe0\\\\xa8R\\\\xa8\\\\xc4\\\\xa97\\\\xa9\\\\xa9\\\\xaa\\\\x1c\\\\xaa\\\\x8f\\\\xab\\\\x02\\\\xabu\\\\xab\\\\xe9\\\\xac\\\\\\\\\\\\xac\\\\xd0\\\\xadD\\\\xad\\\\xb8\\\\xae-\\\\xae\\\\xa1\\\\xaf\\\\x16\\\\xaf\\\\x8b\\\\xb0\\\\x00\\\\xb0u\\\\xb0\\\\xea\\\\xb1`\\\\xb1\\\\xd6\\\\xb2K\\\\xb2\\\\xc2\\\\xb38\\\\xb3\\\\xae\\\\xb4%\\\\xb4\\\\x9c\\\\xb5\\\\x13\\\\xb5\\\\x8a\\\\xb6\\\\x01\\\\xb6y\\\\xb6\\\\xf0\\\\xb7h\\\\xb7\\\\xe0\\\\xb8Y\\\\xb8\\\\xd1\\\\xb9J\\\\xb9\\\\xc2\\\\xba;\\\\xba\\\\xb5\\\\xbb.\\\\xbb\\\\xa7\\\\xbc!\\\\xbc\\\\x9b\\\\xbd\\\\x15\\\\xbd\\\\x8f\\\\xbe\\\\n\\\\xbe\\\\x84\\\\xbe\\\\xff\\\\xbfz\\\\xbf\\\\xf5\\\\xc0p\\\\xc0\\\\xec\\\\xc1g\\\\xc1\\\\xe3\\\\xc2_\\\\xc2\\\\xdb\\\\xc3X\\\\xc3\\\\xd4\\\\xc4Q\\\\xc4\\\\xce\\\\xc5K\\\\xc5\\\\xc8\\\\xc6F\\\\xc6\\\\xc3\\\\xc7A\\\\xc7\\\\xbf\\\\xc8=\\\\xc8\\\\xbc\\\\xc9:\\\\xc9\\\\xb9\\\\xca8\\\\xca\\\\xb7\\\\xcb6\\\\xcb\\\\xb6\\\\xcc5\\\\xcc\\\\xb5\\\\xcd5\\\\xcd\\\\xb5\\\\xce6\\\\xce\\\\xb6\\\\xcf7\\\\xcf\\\\xb8\\\\xd09\\\\xd0\\\\xba\\\\xd1<\\\\xd1\\\\xbe\\\\xd2?\\\\xd2\\\\xc1\\\\xd3D\\\\xd3\\\\xc6\\\\xd4I\\\\xd4\\\\xcb\\\\xd5N\\\\xd5\\\\xd1\\\\xd6U\\\\xd6\\\\xd8\\\\xd7\\\\\\\\\\\\xd7\\\\xe0\\\\xd8d\\\\xd8\\\\xe8\\\\xd9l\\\\xd9\\\\xf1\\\\xdav\\\\xda\\\\xfb\\\\xdb\\\\x80\\\\xdc\\\\x05\\\\xdc\\\\x8a\\\\xdd\\\\x10\\\\xdd\\\\x96\\\\xde\\\\x1c\\\\xde\\\\xa2\\\\xdf)\\\\xdf\\\\xaf\\\\xe06\\\\xe0\\\\xbd\\\\xe1D\\\\xe1\\\\xcc\\\\xe2S\\\\xe2\\\\xdb\\\\xe3c\\\\xe3\\\\xeb\\\\xe4s\\\\xe4\\\\xfc\\\\xe5\\\\x84\\\\xe6\\\\r\\\\xe6\\\\x96\\\\xe7\\\\x1f\\\\xe7\\\\xa9\\\\xe82\\\\xe8\\\\xbc\\\\xe9F\\\\xe9\\\\xd0\\\\xea[\\\\xea\\\\xe5\\\\xebp\\\\xeb\\\\xfb\\\\xec\\\\x86\\\\xed\\\\x11\\\\xed\\\\x9c\\\\xee(\\\\xee\\\\xb4\\\\xef@\\\\xef\\\\xcc\\\\xf0X\\\\xf0\\\\xe5\\\\xf1r\\\\xf1\\\\xff\\\\xf2\\\\x8c\\\\xf3\\\\x19\\\\xf3\\\\xa7\\\\xf44\\\\xf4\\\\xc2\\\\xf5P\\\\xf5\\\\xde\\\\xf6m\\\\xf6\\\\xfb\\\\xf7\\\\x8a\\\\xf8\\\\x19\\\\xf8\\\\xa8\\\\xf98\\\\xf9\\\\xc7\\\\xfaW\\\\xfa\\\\xe7\\\\xfbw\\\\xfc\\\\x07\\\\xfc\\\\x98\\\\xfd)\\\\xfd\\\\xba\\\\xfeK\\\\xfe\\\\xdc\\\\xffm\\\\xff\\\\xffcurv\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x04\\\\x00\\\\x00\\\\x00\\\\x00\\\\x05\\\\x00\\\\n\\\\x00\\\\x0f\\\\x00\\\\x14\\\\x00\\\\x19\\\\x00\\\\x1e\\\\x00#\\\\x00(\\\\x00-\\\\x002\\\\x007\\\\x00;\\\\x00@\\\\x00E\\\\x00J\\\\x00O\\\\x00T\\\\x00Y\\\\x00^\\\\x00c\\\\x00h\\\\x00m\\\\x00r\\\\x00w\\\\x00|\\\\x00\\\\x81\\\\x00\\\\x86\\\\x00\\\\x8b\\\\x00\\\\x90\\\\x00\\\\x95\\\\x00\\\\x9a\\\\x00\\\\x9f\\\\x00\\\\xa4\\\\x00\\\\xa9\\\\x00\\\\xae\\\\x00\\\\xb2\\\\x00\\\\xb7\\\\x00\\\\xbc\\\\x00\\\\xc1\\\\x00\\\\xc6\\\\x00\\\\xcb\\\\x00\\\\xd0\\\\x00\\\\xd5\\\\x00\\\\xdb\\\\x00\\\\xe0\\\\x00\\\\xe5\\\\x00\\\\xeb\\\\x00\\\\xf0\\\\x00\\\\xf6\\\\x00\\\\xfb\\\\x01\\\\x01\\\\x01\\\\x07\\\\x01\\\\r\\\\x01\\\\x13\\\\x01\\\\x19\\\\x01\\\\x1f\\\\x01%\\\\x01+\\\\x012\\\\x018\\\\x01>\\\\x01E\\\\x01L\\\\x01R\\\\x01Y\\\\x01`\\\\x01g\\\\x01n\\\\x01u\\\\x01|\\\\x01\\\\x83\\\\x01\\\\x8b\\\\x01\\\\x92\\\\x01\\\\x9a\\\\x01\\\\xa1\\\\x01\\\\xa9\\\\x01\\\\xb1\\\\x01\\\\xb9\\\\x01\\\\xc1\\\\x01\\\\xc9\\\\x01\\\\xd1\\\\x01\\\\xd9\\\\x01\\\\xe1\\\\x01\\\\xe9\\\\x01\\\\xf2\\\\x01\\\\xfa\\\\x02\\\\x03\\\\x02\\\\x0c\\\\x02\\\\x14\\\\x02\\\\x1d\\\\x02&\\\\x02/\\\\x028\\\\x02A\\\\x02K\\\\x02T\\\\x02]\\\\x02g\\\\x02q\\\\x02z\\\\x02\\\\x84\\\\x02\\\\x8e\\\\x02\\\\x98\\\\x02\\\\xa2\\\\x02\\\\xac\\\\x02\\\\xb6\\\\x02\\\\xc1\\\\x02\\\\xcb\\\\x02\\\\xd5\\\\x02\\\\xe0\\\\x02\\\\xeb\\\\x02\\\\xf5\\\\x03\\\\x00\\\\x03\\\\x0b\\\\x03\\\\x16\\\\x03!\\\\x03-\\\\x038\\\\x03C\\\\x03O\\\\x03Z\\\\x03f\\\\x03r\\\\x03~\\\\x03\\\\x8a\\\\x03\\\\x96\\\\x03\\\\xa2\\\\x03\\\\xae\\\\x03\\\\xba\\\\x03\\\\xc7\\\\x03\\\\xd3\\\\x03\\\\xe0\\\\x03\\\\xec\\\\x03\\\\xf9\\\\x04\\\\x06\\\\x04\\\\x13\\\\x04 \\\\x04-\\\\x04;\\\\x04H\\\\x04U\\\\x04c\\\\x04q\\\\x04~\\\\x04\\\\x8c\\\\x04\\\\x9a\\\\x04\\\\xa8\\\\x04\\\\xb6\\\\x04\\\\xc4\\\\x04\\\\xd3\\\\x04\\\\xe1\\\\x04\\\\xf0\\\\x04\\\\xfe\\\\x05\\\\r\\\\x05\\\\x1c\\\\x05+\\\\x05:\\\\x05I\\\\x05X\\\\x05g\\\\x05w\\\\x05\\\\x86\\\\x05\\\\x96\\\\x05\\\\xa6\\\\x05\\\\xb5\\\\x05\\\\xc5\\\\x05\\\\xd5\\\\x05\\\\xe5\\\\x05\\\\xf6\\\\x06\\\\x06\\\\x06\\\\x16\\\\x06\\\\'\\\\x067\\\\x06H\\\\x06Y\\\\x06j\\\\x06{\\\\x06\\\\x8c\\\\x06\\\\x9d\\\\x06\\\\xaf\\\\x06\\\\xc0\\\\x06\\\\xd1\\\\x06\\\\xe3\\\\x06\\\\xf5\\\\x07\\\\x07\\\\x07\\\\x19\\\\x07+\\\\x07=\\\\x07O\\\\x07a\\\\x07t\\\\x07\\\\x86\\\\x07\\\\x99\\\\x07\\\\xac\\\\x07\\\\xbf\\\\x07\\\\xd2\\\\x07\\\\xe5\\\\x07\\\\xf8\\\\x08\\\\x0b\\\\x08\\\\x1f\\\\x082\\\\x08F\\\\x08Z\\\\x08n\\\\x08\\\\x82\\\\x08\\\\x96\\\\x08\\\\xaa\\\\x08\\\\xbe\\\\x08\\\\xd2\\\\x08\\\\xe7\\\\x08\\\\xfb\\\\t\\\\x10\\\\t%\\\\t:\\\\tO\\\\td\\\\ty\\\\t\\\\x8f\\\\t\\\\xa4\\\\t\\\\xba\\\\t\\\\xcf\\\\t\\\\xe5\\\\t\\\\xfb\\\\n\\\\x11\\\\n\\\\'\\\\n=\\\\nT\\\\nj\\\\n\\\\x81\\\\n\\\\x98\\\\n\\\\xae\\\\n\\\\xc5\\\\n\\\\xdc\\\\n\\\\xf3\\\\x0b\\\\x0b\\\\x0b\\\"\\\\x0b9\\\\x0bQ\\\\x0bi\\\\x0b\\\\x80\\\\x0b\\\\x98\\\\x0b\\\\xb0\\\\x0b\\\\xc8\\\\x0b\\\\xe1\\\\x0b\\\\xf9\\\\x0c\\\\x12\\\\x0c*\\\\x0cC\\\\x0c\\\\\\\\\\\\x0cu\\\\x0c\\\\x8e\\\\x0c\\\\xa7\\\\x0c\\\\xc0\\\\x0c\\\\xd9\\\\x0c\\\\xf3\\\\r\\\\r\\\\r&\\\\r@\\\\rZ\\\\rt\\\\r\\\\x8e\\\\r\\\\xa9\\\\r\\\\xc3\\\\r\\\\xde\\\\r\\\\xf8\\\\x0e\\\\x13\\\\x0e.\\\\x0eI\\\\x0ed\\\\x0e\\\\x7f\\\\x0e\\\\x9b\\\\x0e\\\\xb6\\\\x0e\\\\xd2\\\\x0e\\\\xee\\\\x0f\\\\t\\\\x0f%\\\\x0fA\\\\x0f^\\\\x0fz\\\\x0f\\\\x96\\\\x0f\\\\xb3\\\\x0f\\\\xcf\\\\x0f\\\\xec\\\\x10\\\\t\\\\x10&\\\\x10C\\\\x10a\\\\x10~\\\\x10\\\\x9b\\\\x10\\\\xb9\\\\x10\\\\xd7\\\\x10\\\\xf5\\\\x11\\\\x13\\\\x111\\\\x11O\\\\x11m\\\\x11\\\\x8c\\\\x11\\\\xaa\\\\x11\\\\xc9\\\\x11\\\\xe8\\\\x12\\\\x07\\\\x12&\\\\x12E\\\\x12d\\\\x12\\\\x84\\\\x12\\\\xa3\\\\x12\\\\xc3\\\\x12\\\\xe3\\\\x13\\\\x03\\\\x13#\\\\x13C\\\\x13c\\\\x13\\\\x83\\\\x13\\\\xa4\\\\x13\\\\xc5\\\\x13\\\\xe5\\\\x14\\\\x06\\\\x14\\\\'\\\\x14I\\\\x14j\\\\x14\\\\x8b\\\\x14\\\\xad\\\\x14\\\\xce\\\\x14\\\\xf0\\\\x15\\\\x12\\\\x154\\\\x15V\\\\x15x\\\\x15\\\\x9b\\\\x15\\\\xbd\\\\x15\\\\xe0\\\\x16\\\\x03\\\\x16&\\\\x16I\\\\x16l\\\\x16\\\\x8f\\\\x16\\\\xb2\\\\x16\\\\xd6\\\\x16\\\\xfa\\\\x17\\\\x1d\\\\x17A\\\\x17e\\\\x17\\\\x89\\\\x17\\\\xae\\\\x17\\\\xd2\\\\x17\\\\xf7\\\\x18\\\\x1b\\\\x18@\\\\x18e\\\\x18\\\\x8a\\\\x18\\\\xaf\\\\x18\\\\xd5\\\\x18\\\\xfa\\\\x19 \\\\x19E\\\\x19k\\\\x19\\\\x91\\\\x19\\\\xb7\\\\x19\\\\xdd\\\\x1a\\\\x04\\\\x1a*\\\\x1aQ\\\\x1aw\\\\x1a\\\\x9e\\\\x1a\\\\xc5\\\\x1a\\\\xec\\\\x1b\\\\x14\\\\x1b;\\\\x1bc\\\\x1b\\\\x8a\\\\x1b\\\\xb2\\\\x1b\\\\xda\\\\x1c\\\\x02\\\\x1c*\\\\x1cR\\\\x1c{\\\\x1c\\\\xa3\\\\x1c\\\\xcc\\\\x1c\\\\xf5\\\\x1d\\\\x1e\\\\x1dG\\\\x1dp\\\\x1d\\\\x99\\\\x1d\\\\xc3\\\\x1d\\\\xec\\\\x1e\\\\x16\\\\x1e@\\\\x1ej\\\\x1e\\\\x94\\\\x1e\\\\xbe\\\\x1e\\\\xe9\\\\x1f\\\\x13\\\\x1f>\\\\x1fi\\\\x1f\\\\x94\\\\x1f\\\\xbf\\\\x1f\\\\xea \\\\x15 A l \\\\x98 \\\\xc4 \\\\xf0!\\\\x1c!H!u!\\\\xa1!\\\\xce!\\\\xfb\\\"\\\\'\\\"U\\\"\\\\x82\\\"\\\\xaf\\\"\\\\xdd#\\\\n#8#f#\\\\x94#\\\\xc2#\\\\xf0$\\\\x1f$M$|$\\\\xab$\\\\xda%\\\\t%8%h%\\\\x97%\\\\xc7%\\\\xf7&\\\\'&W&\\\\x87&\\\\xb7&\\\\xe8\\\\'\\\\x18\\\\'I\\\\'z\\\\'\\\\xab\\\\'\\\\xdc(\\\\r(?(q(\\\\xa2(\\\\xd4)\\\\x06)8)k)\\\\x9d)\\\\xd0*\\\\x02*5*h*\\\\x9b*\\\\xcf+\\\\x02+6+i+\\\\x9d+\\\\xd1,\\\\x05,9,n,\\\\xa2,\\\\xd7-\\\\x0c-A-v-\\\\xab-\\\\xe1.\\\\x16.L.\\\\x82.\\\\xb7.\\\\xee/$/Z/\\\\x91/\\\\xc7/\\\\xfe050l0\\\\xa40\\\\xdb1\\\\x121J1\\\\x821\\\\xba1\\\\xf22*2c2\\\\x9b2\\\\xd43\\\\r3F3\\\\x7f3\\\\xb83\\\\xf14+4e4\\\\x9e4\\\\xd85\\\\x135M5\\\\x875\\\\xc25\\\\xfd676r6\\\\xae6\\\\xe97$7`7\\\\x9c7\\\\xd78\\\\x148P8\\\\x8c8\\\\xc89\\\\x059B9\\\\x7f9\\\\xbc9\\\\xf9:6:t:\\\\xb2:\\\\xef;-;k;\\\\xaa;\\\\xe8<\\\\'<e<\\\\xa4<\\\\xe3=\\\"=a=\\\\xa1=\\\\xe0> >`>\\\\xa0>\\\\xe0?!?a?\\\\xa2?\\\\xe2@#@d@\\\\xa6@\\\\xe7A)AjA\\\\xacA\\\\xeeB0BrB\\\\xb5B\\\\xf7C:C}C\\\\xc0D\\\\x03DGD\\\\x8aD\\\\xceE\\\\x12EUE\\\\x9aE\\\\xdeF\\\"FgF\\\\xabF\\\\xf0G5G{G\\\\xc0H\\\\x05HKH\\\\x91H\\\\xd7I\\\\x1dIcI\\\\xa9I\\\\xf0J7J}J\\\\xc4K\\\\x0cKSK\\\\x9aK\\\\xe2L*LrL\\\\xbaM\\\\x02MJM\\\\x93M\\\\xdcN%NnN\\\\xb7O\\\\x00OIO\\\\x93O\\\\xddP\\\\'PqP\\\\xbbQ\\\\x06QPQ\\\\x9bQ\\\\xe6R1R|R\\\\xc7S\\\\x13S_S\\\\xaaS\\\\xf6TBT\\\\x8fT\\\\xdbU(UuU\\\\xc2V\\\\x0fV\\\\\\\\V\\\\xa9V\\\\xf7WDW\\\\x92W\\\\xe0X/X}X\\\\xcbY\\\\x1aYiY\\\\xb8Z\\\\x07ZVZ\\\\xa6Z\\\\xf5[E[\\\\x95[\\\\xe5\\\\\\\\5\\\\\\\\\\\\x86\\\\\\\\\\\\xd6]\\\\']x]\\\\xc9^\\\\x1a^l^\\\\xbd_\\\\x0f_a_\\\\xb3`\\\\x05`W`\\\\xaa`\\\\xfcaOa\\\\xa2a\\\\xf5bIb\\\\x9cb\\\\xf0cCc\\\\x97c\\\\xebd@d\\\\x94d\\\\xe9e=e\\\\x92e\\\\xe7f=f\\\\x92f\\\\xe8g=g\\\\x93g\\\\xe9h?h\\\\x96h\\\\xeciCi\\\\x9ai\\\\xf1jHj\\\\x9fj\\\\xf7kOk\\\\xa7k\\\\xfflWl\\\\xafm\\\\x08m`m\\\\xb9n\\\\x12nkn\\\\xc4o\\\\x1eoxo\\\\xd1p+p\\\\x86p\\\\xe0q:q\\\\x95q\\\\xf0rKr\\\\xa6s\\\\x01s]s\\\\xb8t\\\\x14tpt\\\\xccu(u\\\\x85u\\\\xe1v>v\\\\x9bv\\\\xf8wVw\\\\xb3x\\\\x11xnx\\\\xccy*y\\\\x89y\\\\xe7zFz\\\\xa5{\\\\x04{c{\\\\xc2|!|\\\\x81|\\\\xe1}A}\\\\xa1~\\\\x01~b~\\\\xc2\\\\x7f#\\\\x7f\\\\x84\\\\x7f\\\\xe5\\\\x80G\\\\x80\\\\xa8\\\\x81\\\\n\\\\x81k\\\\x81\\\\xcd\\\\x820\\\\x82\\\\x92\\\\x82\\\\xf4\\\\x83W\\\\x83\\\\xba\\\\x84\\\\x1d\\\\x84\\\\x80\\\\x84\\\\xe3\\\\x85G\\\\x85\\\\xab\\\\x86\\\\x0e\\\\x86r\\\\x86\\\\xd7\\\\x87;\\\\x87\\\\x9f\\\\x88\\\\x04\\\\x88i\\\\x88\\\\xce\\\\x893\\\\x89\\\\x99\\\\x89\\\\xfe\\\\x8ad\\\\x8a\\\\xca\\\\x8b0\\\\x8b\\\\x96\\\\x8b\\\\xfc\\\\x8cc\\\\x8c\\\\xca\\\\x8d1\\\\x8d\\\\x98\\\\x8d\\\\xff\\\\x8ef\\\\x8e\\\\xce\\\\x8f6\\\\x8f\\\\x9e\\\\x90\\\\x06\\\\x90n\\\\x90\\\\xd6\\\\x91?\\\\x91\\\\xa8\\\\x92\\\\x11\\\\x92z\\\\x92\\\\xe3\\\\x93M\\\\x93\\\\xb6\\\\x94 \\\\x94\\\\x8a\\\\x94\\\\xf4\\\\x95_\\\\x95\\\\xc9\\\\x964\\\\x96\\\\x9f\\\\x97\\\\n\\\\x97u\\\\x97\\\\xe0\\\\x98L\\\\x98\\\\xb8\\\\x99$\\\\x99\\\\x90\\\\x99\\\\xfc\\\\x9ah\\\\x9a\\\\xd5\\\\x9bB\\\\x9b\\\\xaf\\\\x9c\\\\x1c\\\\x9c\\\\x89\\\\x9c\\\\xf7\\\\x9dd\\\\x9d\\\\xd2\\\\x9e@\\\\x9e\\\\xae\\\\x9f\\\\x1d\\\\x9f\\\\x8b\\\\x9f\\\\xfa\\\\xa0i\\\\xa0\\\\xd8\\\\xa1G\\\\xa1\\\\xb6\\\\xa2&\\\\xa2\\\\x96\\\\xa3\\\\x06\\\\xa3v\\\\xa3\\\\xe6\\\\xa4V\\\\xa4\\\\xc7\\\\xa58\\\\xa5\\\\xa9\\\\xa6\\\\x1a\\\\xa6\\\\x8b\\\\xa6\\\\xfd\\\\xa7n\\\\xa7\\\\xe0\\\\xa8R\\\\xa8\\\\xc4\\\\xa97\\\\xa9\\\\xa9\\\\xaa\\\\x1c\\\\xaa\\\\x8f\\\\xab\\\\x02\\\\xabu\\\\xab\\\\xe9\\\\xac\\\\\\\\\\\\xac\\\\xd0\\\\xadD\\\\xad\\\\xb8\\\\xae-\\\\xae\\\\xa1\\\\xaf\\\\x16\\\\xaf\\\\x8b\\\\xb0\\\\x00\\\\xb0u\\\\xb0\\\\xea\\\\xb1`\\\\xb1\\\\xd6\\\\xb2K\\\\xb2\\\\xc2\\\\xb38\\\\xb3\\\\xae\\\\xb4%\\\\xb4\\\\x9c\\\\xb5\\\\x13\\\\xb5\\\\x8a\\\\xb6\\\\x01\\\\xb6y\\\\xb6\\\\xf0\\\\xb7h\\\\xb7\\\\xe0\\\\xb8Y\\\\xb8\\\\xd1\\\\xb9J\\\\xb9\\\\xc2\\\\xba;\\\\xba\\\\xb5\\\\xbb.\\\\xbb\\\\xa7\\\\xbc!\\\\xbc\\\\x9b\\\\xbd\\\\x15\\\\xbd\\\\x8f\\\\xbe\\\\n\\\\xbe\\\\x84\\\\xbe\\\\xff\\\\xbfz\\\\xbf\\\\xf5\\\\xc0p\\\\xc0\\\\xec\\\\xc1g\\\\xc1\\\\xe3\\\\xc2_\\\\xc2\\\\xdb\\\\xc3X\\\\xc3\\\\xd4\\\\xc4Q\\\\xc4\\\\xce\\\\xc5K\\\\xc5\\\\xc8\\\\xc6F\\\\xc6\\\\xc3\\\\xc7A\\\\xc7\\\\xbf\\\\xc8=\\\\xc8\\\\xbc\\\\xc9:\\\\xc9\\\\xb9\\\\xca8\\\\xca\\\\xb7\\\\xcb6\\\\xcb\\\\xb6\\\\xcc5\\\\xcc\\\\xb5\\\\xcd5\\\\xcd\\\\xb5\\\\xce6\\\\xce\\\\xb6\\\\xcf7\\\\xcf\\\\xb8\\\\xd09\\\\xd0\\\\xba\\\\xd1<\\\\xd1\\\\xbe\\\\xd2?\\\\xd2\\\\xc1\\\\xd3D\\\\xd3\\\\xc6\\\\xd4I\\\\xd4\\\\xcb\\\\xd5N\\\\xd5\\\\xd1\\\\xd6U\\\\xd6\\\\xd8\\\\xd7\\\\\\\\\\\\xd7\\\\xe0\\\\xd8d\\\\xd8\\\\xe8\\\\xd9l\\\\xd9\\\\xf1\\\\xdav\\\\xda\\\\xfb\\\\xdb\\\\x80\\\\xdc\\\\x05\\\\xdc\\\\x8a\\\\xdd\\\\x10\\\\xdd\\\\x96\\\\xde\\\\x1c\\\\xde\\\\xa2\\\\xdf)\\\\xdf\\\\xaf\\\\xe06\\\\xe0\\\\xbd\\\\xe1D\\\\xe1\\\\xcc\\\\xe2S\\\\xe2\\\\xdb\\\\xe3c\\\\xe3\\\\xeb\\\\xe4s\\\\xe4\\\\xfc\\\\xe5\\\\x84\\\\xe6\\\\r\\\\xe6\\\\x96\\\\xe7\\\\x1f\\\\xe7\\\\xa9\\\\xe82\\\\xe8\\\\xbc\\\\xe9F\\\\xe9\\\\xd0\\\\xea[\\\\xea\\\\xe5\\\\xebp\\\\xeb\\\\xfb\\\\xec\\\\x86\\\\xed\\\\x11\\\\xed\\\\x9c\\\\xee(\\\\xee\\\\xb4\\\\xef@\\\\xef\\\\xcc\\\\xf0X\\\\xf0\\\\xe5\\\\xf1r\\\\xf1\\\\xff\\\\xf2\\\\x8c\\\\xf3\\\\x19\\\\xf3\\\\xa7\\\\xf44\\\\xf4\\\\xc2\\\\xf5P\\\\xf5\\\\xde\\\\xf6m\\\\xf6\\\\xfb\\\\xf7\\\\x8a\\\\xf8\\\\x19\\\\xf8\\\\xa8\\\\xf98\\\\xf9\\\\xc7\\\\xfaW\\\\xfa\\\\xe7\\\\xfbw\\\\xfc\\\\x07\\\\xfc\\\\x98\\\\xfd)\\\\xfd\\\\xba\\\\xfeK\\\\xfe\\\\xdc\\\\xffm\\\\xff\\\\xffchrm\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x03\\\\x00\\\\x00\\\\x00\\\\x00\\\\xa3\\\\xd7\\\\x00\\\\x00T{\\\\x00\\\\x00L\\\\xcd\\\\x00\\\\x00\\\\x99\\\\x9a\\\\x00\\\\x00&f\\\\x00\\\\x00\\\\x0f\\\\\\\\text\\\\x00\\\\x00\\\\x00\\\\x00no copyright, use freely\\\\x00\\\\n'\\n ds7.OpticalPathIdentifier = '1'\\n # noinspection SpellCheckingInspection\\n ds7.OpticalPathDescription = 'Brightfield'\\n\\n dcm.OpticalPathSequence = Sequence([ds7])\\n del ds7, ds5, ds4\\n\\n dcm.AcquisitionContextSequence = Sequence([])\\n\\n ds0 = Dataset()\\n ds0.LocalNamespaceEntityID = 'UNKNOWN'\\n dcm.IssuerOfTheContainerIdentifierSequence = Sequence([ds0])\\n del ds0\\n\\n ds0 = Dataset()\\n\\n ds0.SpecimenIdentifier = 'UNKNOWN'\\n ds0.SpecimenPreparationSequence = Sequence([])\\n ds0.SpecimenUID = generate_uid(prefix=None)\\n ds0.IssuerOfTheSpecimenIdentifierSequence = Sequence([])\\n dcm.SpecimenDescriptionSequence = Sequence([ds0])\\n dcm.ContainerTypeCodeSequence = Sequence([])\\n dcm.ContainerIdentifier = 'UNKNOWN'\\n return dcm\",\n \"def make_squiggle(sequence, model, std_multiplier=1.0):\\n # Find k for kmers from model\\n k = len(model.index.values[0])\\n\\n # number of events\\n n = len(sequence) - k\\n\\n # prepare means\\n means = np.zeros(n, dtype=\\\"float64\\\")\\n stdvs = np.zeros(n, dtype=\\\"float64\\\")\\n\\n for i in range(n):\\n kmer = sequence[i:i + k].values.tostring()\\n means[i] = model.ix[kmer][\\\"level_mean\\\"]\\n stdvs[i] = model.ix[kmer][\\\"level_stdv\\\"]\\n x = np.random.normal(means, stdvs * std_multiplier)\\n return x\",\n \"def random_crop_generator(batches, crop_length):\\n while True:\\n batch_x, batch_y = next(batches)\\n batch_crops = np.zeros((batch_x.shape[0], crop_length, crop_length, 3))\\n for i in range(batch_x.shape[0]):\\n batch_crops[i] = random_crop(batch_x[i], (crop_length, crop_length))\\n yield (batch_crops, batch_y)\",\n \"def generate_model (d):\\n return np.random.rand (d+1, 1)\",\n \"def make_data_iterator(dataset, batch_size):\\n \\n if dataset == '8gaussians':\\n scale = 2.\\n centers = [\\n (1, 0),\\n (-1, 0),\\n (0, 1),\\n (0, -1),\\n (1. / np.sqrt(2), 1. / np.sqrt(2)),\\n (1. / np.sqrt(2), -1. / np.sqrt(2)),\\n (-1. / np.sqrt(2), 1. / np.sqrt(2)),\\n (-1. / np.sqrt(2), -1. / np.sqrt(2))\\n ]\\n centers = [(scale * x, scale * y) for x, y in centers]\\n while True:\\n dataset = []\\n for i in range(batch_size):\\n point = np.random.randn(2) * .2\\n center = random.choice(centers)\\n point[0] += center[0]\\n point[1] += center[1]\\n dataset.append(point)\\n dataset = torch.Tensor(dataset)\\n dataset /= 1.414 # stdev\\n yield dataset\\n \\n elif dataset == 'sine':\\n while True:\\n noise = 0.2\\n x = torch.linspace(-4, 4, batch_size, dtype=torch.float32)\\n y = np.sin(x) + noise*np.random.randn(*x.shape)\\n yield torch.stack([x, y], dim=1)\\n \\n elif dataset == 'heteroscedastic':\\n theta = torch.linspace(0, 2, batch_size)\\n x = np.exp(theta)*np.tan(0.1*theta)\\n while True:\\n b = (0.001 + 0.5 * np.abs(x)) * np.random.normal(1, 1, batch_size)\\n y = np.exp(theta)*np.sin(0.1*theta) + b\\n yield torch.stack([x, y], dim=1)\\n \\n elif dataset == 'moon':\\n noise = 0.1\\n while True:\\n data, _ = sklearn.datasets.make_moons(n_samples=batch_size,\\n noise=noise)\\n yield torch.Tensor(data)\\n \\n elif dataset == 'helix':\\n noise = 0.2\\n while True:\\n t = torch.linspace(0, 20, batch_size)\\n x = np.cos(t)\\n x2 = np.sin(t) + noise * np.random.randn(*x.shape)\\n \\n yield torch.stack([x, x2, t], dim=1)\\n \\n elif dataset == 'circle':\\n while True:\\n t = np.random.random(batch_size) * 2 * np.pi - np.pi\\n length = 1 - np.random.random(batch_size)*0.4\\n x = torch.Tensor(np.multiply(np.cos(t), length))\\n y = torch.Tensor(np.multiply(np.sin(t), length))\\n \\n yield torch.stack([x, y], dim=1)\\n\\n elif dataset == '2spirals':\\n while True:\\n z = torch.randn(batch_size, 2)\\n n = torch.sqrt(torch.rand(batch_size // 2)) * 540 * (2 * math.pi) / 360\\n d1x = - torch.cos(n) * n + torch.rand(batch_size // 2) * 0.5\\n d1y = torch.sin(n) * n + torch.rand(batch_size // 2) * 0.5\\n x = torch.cat([torch.stack([ d1x, d1y], dim=1),\\n torch.stack([-d1x, -d1y], dim=1)], dim=0) / 3\\n yield x + 0.1*z\",\n \"def batches(self, batch_size): \\n if self.shuffle:\\n idx = np.arange(len(dataset.train_x))\\n np.random.shuffle(idx)\\n self.train_x = self.train_x[idx]\\n \\n n_batches = len(self.train_x) // batch_size\\n for ii in range(0, len(self.train_x), batch_size):\\n x = self.train_x[ii:ii+batch_size]\\n \\n yield self.scaler(x)\",\n \"def generate_multi_type2(self, num_data, velocity, num_step, num_dim, test=False, visualize=False):\\n num_vel = len(velocity)\\n if not test:\\n # if pow(num_vel, num_step) < num_data:\\n # vel_list = np.asarray(list(itertools.product(np.arange(num_vel), repeat=num_step)))\\n # num_vel_list = len(vel_list)\\n #\\n # div, rem = num_data // num_vel_list, num_data % num_vel_list\\n # vel_idx = np.vstack((np.tile(vel_list, [div, 1]), vel_list[np.random.choice(num_vel_list, size=rem)]))\\n # np.random.shuffle(vel_idx)\\n # else:\\n vel_idx = np.random.choice(num_vel, size=[num_data, num_step])\\n\\n vel_grid = np.take(velocity, vel_idx, axis=0)\\n vel = vel_grid * self.interval_length\\n\\n vel_grid_cumsum = np.cumsum(vel_grid, axis=1)\\n mu_max = np.fmin(self.num_interval, np.min(self.num_interval - vel_grid_cumsum, axis=1))\\n mu_min = np.fmax(0, np.max(-vel_grid_cumsum, axis=1))\\n mu_start = np.random.sample(size=[num_data, num_dim])\\n mu_start = np.expand_dims(np.round(mu_start * (mu_max - mu_min) + mu_min - 0.5), axis=1)\\n mu_seq = np.concatenate((mu_start, mu_start + vel_grid_cumsum), axis=1)\\n else:\\n if visualize:\\n mu_start = np.reshape([4, 4], newshape=(1, 1, 2))\\n vel_pool = np.where((velocity[:, 0] >= -1) & (velocity[:, 1] >= -1))\\n vel_idx = np.random.choice(vel_pool[0], size=[num_data * 10, num_step])\\n\\n vel_grid_cumsum = np.cumsum(np.take(velocity, vel_idx, axis=0), axis=1)\\n mu_seq = np.concatenate((np.tile(mu_start, [num_data * 10, 1, 1]), vel_grid_cumsum + mu_start), axis=1)\\n mu_seq_new, vel_idx_new = [], []\\n for i in range(len(mu_seq)):\\n mu_seq_sub = mu_seq[i]\\n if len(np.unique(mu_seq_sub, axis=0)) == len(mu_seq_sub):\\n mu_seq_new.append(mu_seq[i])\\n vel_idx_new.append(vel_idx[i])\\n mu_seq, vel_idx = np.stack(mu_seq_new, axis=0), np.stack(vel_idx_new, axis=0)\\n mu_seq_rs = np.reshape(mu_seq, [-1, (num_step + 1) * 2])\\n select_idx = np.where(np.sum(mu_seq_rs >= self.num_interval, axis=1) == 0)[0][:num_data]\\n vel_idx = vel_idx[select_idx]\\n mu_seq = mu_seq[select_idx]\\n vel = np.take(velocity, vel_idx, axis=0) * self.interval_length\\n else:\\n vel_idx = np.random.choice(num_vel, size=[num_data * num_dim, num_step])\\n vel_grid_cumsum = np.cumsum(np.take(velocity, vel_idx, axis=0), axis=1)\\n mu_max = np.fmin(self.num_interval, np.min(self.num_interval - vel_grid_cumsum, axis=1))\\n mu_min = np.fmax(0, np.max(-vel_grid_cumsum, axis=1))\\n\\n select_idx = np.where(np.sum(mu_max < mu_min, axis=1) == 0)[0][:num_data]\\n vel_idx, vel_grid_cumsum = vel_idx[select_idx], vel_grid_cumsum[select_idx]\\n vel_grid = np.take(velocity, vel_idx, axis=0)\\n mu_max, mu_min = mu_max[select_idx], mu_min[select_idx]\\n mu_start = np.random.sample(size=[num_data, num_dim])\\n mu_start = np.expand_dims(np.round(mu_start * (mu_max - mu_min) + mu_min - 0.5), axis=1)\\n mu_seq = np.concatenate((mu_start, mu_start + vel_grid_cumsum), axis=1)\\n vel = vel_grid * self.interval_length\\n\\n # sns.distplot(vel, rug=True, hist=False)\\n # plt.show()\\n\\n place_seq = {'seq': mu_seq, 'vel': vel, 'vel_idx': vel_idx}\\n return place_seq\",\n \"def sample(self, num_samples, current_device):\\n z = torch.randn(num_samples, self.latent_dim).to(current_device)\\n samples = self.decode(z)\\n return samples\",\n \"def generator(features, labels, batch_size):\\n \\n # Create empty arrays to contain batch of features and labels#\\n batch_features = np.zeros((batch_size, 160, 320, 3))\\n batch_labels = np.zeros((batch_size, 1))\\n while True:\\n for i in range(batch_size):\\n # choose random index in features\\n index = random.choice(range(len(features)))\\n batch_features[i] = features[index]\\n batch_labels[i] = labels[index]\\n yield batch_features, batch_labels\",\n \"def _samples(self):\\n finite_types = \\\\\\n [QuiverMutationType(t) for t in [['A', 1], ['A', 5], ['B', 2], ['B', 5],\\n ['C', 3], ['C', 5], ['D', 2], ['D', 5],\\n [\\\"E\\\", 6], [\\\"E\\\", 7], [\\\"E\\\", 8], [\\\"F\\\", 4],\\n [\\\"G\\\", 2]]]\\n affine_types = \\\\\\n [QuiverMutationType(t) for t in [['A', [1,1], 1], ['A', [4,5], 1], ['D', 4, 1], ['BB', 5, 1]]]\\n elliptic_types = \\\\\\n [QuiverMutationType(t) for t in [['E', 6, [1,1]], ['E', 7, [1,1]]]]\\n mutation_finite_types = \\\\\\n [QuiverMutationType(t) for t in [['R2',(1,5)], ['R2',(3,5)]]]\\n mutation_infinite_types = \\\\\\n [QuiverMutationType(t) for t in [['E',10], ['BE',5], ['GR',(3,10)], ['T',(3,3,4)]]]\\n\\n return finite_types + affine_types + elliptic_types + mutation_finite_types + mutation_infinite_types\",\n \"def ptb_iterator(raw_data, batch_size, num_steps, augment=False):\\n raw_data = np.array(raw_data, dtype=np.int32)\\n\\n if augment:\\n # https://github.com/cooijmanstim/recurrent-batch-normalization/blob/master/penntreebank.py#L93\\n offset = np.random.randint(num_steps)\\n raw_data = raw_data[offset:]\\n\\n data_len = len(raw_data)\\n batch_len = data_len // batch_size\\n data = np.zeros([batch_size, batch_len], dtype=np.int32)\\n for i in range(batch_size):\\n data[i] = raw_data[batch_len * i:batch_len * (i + 1)]\\n\\n\\n epoch_size = (batch_len - 1) // num_steps\\n\\n if epoch_size == 0:\\n raise ValueError(\\\"epoch_size == 0, decrease batch_size or num_steps\\\")\\n\\n for i in range(epoch_size):\\n x = data[:, i*num_steps:(i+1)*num_steps]\\n y = data[:, i*num_steps+1:(i+1)*num_steps+1]\\n yield (x, y)\",\n \"def createGenerator(seed, channels):\\n model = tf.keras.Sequential()\\n model.add(layers.Dense(4 * 4 * 256, activation = \\\"relu\\\", input_dim = seed))\\n model.add(layers.Reshape((4, 4, 256)))\\n\\n model.add(layers.UpSampling2D())\\n model.add(layers.Conv2D(256, kernel_size = 3,padding = \\\"same\\\"))\\n model.add(layers.BatchNormalization(momentum = 0.8))\\n model.add(layers.Activation(\\\"relu\\\"))\\n\\n model.add(layers.UpSampling2D())\\n model.add(layers.Conv2D(256, kernel_size = 3, padding = \\\"same\\\"))\\n model.add(layers.BatchNormalization(momentum = 0.8))\\n model.add(layers.Activation(\\\"relu\\\"))\\n\\n model.add(layers.UpSampling2D())\\n model.add(layers.Conv2D(128, kernel_size = 3, padding = \\\"same\\\"))\\n model.add(layers.BatchNormalization(momentum = 0.8))\\n model.add(layers.Activation(\\\"relu\\\"))\\n #check desired resolution to adjust output size and add complexity\\n if GENERATE_RES > 1:\\n model.add(layers.UpSampling2D(size=(GENERATE_RES, GENERATE_RES)))\\n model.add(layers.Conv2D(128, kernel_size = 3, padding = \\\"same\\\"))\\n model.add(layers.BatchNormalization(momentum = 0.8))\\n model.add(layers.Activation(\\\"relu\\\"))\\n #if()\\n\\n #final Convolutional NN layer\\n model.add(layers.Conv2D(channels, kernel_size = 3, padding = \\\"same\\\"))\\n model.add(layers.Activation(\\\"tanh\\\"))\\n\\n return model\",\n \"def get_cd_samples(self):\\n \\n if \\\"PCD\\\" in self.algorithm:\\n \\n input_vars = []\\n \\n given_vars = []\\n \\n else:\\n \\n input_vars = [self.minibatch_set]\\n \\n given_vars = {self.x_gibbs: self.train_inputs[self.minibatch_set,:]} \\n \\n get_samples = theano.function(inputs = input_vars,\\n outputs = [self.p_xi_given_x_[-1], \\n self.gibbs_samples[-1]\\n ], \\n givens = given_vars,\\n #start the chain at the data distribution\\n updates = self.gibbs_updates)\\n \\n return get_samples\",\n \"def _build_runlist(self):\\n\\n if self.seed is not None:\\n np.random.seed(self.seed)\\n\\n for i in moves.range(self.num_samples):\\n sample = []\\n for key, meta in iteritems(self.get_desvar_metadata()):\\n nval = meta['size']\\n values = []\\n for k in range(nval):\\n\\n low = meta['lower']\\n high = meta['upper']\\n if isinstance(low, np.ndarray):\\n low = low[k]\\n if isinstance(high, np.ndarray):\\n high = high[k]\\n\\n values.append(np.random.uniform(low, high))\\n sample.append([key, np.array(values)])\\n\\n yield sample\",\n \"def enhancer_iterator(self, data, labels, batch_size, num_steps):\\n def seq_to_ints(seq):\\n return [self.vocab.word_to_index[c] for c in seq]\\n\\n # Map raw data to array of ints. if all sequences are the same length L, \\n # raw_data will be N-by-L\\n mdata = np.array([seq_to_ints(i) for i in data], dtype=np.int32)\\n num_batches = len(mdata) // batch_size\\n \\n # data will have batch_len elements, each of size batch_size\\n # ASSUME FIXED SEQUENCE LENGTHS OFF 1000 FOR NOW (5/20/16)\\n # Just grab middle self.config.num_steps nucleotides\\n a = int(len(mdata[0,:])/2-self.config.num_steps/2)\\n b = int(len(mdata[0,:])/2+self.config.num_steps/2)\\n for i in range(num_batches):\\n x = mdata[batch_size*i:batch_size*(i+1),a:b]\\n if labels is not None:\\n y = labels[batch_size*i:batch_size*(i+1)]\\n else:\\n y = None\\n yield(x,y)\",\n \"def flow(self, batch_size=32, output='both', crops=0):\\n while True:\\n for dataset in self.input_sets:\\n X = self.training_set['input/'+dataset]\\n y = self.training_set['target/'+dataset]\\n y_seg = self.training_set['seg_map/'+dataset]\\n\\n for i in range(int(math.ceil(X.shape[0]/2000))):\\n index = list(range(0,X.shape[0]))\\n sample = random.sample(index, batch_size)\\n sample.sort()\\n X_batch = X[sample, ...]\\n y_batch = y[sample, ...]\\n y_seg_batch = y_seg[sample, ...]\\n X_batch = self.augment(X_batch)\\n\\n if crops > 0:\\n (X_batch, y_batch,\\n y_seg_batch) = _augmentors.random_crops(\\n X_batch, y_batch, y_seg_batch, n_crops=crops, crop_dim=20)\\n\\n if output=='both':\\n yield (X_batch, [y_batch, y_seg_batch])\\n elif output=='seg':\\n yield (X_batch, y_seg)\\n elif output=='density':\\n yield (X_batch, y_batch)\\n else:\\n raise Exception('output must be \\\"density\\\", \\\"seg\\\" or \\\"both\\\"')\",\n \"def samples(self):\\n pass\",\n \"def fixture_samples(sample_single) -> Iterator[dict]:\\n _samples = []\\n sample_id = sample_single[\\\"sample_id\\\"]\\n for number in range(3):\\n sample = copy.deepcopy(sample_single)\\n sample[\\\"sample_id\\\"] = \\\"_\\\".join([sample_id, str(number)])\\n _samples.append(sample)\\n return _samples\",\n \"def to_dataset(sound_inputs, chunk_size=None, increment=None):\\n\\n if chunk_size is None:\\n nrows = len(sound_inputs)\\n ncols = np.prod(sound_inputs[0].shape)\\n else:\\n get_nchunks = lambda dur: np.ceil(float(dur) / int(self.chunk_size * self.stride))\\n # Compute the total number of vectorized samples in the list of sound_inputs\\n nrows = np.sum([get_nchunks(s.sound.annotations[\\\"data_shape\\\"][1]) for s in sound_inputs])\\n ncols = sound_inputs[0].shape[0] * chunk_size\\n\\n mean = np.zeros(data_shape[1])\\n std = np.ones(data_shape[1])\\n if self.zscore:\\n for s in sound_inputs:\\n data = s.data.ravel()\\n s.clear_cache()\\n mean += data\\n std += data ** 2\\n std = np.sqrt(std / len(sound_inputs) - mean ** 2 / len(sound_inputs))\\n mean = mean / len(sound_inputs)\\n\\n\\n with h5py.File(self.ds_filename, \\\"w\\\") as hf:\\n ds = hf.create_dataset(\\\"input\\\",\\n data_shape,\\n chunks=(batch_size, data_shape[1]))\\n data = list()\\n start = 0\\n for s in sound_inputs:\\n data.append(s.data.ravel())\\n s.clear_cache()\\n if len(data) == batch_size:\\n ds[start: start + batch_size] = (np.vstack(data) - mean) / std\\n start += batch_size\\n data = list()\\n if len(data):\\n ds[start: start + len(data)] = np.vstack(data)\\n\\n return self.ds_filename\",\n \"def generate_mog_dataset():\\n\\n n_per_class = 100\\n dim = 2\\n n_gaussians = 4\\n mus = [(0, 1), (-1, 0), (0, -1), (1, 0)]\\n mus = [torch.tensor(m) for m in mus]\\n var = 0.05\\n\\n inputs, labels = [], []\\n\\n for id in range(n_gaussians):\\n # Generate input data by mu + x @ sqrt(cov)\\n cov = np.sqrt(var) * torch.eye(dim)\\n mu = mus[id]\\n inputs.append(mu + torch.randn(n_per_class, dim) @ cov)\\n\\n # Labels\\n labels.append(torch.tensor(n_per_class * [1.0 if id < 2 else 0.0]))\\n\\n return torch.cat(inputs, dim=0), torch.cat(labels, dim=0)\",\n \"def generate_samples(self, config, num_samples):\\n tic = time.time()\\n\\n generator = GMM(**config)\\n weights = torch.rand(config.num_components)\\n generator.component_weights.set_(weights / weights.sum())\\n generator.gaussian.means.set_(torch.randn(config.num_components, config.num_features))\\n\\n if config.covariance == 'diag':\\n generator.gaussian.covars.set_(torch.rand(config.num_components, config.num_features))\\n\\n samples = generator.sample(num_samples)\\n\\n toc = time.time()\\n print(f\\\"Generated {num_samples:,} samples in {toc-tic:.2f} seconds.\\\")\\n\\n return samples\",\n \"def generate_data(example_size):\\n\\n\\n # A placeholder for data.\\n x = np.zeros((example_size, 2))\\n\\n # Randomly selects one of two classes for each example.\\n class_id = np.random.randint(2, size=example_size)\\n\\n # Generates data for the class 0.\\n class_0_idx = np.where(class_id == 0)\\n mean0 = [0.0, 1.0]\\n cov0 = [[0.4, 0.0], [0.0, 1.0]]\\n x[class_0_idx[0], :] = np.random.multivariate_normal(\\n mean0, cov0, class_0_idx[0].shape[0])\\n\\n # Generates data for the class 0.\\n class_1_idx = np.where(class_id == 1)\\n mean1 = [1.0, 2.0]\\n cov1 = [[1.0, 0.0], [0.0, 0.4]]\\n x[class_1_idx[0], :] = np.random.multivariate_normal(\\n mean1, cov1, class_1_idx[0].shape[0])\\n\\n return (x, class_id)\",\n \"def __iter__(self):\\n for sample in self.samples:\\n yield sample\",\n \"def chunks(X, y, batch_size=32, augmentation_times=4, thickness=0,\\n data_generator=ImageDataGenerator(dim_ordering=\\\"th\\\"), is_training=True):\\n while 1:\\n prct_pop, prct1 = 0.2, 0.2 # (1) of all the training set, how much we keep (2) % of 1's\\n idx_1 = [i for i in range(len(y)) if y[i] == 1]\\n idx_1 = random.sample(idx_1, int(prct_pop * len(idx_1)))\\n idx_0 = [i for i in range(len(y)) if y[i] == 0]\\n idx_0 = random.sample(idx_0, int(len(idx_1) / prct1))\\n selected_samples = idx_0 + idx_1\\n random.shuffle(selected_samples)\\n logging.info(\\\"Final downsampled dataset stats: TP:%d, FP:%d\\\" % (\\n sum(y[selected_samples]), len(y[selected_samples]) - sum(y[selected_samples])))\\n\\n i, good = 0, 0\\n lenX = len(selected_samples)\\n for X_batch, y_batch in data_generator.flow(X[selected_samples], y[selected_samples], batch_size=batch_size,\\n shuffle=is_training):\\n i += 1\\n if good * batch_size > lenX * augmentation_times or i > 100: # stop when we have augmented enough the batch\\n break\\n if X_batch.shape[0] != batch_size: # ensure correct batch size\\n continue\\n good += 1\\n yield X_batch, y_batch\",\n \"def step(self, chunk: th.Tensor) -> th.Tensor:\\n for conv1d in self.enc_layers:\\n chunk = conv1d(chunk)\\n return chunk\",\n \"def sample(self, num_samples, current_device, **kwargs):\\n z = torch.randn(num_samples, self.latent_dim)\\n z = z.to(current_device)\\n samples = self.decode(z)\\n\\n return samples\",\n \"def mscoco_generator(data_dir,\\n tmp_dir,\\n training,\\n how_many,\\n start_from=0,\\n eos_list=None,\\n vocab_filename=None):\\n eos_list = [1] if eos_list is None else eos_list\\n def get_vocab():\\n \\\"\\\"\\\"Get vocab for caption text encoder.\\\"\\\"\\\"\\n if data_dir is not None and vocab_filename is not None:\\n vocab_filepath = os.path.join(data_dir, vocab_filename)\\n if tf.gfile.Exists(vocab_filepath):\\n tf.logging.info(\\\"Found vocab file: %s\\\", vocab_filepath)\\n vocab_symbolizer = text_encoder.SubwordTextEncoder(vocab_filepath)\\n return vocab_symbolizer\\n else:\\n raise ValueError(\\\"Vocab file does not exist: %s\\\" % vocab_filepath)\\n return None\\n\\n vocab_symbolizer = get_vocab()\\n _get_mscoco(tmp_dir)\\n caption_filepath = (\\n _MSCOCO_TRAIN_CAPTION_FILE if training else _MSCOCO_EVAL_CAPTION_FILE)\\n caption_filepath = os.path.join(tmp_dir, caption_filepath)\\n prefix = _MSCOCO_TRAIN_PREFIX if training else _MSCOCO_EVAL_PREFIX\\n caption_file = io.open(caption_filepath)\\n caption_json = json.load(caption_file)\\n # Dictionary from image_id to ((filename, height, width), captions).\\n image_dict = {}\\n for image in caption_json[\\\"images\\\"]:\\n image_dict[image[\\\"id\\\"]] = [(image[\\\"file_name\\\"], image[\\\"height\\\"],\\n image[\\\"width\\\"]), []]\\n annotations = caption_json[\\\"annotations\\\"]\\n annotation_count = len(annotations)\\n image_count = len(image_dict)\\n tf.logging.info(\\\"Processing %d images and %d labels\\\\n\\\" % (image_count,\\n annotation_count))\\n for annotation in annotations:\\n image_id = annotation[\\\"image_id\\\"]\\n image_dict[image_id][1].append(annotation[\\\"caption\\\"])\\n\\n data = list(image_dict.values())[start_from:start_from + how_many]\\n random.shuffle(data)\\n for image_info, labels in data:\\n image_filename = image_info[0]\\n image_filepath = os.path.join(tmp_dir, prefix, image_filename)\\n with tf.gfile.Open(image_filepath, \\\"rb\\\") as f:\\n encoded_image_data = f.read()\\n height, width = image_info[1], image_info[2]\\n for label in labels:\\n if vocab_filename is None or vocab_symbolizer is None:\\n label = [ord(c) for c in label] + eos_list\\n else:\\n label = vocab_symbolizer.encode(label) + eos_list\\n yield {\\n \\\"image/encoded\\\": [encoded_image_data],\\n \\\"image/format\\\": [\\\"jpeg\\\"],\\n \\\"image/class/label\\\": label,\\n \\\"image/height\\\": [height],\\n \\\"image/width\\\": [width]\\n }\",\n \"def sample(self, detections):\\n\\n dist_mean = []\\n dist_covar = []\\n num_det = len(detections)\\n timestamp = next(iter(detections)).timestamp\\n for detection in detections:\\n ndim_state = detection.measurement_model.ndim_state\\n ndim_meas = detection.measurement_model.ndim\\n if isinstance(detection.measurement_model, LinearModel):\\n if ndim_state > ndim_meas:\\n mapping = detection.measurement_model.mapping\\n mapping_matrix = np.zeros((ndim_state, ndim_meas))\\n mapping_index = np.linspace(0, len(mapping)-1, ndim_meas, dtype=int)\\n mapping_matrix[mapping, mapping_index] \\\\\\n = 1\\n dist_mean.append(mapping_matrix @ detection.state_vector)\\n dist_covar.append(mapping_matrix @\\n detection.measurement_model.noise_covar @\\n mapping_matrix.T)\\n else:\\n dist_mean.append(detection.state_vector)\\n dist_covar.append(detection.measurement_model.noise_covar)\\n else:\\n tmp_mean = detection.measurement_model.inverse_function(detection)\\n jac = jacobian(detection.measurement_model.inverse_function, detection)\\n tmp_covar = jac @ detection.measurement_model.noise_covar @ jac.T\\n dist_mean.append(tmp_mean)\\n dist_covar.append(tmp_covar)\\n\\n weights = self.get_weight(num_det)\\n\\n samples = gm_sample(means=dist_mean,\\n covars=dist_covar,\\n weights=weights,\\n size=self.nsamples)\\n\\n particles = ParticleState(state_vector=StateVectors(samples),\\n weight=np.array([1 / self.nsamples] * self.nsamples),\\n timestamp=timestamp)\\n return particles\",\n \"def generate_samples(data, root_path, batch_size=128):\\n while True:\\n # Generate random batch of indices\\n indices = np.random.permutation(data.count()[0])\\n\\n for batch in range(0, len(indices), batch_size):\\n batch_i = indices[batch:(batch + batch_size)]\\n\\n x = np.empty([0, img_h, img_w, img_c], dtype=np.float32)\\n y = np.empty([0], dtype=np.float32)\\n\\n x, y = augment_data(x, y, data, root_path, batch_i)\\n x, y = flip_images(x, y)\\n\\n yield (x, y)\",\n \"def generate(\\n self, models, sample: Dict[str, Dict[str, Tensor]], **kwargs\\n ) -> List[List[Dict[str, Tensor]]]:\\n return self._generate(sample, **kwargs)\",\n \"def _get_chunk_data(self, inputs: Iterable, chunk_size: int):\\n inputs_iter = iter(inputs)\\n while True:\\n try:\\n chunk_data = []\\n for _ in range(chunk_size):\\n processed_data = next(inputs_iter)\\n chunk_data.append(processed_data)\\n yield chunk_data\\n except StopIteration:\\n if chunk_data:\\n yield chunk_data\\n break\",\n \"def sample_from_cone(self, cone, num_samples=1):\\n num_faces = cone.shape[1]\\n v_samples = np.empty((num_samples, 3))\\n for i in range(num_samples):\\n lambdas = np.random.gamma(self.dir_prior, self.dir_prior, num_faces)\\n lambdas = lambdas / sum(lambdas)\\n v_sample = lambdas * cone\\n v_samples[i, :] = np.sum(v_sample, 1)\\n return v_samples\",\n \"def test_categorical(self):\\n with Model() as model:\\n Categorical('x', np.array([0.25, 0.75]))\\n steps = assign_step_methods(model, [])\\n assert isinstance(steps, BinaryGibbsMetropolis)\\n with Model() as model:\\n Categorical('y', np.array([0.25, 0.70, 0.05]))\\n steps = assign_step_methods(model, [])\\n assert isinstance(steps, CategoricalGibbsMetropolis)\",\n \"def trainval_generators(indices, indices_aug, model_type, folder, batch_size, labels, kfold_bool=False):\\n #which data to load\\n if model_type == \\\"aug_padding\\\":\\n file_data = os.path.join(absPath, 'data/', folder, 'aug_data.h5')\\n indices = indices_aug\\n else:\\n file_data = os.path.join(absPath, 'data/', folder, 'data.h5')\\n h5f = h5py.File(file_data, 'r')\\n #now creating batches\\n if kfold_bool == False:\\n i_train, i_val, i_test = indices\\n train_generator = batch_generator(batch_size, file_data, model_type, i_train, labels)\\n val_generator = batch_generator(batch_size, file_data, model_type, i_val, labels)\\n generators = (train_generator, val_generator)\\n else:\\n generators = []\\n for k_fold in indices:\\n i_train, i_val, i_test = k_fold\\n train_generator = batch_generator(batch_size, file_data, model_type, i_train, labels)\\n val_generator = batch_generator(batch_size, file_data, model_type, i_val, labels)\\n generators.append((train_generator, val_generator))\\n return generators\",\n \"def generator_input(filenames, chunk_size, batch_size=64):\\n\\n feature_cols = None\\n while True:\\n input_reader = pd.read_csv(\\n tf.gfile.Open(filenames[0]),\\n names=CSV_COLUMNS,\\n chunksize=chunk_size,\\n na_values=' ?')\\n\\n for input_data in input_reader:\\n input_data = input_data.dropna()\\n # Pop off all of the columns we want to predict and concatenate them\\n labels = pd.concat([input_data.pop(x) for x in LABEL_COLUMNS], 1)\\n\\n input_data = to_numeric_features(input_data, feature_cols)\\n\\n # Retains schema for next chunk processing.\\n if feature_cols is None:\\n feature_cols = input_data.columns\\n\\n idx_len = input_data.shape[0]\\n for index in range(0, idx_len, batch_size):\\n yield (input_data.iloc[index:min(idx_len, index + batch_size)],\\n labels.iloc[index:min(idx_len, index + batch_size)])\",\n \"def generator(samples, batch_size=32):\\n num_samples = len(samples)\\n while 1: # Loop forever so the generator never terminates\\n samples = sklearn.utils.shuffle(samples)\\n for offset in range(0, num_samples, batch_size):\\n batch_samples = samples[offset:offset+batch_size]\\n\\n images = []\\n angles = []\\n for batch_sample in batch_samples:\\n #Because the file path in two folders are different, a if-else is needed.\\n if len(batch_sample[0].split('/')) == 2:\\n name = './data/IMG/'+batch_sample[0].split('/')[-1]\\n else:\\n name =batch_sample[0]\\n originalImage = cv2.imread(name)\\n image = cv2.cvtColor(originalImage, cv2.COLOR_BGR2RGB)\\n images.append(image)\\n measurement = float(line[3])\\n angles.append(measurement)\\n \\n # Flipping\\n images.append(cv2.flip(image,1))\\n angles.append(measurement*(-1.0))\\n\\n # trim image to only see section with road\\n inputs = np.array(images)\\n outputs = np.array(angles)\\n yield sklearn.utils.shuffle(inputs, outputs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7261067","0.6262869","0.5684544","0.56400836","0.55678874","0.5419031","0.5419031","0.5378836","0.53703797","0.5349273","0.5279914","0.52595407","0.5239342","0.52295643","0.5188037","0.51616156","0.515846","0.5093254","0.50914216","0.5061559","0.5050774","0.5044631","0.50437707","0.4996947","0.49931344","0.49859464","0.4971209","0.49706495","0.4952079","0.49388003","0.49366754","0.49111313","0.49057037","0.49024788","0.49023303","0.48942655","0.48872924","0.4885355","0.48806706","0.48506093","0.48481816","0.48476774","0.48415545","0.48408216","0.48316774","0.48291713","0.48277953","0.4825732","0.48236743","0.48213568","0.48175323","0.48053202","0.48045367","0.48037094","0.47973725","0.4796339","0.47953647","0.47947192","0.4794366","0.47902247","0.47879574","0.47817054","0.47798946","0.47686732","0.4766095","0.47621977","0.47613943","0.4760955","0.4760308","0.47542077","0.47528842","0.47481698","0.4746497","0.47396028","0.47375467","0.47300416","0.47291714","0.47290608","0.47277677","0.47191688","0.47152892","0.47091207","0.4701032","0.4701019","0.4699881","0.4694252","0.468425","0.46794","0.46685395","0.46667406","0.4665782","0.4665107","0.46603143","0.46561724","0.464821","0.4645008","0.46443275","0.46429425","0.4639845","0.46355665"],"string":"[\n \"0.7261067\",\n \"0.6262869\",\n \"0.5684544\",\n \"0.56400836\",\n \"0.55678874\",\n \"0.5419031\",\n \"0.5419031\",\n \"0.5378836\",\n \"0.53703797\",\n \"0.5349273\",\n \"0.5279914\",\n \"0.52595407\",\n \"0.5239342\",\n \"0.52295643\",\n \"0.5188037\",\n \"0.51616156\",\n \"0.515846\",\n \"0.5093254\",\n \"0.50914216\",\n \"0.5061559\",\n \"0.5050774\",\n \"0.5044631\",\n \"0.50437707\",\n \"0.4996947\",\n \"0.49931344\",\n \"0.49859464\",\n \"0.4971209\",\n \"0.49706495\",\n \"0.4952079\",\n \"0.49388003\",\n \"0.49366754\",\n \"0.49111313\",\n \"0.49057037\",\n \"0.49024788\",\n \"0.49023303\",\n \"0.48942655\",\n \"0.48872924\",\n \"0.4885355\",\n \"0.48806706\",\n \"0.48506093\",\n \"0.48481816\",\n \"0.48476774\",\n \"0.48415545\",\n \"0.48408216\",\n \"0.48316774\",\n \"0.48291713\",\n \"0.48277953\",\n \"0.4825732\",\n \"0.48236743\",\n \"0.48213568\",\n \"0.48175323\",\n \"0.48053202\",\n \"0.48045367\",\n \"0.48037094\",\n \"0.47973725\",\n \"0.4796339\",\n \"0.47953647\",\n \"0.47947192\",\n \"0.4794366\",\n \"0.47902247\",\n \"0.47879574\",\n \"0.47817054\",\n \"0.47798946\",\n \"0.47686732\",\n \"0.4766095\",\n \"0.47621977\",\n \"0.47613943\",\n \"0.4760955\",\n \"0.4760308\",\n \"0.47542077\",\n \"0.47528842\",\n \"0.47481698\",\n \"0.4746497\",\n \"0.47396028\",\n \"0.47375467\",\n \"0.47300416\",\n \"0.47291714\",\n \"0.47290608\",\n \"0.47277677\",\n \"0.47191688\",\n \"0.47152892\",\n \"0.47091207\",\n \"0.4701032\",\n \"0.4701019\",\n \"0.4699881\",\n \"0.4694252\",\n \"0.468425\",\n \"0.46794\",\n \"0.46685395\",\n \"0.46667406\",\n \"0.4665782\",\n \"0.4665107\",\n \"0.46603143\",\n \"0.46561724\",\n \"0.464821\",\n \"0.4645008\",\n \"0.46443275\",\n \"0.46429425\",\n \"0.4639845\",\n \"0.46355665\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7653979"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":10491,"cells":{"query":{"kind":"string","value":"helper function for optimizing the receptor library using multiprocessing"},"document":{"kind":"string","value":"def _run_job(args):\n # Note that we do not set the seed of the random number generator because\n # we already modified the interaction matrix before calling this function\n # and it does not harm us when all sub processes have the same sequence of\n # random numbers.\n \n # create the object ...\n obj = LibraryBinaryNumeric(**args[0])\n # ... get the method to evaluate ...\n method = getattr(obj, args[1])\n # ... and evaluate it\n if len(args) > 2:\n return method(**args[2])\n else:\n return method()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _optimise(self):\n pass","def computeIntercepts():\n pass","def propose_optimize():\n pass","def process():","def reduce_run():","def test_3():\n \n\n # Functions wrapped by agents\n def f(in_streams, out_streams):\n multiply_and_add(in_streams[0], out_streams[0],\n multiplicand=2, addend=1)\n\n def g(in_streams, out_streams):\n t = Stream('t')\n filter_then_square(in_streams[0], t,\n filter_threshold=20)\n print_stream(t, name='p1')\n\n def sums(in_streams, out_streams):\n s = Stream('s')\n sum_window(in_streams[0], s, window_size=3, step_size=3)\n print_stream(s, name=' p2')\n\n processes = \\\n {\n 'source_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': f,\n 'sources':\n {'acceleration':\n {'type': 'i',\n 'func': source_thread_target\n },\n }\n },\n 'process_1':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': g,\n 'sources': {}\n },\n 'process_2':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': sums,\n 'sources': {}\n }\n }\n \n connections = \\\n {\n 'source_process' :\n {\n 'out' : [('process_1', 'in'), ('process_2', 'in')],\n 'acceleration' : [('source_process', 'in')]\n },\n 'process_1':\n {\n },\n 'process_2':\n {\n }\n }\n\n multicore(processes, connections)","def test_2():\n \n # Functions wrapped by agents\n def f(in_streams, out_streams):\n multiply_and_add(in_streams[0], out_streams[0],\n multiplicand=2, addend=1)\n\n def g(in_streams, out_streams):\n filter_then_square(in_streams[0], out_streams[0],\n filter_threshold=20)\n\n def h(in_streams, out_streams):\n s = Stream('s')\n sum_window(in_streams[0], s, window_size=3, step_size=3)\n print_stream(s, name=s.name)\n \n\n # Specify processes and connections.\n processes = \\\n {\n 'source_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': f,\n 'sources':\n {'acceleration':\n {'type': 'i',\n 'func': source_thread_target\n },\n },\n 'actuators': {}\n },\n 'filter_and_square_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('filtered', 'i')],\n 'compute_func': g,\n 'sources': {},\n 'actuators': {}\n },\n 'aggregate_and_output_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': h,\n 'sources': {},\n 'actuators': {}\n }\n }\n \n connections = \\\n {\n 'source_process' :\n {\n 'out' : [('filter_and_square_process', 'in')],\n 'acceleration' : [('source_process', 'in')]\n },\n 'filter_and_square_process' :\n {\n 'filtered' : [('aggregate_and_output_process', 'in')],\n },\n 'aggregate_and_output_process':\n {}\n }\n\n multicore(processes, connections)","def test_4():\n\n # Functions wrapped by agents\n def f(in_streams, out_streams):\n identity(in_streams[0], out_streams[0])\n\n def g(in_streams, out_streams):\n multiply(in_streams[0], out_streams[0],\n multiplicand=2)\n\n def h(in_streams, out_streams):\n square(in_streams[0], out_streams[0])\n\n def m(in_streams, out_streams):\n s = Stream('s')\n sum_numbers(in_streams, s)\n print_stream(s, name='s')\n\n processes = \\\n {\n 'source_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': f,\n 'sources':\n {'acceleration':\n {'type': 'i',\n 'func': source_thread_target\n },\n }\n },\n 'multiply_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': g,\n 'sources': {}\n },\n 'square_process':\n {'in_stream_names_types': [('in', 'i')],\n 'out_stream_names_types': [('out', 'i')],\n 'compute_func': h,\n 'sources': {}\n },\n 'merge_process':\n {'in_stream_names_types': [('in_multiply', 'i'),\n ('in_square', 'i')],\n 'out_stream_names_types': [],\n 'compute_func': m,\n 'sources': {}\n }\n }\n \n connections = \\\n {\n 'source_process' :\n {\n 'out' : [('multiply_process', 'in'), ('square_process', 'in')],\n 'acceleration' : [('source_process', 'in')]\n },\n 'multiply_process':\n {\n 'out' : [('merge_process', 'in_multiply')]\n },\n 'square_process':\n {\n 'out' : [('merge_process', 'in_square')]\n },\n 'merge_process':\n {\n }\n }\n\n multicore(processes, connections)","def ParallelToserial(self):\n pass","def models_optimize_parallel(model, react_set, fract_opt=0.1, save_file_loc=None, fva=False, processes=cpu_count()):\n with ProcessPool(processes, initializer=species_init_Objective, initargs=(model,react_set,fract_opt)) as pool:\n try:\n if fva==True:\n future = pool.map(models_optimize_fva, [x.id for x in model.strains], timeout=100)\n future_iterable = future.result()\n pheno = list(future_iterable)\n else:\n future = pool.map(models_optimize_objective, [x.id for x in model.strains], timeout=20)\n future_iterable = future.result()\n pheno = list(future_iterable)\n except TimeoutError as error:\n print(\"function took longer than %d seconds\" % error.args[1])\n except Exception as error:\n print(\"function raised %s\" % error)\n\n if save_file_loc!=None:\n save_json_obj(dict(pheno), save_samples_dir+\"sample_\"+str(t)+\".json\")\n save_json_obj(variant_id_dec_dict, save_samples_dir+\"sample_\"+str(t)+\"_varDecision.json\")\n \n pool.close()\n pool.stop()\n pool.join()\n return pheno","def executor(self):","def optimize(self):\n\t\ts1,a1,r1,s2 = self.ram.agg_sample(self.batch_size)\n\n\t\ts1 = Variable(torch.from_numpy(s1))\n\t\ta1 = Variable(torch.from_numpy(a1))\n\t\tr1 = Variable(torch.from_numpy(r1))\n\t\ts2 = Variable(torch.from_numpy(s2))\n\n\t\tfor i in range(self.critic_step):\n\t\t\t# ---------------------- optimize critic ----------------------\n\t\t\t# Use target actor exploitation policy here for loss evaluation\n\t\t\t\n\t\t\t# a2 = self.target_actor.forward(s2).detach()\n\t\t\t# next_val = torch.squeeze(self.target_critic.forward(s2, a2).detach())\n\t\t\t\n\t\t\t# y_exp = r + gamma*Q'( s2, pi'(s2))\n\t\t\ty_expected = r1 #+ GAMMA*next_val\n\t\t\t# y_pred = Q( s1, a1)\n\t\t\ty_predicted = torch.squeeze(self.critic.forward(s1, a1))\n\t\t\t# compute critic loss, and update the critic\n\t\t\t#print(y_predicted,y_expected,\"hi\")\n\t\t\tloss_critic = F.smooth_l1_loss(y_predicted, y_expected.squeeze())\n\t\t\tself.critic_optimizer.zero_grad()\n\t\t\tloss_critic.backward()\n\t\t\tself.critic_optimizer.step()\n\n\t\t# ---------------------- optimize actor ----------------------\n\t\tpred_a1 = self.actor.forward(s1)\n\t\tloss_actor = -1*torch.sum(self.critic.forward(s1, pred_a1))\n\t\tself.actor_optimizer.zero_grad()\n\t\tloss_actor.backward()\n\t\tself.actor_optimizer.step()\n\n\t\tutils.soft_update(self.target_actor, self.actor, TAU)\n\t\tutils.soft_update(self.target_critic, self.critic, TAU)\n\n\t\t# if self.iter % 100 == 0:\n\t\tif self.batch_size > 1:\n\t\t\ty_1 = y_predicted.data.numpy()[0]\n\t\t\tr_1 = r1.data.numpy()[0]\n\t\telse:\n\t\t\ty_1 = y_predicted.data.numpy()\n\t\t\tr_1 = r1.data.numpy()\n\t\tprint ('Iteration :- ', self.iter, ' Loss_actor :- ', loss_actor.data.numpy(),\\\n\t\t\t' Loss_critic :- ', loss_critic.data.numpy(), ' Critic Pred Reward :- ', y_1, ' Actual Reward :- ', r_1)\n\t\tself.iter += 1","def accept_optimize():\n pass","def run_RL_sync(mapname,n_trials = int, seed = int,alpha = 0.15, beta = 0.2, tau = 5, gamma = 0.9, max_steps = 1000, reward_size = 100):\n\n # Softmax can't be from external file, because multiprocessing messes up the seed values\n np.random.seed(seed)\n def softmax_action(action_weights = [], tau = int):\n action_indices = list(range(len(action_weights)))\n f = np.exp((action_weights - np.max(action_weights))/tau) # shift values\n action_prob = f / f.sum(axis=0)\n action_index = np.random.choice(action_indices, 1, p=action_prob)\n return action_index[0]\n\n srate = 500 #sample rate\n \n total_time = int(1.5*srate) #total timesteps or \"time the agent gets to think about moving\"\n\n time0 = time.perf_counter()\n\n print(\"Running the RL model but with sync !\")\n srate = 500 #sample rate\n \n total_time = int(1.5*srate) #total timesteps or \"time the agent gets to think about moving\"\n\n # Learning Parameters\n parameters = {\"alpha\": alpha\n ,\"beta\": beta\n ,\"gamma\": gamma\n ,\"tau\": tau}\n n_steps = max_steps\n n_trials = n_trials\n \n sub_reward_size = 0 # no subgoals!\n # # # # # # # # # # # # # #\n # # Setting up the map # #\n # # # # # # # # # # # # # #\n \"\"\" The agent begins in a walled grid and has to find \n the goal to obtain a reward.\"\"\"\n # Grid #\n states = create_grid_from_file(map_file=mapname,goal_location = [10,3],reward_size=reward_size,sub_reward_size=sub_reward_size)\n state_set = list(range(int(states.shape[0]*states.shape[1]))) #index of states\n\n #set of actions\n move_name=[\"UP\", \"R-UP\", \"RIGHT\",\"R-DOWN\",\"DOWN\",\"L-DOWN\", \"LEFT\" ,\"LEFT-UP\"] \n moves = [[-1, 0],[-1, 1], [0, 1], [1, 1], [1, 0],[1, -1], [0, -1], [-1, -1]]\n action_set = list(range(len(moves))) #index list\n\n # # # # # # # # # # # # # # # # # # # # # # # #\n # # Setting up the synchronization modules # #\n # # # # # # # # # # # # # # # # # # # # # # # #\n\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n Processing module\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n\n # Initial variables #\n\n r2_max = 1 #maximum amplitude of nodes\n drift = .8 #rate of drift between coupling parameters\n\n cg_1 = (30/srate)*np.pi #gamma band coupling parameter for input information\n cg_2 = cg_1 + (drift/srate)*2*np.pi #gamma band coupling parameter for actions\n \n damp = 0.3 #damping parameter\n decay = 0.9 #decay parameter\n noise = 0.5 #noise parameter\n\n # Initial matrices #\n\n n_states = len(state_set)\n n_actions= len(action_set)\n\n #Setting up phase code neurons across entire task\n S_Phase = np.zeros((2,states.shape[0],states.shape[1],total_time)) #State phase code units\n A_Phase = np.zeros((2,n_actions,total_time)) #Action phase code units\n\n #Setting up rate code neurons across entire task\n S_Rate = np.zeros((states.shape[0],states.shape[1],total_time)) #State rate code units\n A_Rate = np.zeros((n_actions,total_time)) #Action rate code units\n #State-Action Weight Matrix\n W = np.zeros((states.shape[0],states.shape[1],n_actions))#*0.001 #initial state-action weights\n V = np.zeros((states.shape[0],states.shape[1]))#*0.001 #initial state weights\n\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n Control module\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n\n # MFC #\n # Initial variables \n r2_MFC = 0.7 #maximum amplitude MFC node\n damp_MFC = 0.03 # damping parameter MFC\n acc_slope = 10 # MFC slope parameter ---> steepness of burst probability distribution\n ct = (5/srate)*2*np.pi #theta band coupling parameter for MFC\n\n #Setting up phase code nodes for the MFC\n MFC = np.zeros((2,total_time))\n #Setting up phase code neuron for MFC -> Bernoulli rate code\n Be = 0 \n \"\"\"When the be value as the rate code of MFC\n reaches certain threshold the MFC will send a burst to coupled neurons\"\"\"\n\n # LFC #\n #Module indicating which states should be initiate action-state synchronization\n LFC = np.zeros((states.shape[0],states.shape[1],n_steps))\n\n #Module that gives the right indices to synchronize\n LFC_sync = 0\n\n\n\n # # # # # # # # # # # # # #\n # # Simulation # #\n # # # # # # # # # # # # # #\n\n # Logging dependent variables\n Hit = np.zeros((total_time,n_steps,n_trials)) #log when there is a burst from the MFC\n # Goal_reach = np.zeros((n_steps,n_trials)) #record if goal is reached \n # Move = np.zeros((n_steps,n_trials)) #record move\n # Bernoulli = np.zeros((total_time,n_steps,n_trials)) #Logging the bernoulli process variables (should be in between -.8 and .8)\n # pred_err = np.zeros((states.shape[0],states.shape[1],n_steps,n_trials)) #logging the prediction error\n trial_length = np.zeros((n_trials))\n\n # Recording sync\n sync = np.zeros((n_states,n_actions,n_steps,n_trials)) \n\n \"\"\" L O O P \"\"\"\n\n exploration = 0\n exploration_intent =0\n sync_fail=0\n greedy=0\n for trial in range(n_trials):\n \"\"\"A trial is considered as each journey the actor makes until the goal\n or until it runs out of steps\"\"\"\n at_goal = False\n start_loc = [1,int(states.shape[1]-2)] #start in the top left\n step = 0 \n S_Phase[:,:,:,0] = (2*np.random.random_sample((2,states.shape[0],states.shape[1])))-1 # random starting points processing module\n A_Phase[:,:,0] = (2*np.random.random_sample((2,n_actions)))-1 # idem\n while not at_goal:\n #starting location at first trial\n if step == 0:\n current_loc = start_loc\n else:\n S_Phase[:,:,:,0] = S_Phase[:,:,:,total_time-1] # random starting points processing module\n A_Phase[:,:,0] = A_Phase[:,:,total_time-1] # idem\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n Synchronization\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n\n \n #phase reset\n MFC[:,0]=np.ones((2))*r2_MFC \n\n\n # LFC setting instruction per step: each state is an input\n LFC[current_loc[0],current_loc[1],step] = 1\n\n # What we want is the lfc to indicate the state and then have the LFC sync pro actively select an action based on state action value maps\n \n action_to_sync = softmax_action(action_weights=W[current_loc[0],current_loc[1],:],tau=10)\n if action_to_sync in np.where(W[current_loc[0],current_loc[1],:]== max(W[current_loc[0],current_loc[1],:]))[0]:\n greedy+=0\n else:\n exploration_intent+=1\n \n \n #Which action does LFC sync to current state\n LFC_sync = int(action_to_sync)\n LFC_desync = list(range(len(moves)))\n LFC_desync.pop(LFC_sync) \n\n # The actor makes the move #\n for t in range(total_time-1):\n\n \n #Update phase code neurons for actions and states in processing module\n #State phase code neurons \n S_Phase[:,:,:,t+1] = update_phase(nodes=S_Phase[:,:,:,t], grid = True, radius=r2_max, damp = damp, coupling = cg_1,multiple=True )\n \n #Action phase code neurons\n A_Phase[:,:,t+1] = update_phase(nodes=A_Phase[:,:,t], grid = False, radius=r2_max, damp = damp, coupling = cg_2,multiple=True )\n\n #Update phase code untis of MFC\n MFC[:,t+1] = update_phase(nodes=MFC[:,t], grid = False, radius=r2_MFC, damp=damp_MFC, coupling=ct,multiple=False)\n\n #MFC rate code neuron-> Bernoulli process\n\n Be = 1/(1 + np.exp(-acc_slope*(MFC[0,t]-1))) # Bernoulli process \n #Bernoulli[time,step,trial] = Be # logging Be value\n\n p = random.random()\n\n if p < Be:\n\n Gaussian = np.random.normal(size = [1,2]) #noise factor as normal distribution\n #Hit[tijd,step,trial] = 1\n \n \n x, y = current_loc[1], current_loc[0]\n\n #the LFC decides which state is paired with which actions\n\n if LFC[y,x,step]:\n #The state the actor is in receives a burst because it is the only input\n S_Phase[:,y,x,t+1] = decay*S_Phase[:,y,x,t] + Gaussian\n\n # and all the actions that are to be synchronized to that state receive a burst\n if type(LFC_sync) is int:\n A_Phase[:,LFC_sync,t+1] = decay*A_Phase[:,LFC_sync,t] + Gaussian\n \n # Desynchronize all other actions !\n for node in LFC_desync:\n A_Phase[:,int(node),t+1] = decay*A_Phase[:,int(node),t] - Gaussian*noise\n\n #Updating rate code units\n #Only the rate code neuron of a single state is updated because the actor can only be in one place at the same time\n S_Rate[current_loc[0],current_loc[1],t]= (1/(1+np.exp(-5*S_Phase[0,current_loc[0],current_loc[1],t]-0.6)))\n A_Rate[:,t]=(S_Rate[current_loc[0],current_loc[1],t]*(W[current_loc[0],current_loc[1],:]+1))*(1/(1+np.exp(-5*A_Phase[0,:,t]-0.6)))\n #A_Rate[:,t]=(S_Rate[current_loc[0],current_loc[1],t])*(1/(1+np.exp(-5*A_Phase[0,:,t]-0.6)))\n \n # select action\n action_index = int(np.argmax(np.sum(A_Rate[:,:],axis=1)))\n if action_index in np.where(W[current_loc[0],current_loc[1],:] == max(W[current_loc[0],current_loc[1],:]))[0]:\n greedy+=1\n else:\n exploration+=1\n\n if action_index != LFC_sync:\n sync_fail+=1\n \n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n Learning\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n\n #update location\n new_loc= update_location(grid = states, loc=current_loc,move = moves[action_index])\n\n #log coordinates for weight matrices\n coordinates = [current_loc[0], current_loc[1], new_loc[0], new_loc[1], action_index] #location coordinates\n\n #update weights according to TD-learning\n V, W, delta, at_goal = update_weights(param=parameters, index=coordinates, V=V, W=W, states=states, reward_size = reward_size)\n\n\n #update_location\n current_loc = new_loc\n step+=1\n if step ==n_steps:\n #print(\"Agent did not reach goal\")\n break\n \n trial_length[trial] = step \n \n print(\"I took {0} exploratory steps and {1} greedy steps this simulation\".format(exploration,greedy))\n print(\"I intended to explore {} times\".format(exploration_intent))\n print(\"Sync of correct action failed {} times\".format(sync_fail))\n print(\"In this sim I took a total {} steps\".format(np.sum(trial_length)))\n \n time1 = time.perf_counter()\n print(\"For the second model I took {} minutes\".format((time1-time0)/60))\n return trial_length, V","def precompute(self, features, mode, params):\n return None","def test_inter_process_cache():\r\n\r\n x, y = theano.tensor.dvectors('xy')\r\n f = theano.function([x, y], [MyOp()(x), MyOp()(y)])\r\n f(numpy.arange(60), numpy.arange(60))\r\n if theano.config.mode == 'FAST_COMPILE' or theano.config.cxx == \"\":\r\n assert MyOp.nb_called == 0\r\n else:\r\n assert MyOp.nb_called == 1\r\n\r\n # What if we compile a new function with new variables?\r\n x, y = theano.tensor.dvectors('xy')\r\n f = theano.function([x, y], [MyOp()(x), MyOp()(y)])\r\n f(numpy.arange(60), numpy.arange(60))\r\n if theano.config.mode == 'FAST_COMPILE' or theano.config.cxx == \"\":\r\n assert MyOp.nb_called == 0\r\n else:\r\n assert MyOp.nb_called == 1","def preprocess_main():","def RUN(numTrials, rateMap, numPhotons=48, angularSize=10.0, outputSize=300, mcList='MCOut.pickle',HESS=False, Sig = -1 ,numProcs = 10):\r\n print 'Beginning MC Series\\nProgress'\r\n \r\n import FermiPSF, ParseFermi\r\n mcOut = []\r\n map = pickle.load(open(rateMap, \"r\" )) # load rate-map\r\n PSFTableFront = FermiPSF.PSF_130(convType='front') # load PSF front converting\r\n PSFTableBack = FermiPSF.PSF_130(convType='back') # load PSF back converting\r\n\r\n start = time.time();\r\n \r\n ppa = outputSize/angularSize # pixel per degree\r\n\r\n # Import background template\r\n bgmap = 'BGRateMap.pickle'\r\n if (HESS == True):\r\n bgmap = 'BGRateMap_HESS_2_deg.pickle'\r\n \r\n bgTemplate = pickle.load(open(bgmap , \"r\" ))\r\n \r\n mcOut = np.zeros(numTrials)\r\n p = pool.Pool(numProcs)\r\n \r\n partial_MC_THREAD = partial( MC_THREAD, map = map,bgTemplate=bgTemplate,PSFTableFront=PSFTableFront, PSFTableBack=PSFTableBack, HESS=HESS, angularSize=angularSize, numPhotons=numPhotons, outputSize=outputSize,Sig = Sig)\r\n mcOut = p.map(partial_MC_THREAD, mcOut)\r\n \r\n# for i in range(numTrials): \r\n# # Build the background \r\n## background = Build_Background_Sideband(bgMean, lowSideband, highSideband, PSFTable)\r\n# background = Build_Background_Template(bg, bgTemplate, PSFTableFront, PSFTableBack,flatLevel = 0.0,HESS= HESS,angularSize = angularSize)\r\n# # Compute number of source photons\r\n# numMC = numPhotons - len(background[0])\r\n# # Run MC for source photons \r\n# data = MC(map,numMC,angularSize,outputSize,PSFTableFront, PSFTableBack,HESS=HESS)\r\n# # Append data\r\n# mcOut.append((data[0]+background[0], data[1]+background[1]))\r\n# \r\n# # Compute Speed Statistics\r\n# sys.stdout.write('\\r' + str(i+1)+'/'+str(numTrials)) \r\n# sys.stdout.flush()\r\n elapsed = time.time()-start;\r\n if (elapsed != 0.0):\r\n print '\\nSimulations Completed in', elapsed, 's', '(',numTrials/elapsed, ' sims per second)'\r\n \r\n outFile = open(mcList, \"wb\" )\r\n pickle.dump(mcOut, outFile)\r\n print 'Results saved to ', mcList\r\n return mcOut","def main():\n pool = Pool(processes=50)\n results = pool.imap_unordered(experiment, range(50), chunksize=1)\n\n # Output\n offset = 1\n # for i, (data_surv, data_order, data_ctrl) in enumerate(results):\n for i, (data_surv, data_ctrl) in enumerate(results):\n with open(f'../data/reproductive_barrier/hybrid_survival_percentage/experiment_{i+offset}.csv', 'w') as fp:\n for t, surv in data_surv:\n fp.write(f'{int(t)},{float(surv)}\\n')\n\n with open(f'../data/reproductive_barrier/order_of_incompatibility/experiment_{i+offset}.csv', 'w') as fp:\n for x in data_order:\n fp.write('%d,' % int(x[0]) + ','.join(map(str, x[1:])) + '\\n')\n\n with open(f'../data/reproductive_barrier/control_survival_percentage/experiment_{i+offset}.csv', 'w') as fp:\n for t, surv in data_ctrl:\n fp.write(f'{int(t)},{float(surv)}\\n')\n\n return","def start_processing(self):","def __init__(self, limit, noise, random_seed, n_state=33, n_action=4):\n # Actor Model: Local, Target, & Optimizer\n self.Actor, self.ActorTarget, self.actorOpt = [], [], []\n for i in range(limit):\n self.Actor.append(Actor(n_state, n_action, random_seed).to(device)) \n self.actorOpt.append(optim.Adam(self.Actor[i].parameters(), lr=LR_ACTOR))\n self.ActorTarget = Actor(n_state, n_action, random_seed).to(device) \n # Critic Model: Local, Target, & Optimizer\n self.Critic = Critic(n_state, n_action, random_seed).to(device)\n self.CriticTarget = Critic(n_state, n_action, random_seed).to(device)\n self.criticOpt = optim.Adam(self.Critic.parameters(), lr=LR_CRITIC)\n # Replay Buffer\n self.Memory = ReplayBuffer2(n_action, BUFFER_SIZE, BATCH_SIZE, device, random_seed)\n self.step = 0\n # OUNoise Process\n self.noise = noise\n # Display\n print('\\nBUFFER_SIZE', BUFFER_SIZE,\n '\\nBATCH_SIZE', BATCH_SIZE,\n '\\nGAMMA', GAMMA,\n '\\nTAU', TAU,\n '\\nLR_ACTOR', LR_ACTOR,\n '\\nLR_CRITIC', LR_CRITIC)\n # Display Actor & Critic\n print('\\nACTOR[i]:\\n', self.Actor[0])\n print('CRITIC:\\n', self.Critic)","def main():\n # Handle CLI.\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--molecule\", type=str, default=\"H2\", help=\"the \"\n \"UCCSD molecule to perform HPO on\")\n parser.add_argument(\"--slice-index\", type=int, default=-1, help=\"the \"\n \"slice to perform HPO on, do not specify to run HPO \"\n \"on the full circuit\")\n parser.add_argument(\"--core-count\", type=int, default=1, help=\"the \"\n \"number of cpu cores this run may use\")\n args = vars(parser.parse_args())\n molecule = args[\"molecule\"]\n slice_index = args[\"slice_index\"]\n core_count = args[\"core_count\"]\n\n # Generate the state object that encapsulates the optimization for the circuit.\n state = ProcessState(molecule, slice_index)\n\n # Redirect everything the central process puts out to a log file.\n # By default, ray redirects the stdout of each worker process\n # to the central process.\n log_file = state.file_name + \".log\"\n log_file_path = os.path.join(state.data_path, log_file)\n with open(log_file_path, \"a+\") as log:\n sys.stdout = sys.stderr = log\n\n # Display run characteristics.\n print(\"PID={}\\nWALL_TIME={}\\nSLICE_INDEX={}\\nPULSE_TIME={}\\n\"\n \"(LR_LB, LR_UB)=({}, {})\\n(DECAY_LB, DECAY_UB)=({}, {})\\n\"\n \"CORE_COUNT={}\\n{}\"\n \"\".format(os.getpid(), time.time(), state.slice_index,\n state.pulse_time, LR_LB, LR_UB, DECAY_LB, DECAY_UB, \n core_count, state.circuit))\n\n # Define the search space on the parameters: learning rate and\n # learning rate decay.\n space = {\n \"lr\": hp.loguniform(\"lr\", np.log(LR_LB), np.log(LR_UB)),\n \"decay\": hp.uniform(\"decay\", DECAY_LB, DECAY_UB),\n }\n \n # We want to minimize QOC error/loss, i.e. we want to maximize\n # negative loss.\n algo = ray.tune.suggest.HyperOptSearch(space, max_concurrent=core_count,\n reward_attr=\"neg_loss\")\n run_config = {\n \"num_samples\": HPO_MAX_ITERATIONS,\n \"name\": state.file_name,\n \"loggers\": [ray.tune.logger.NoopLogger],\n \"search_alg\": algo,\n \"verbose\": 1,\n \"local_dir\": state.data_path,\n \"resume\": True,\n }\n \n # Ray cannot serialize python objects in its object store,\n # so we have to pass the state in a lambda wrapper.\n objective_wrapper = lambda config, reporter: objective(state, config,\n reporter)\n \n # Start ray and run HPO.\n ray.init(num_cpus=core_count, object_store_memory=OBJECT_STORE_MEMORY,\n redis_max_memory=REDIS_MAX_MEMORY)\n ray.tune.register_trainable(\"lambda_id\", objective_wrapper)\n ray.tune.run(\"lambda_id\", **run_config)","def PARALLEL_worker_mc_inv(procnum, num_samples_per_processor, inversion_type, M_amplitude, green_func_array, real_data_array, comparison_metric, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, return_dict_MTs, return_dict_similarity_values_all_samples, return_dict_shift_idxs, return_dict_MT_single_force_rel_amps, return_dict_medium_1_medium_2_rel_amp_ratios, invert_for_ratio_of_multiple_media_greens_func_switch, green_func_phase_labels, num_phase_types_for_media_ratios, invert_for_relative_magnitudes_switch=False, rel_exp_mag_range=[1.,1.], auto_shift_for_best_fit=True):\n print(\"Processing for process:\", procnum, \"for \", num_samples_per_processor, \"samples.\")\n \n # Define temp data stores for current process:\n tmp_MTs = np.zeros((len(green_func_array[0,:,0]), num_samples_per_processor), dtype=float)\n tmp_similarity_values_all_samples = np.zeros(num_samples_per_processor, dtype=float)\n tmp_shift_idxs_all_samples = []\n if inversion_type == \"DC_single_force_couple\" or inversion_type == \"DC_single_force_no_coupling\" or inversion_type == \"DC_crack_couple\" or inversion_type == \"single_force_crack_no_coupling\":\n tmp_MT_single_force_rel_amps = np.zeros(num_samples_per_processor, dtype=float)\n else:\n tmp_MT_single_force_rel_amps = []\n if invert_for_ratio_of_multiple_media_greens_func_switch:\n tmp_medium_1_medium_2_rel_amp_ratios = np.zeros(num_samples_per_processor, dtype=float)\n else:\n tmp_medium_1_medium_2_rel_amp_ratios = []\n if invert_for_ratio_of_multiple_media_greens_func_switch:\n if num_phase_types_for_media_ratios>0:\n tmp_frac_medium_2_diff_phases_dict = {} # Dictionary for temp storing of phase fractions of medium 1\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases = np.zeros((num_samples_per_processor, 3), dtype=float)\n else:\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases = []\n \n # Sort greens function storage if processing for multiple media:\n if invert_for_ratio_of_multiple_media_greens_func_switch:\n green_func_array_total_both_media = green_func_array.copy()\n \n # 3. Loop over samples, checking how well a given MT sample synthetic wavefrom from the forward model compares to the real data:\n for i in range(num_samples_per_processor):\n # Generate random medium amplitude ratio and associated greens functions (if required):\n if invert_for_ratio_of_multiple_media_greens_func_switch:\n # If want to invert for ratio of meduim 1 to medium 2 separately for different phases:\n if num_phase_types_for_media_ratios>0:\n # Generate different phase fractions:\n tmp_frac_medium_2_diff_phases_dict[\"P\"] = np.random.uniform(0.0, 1.0)\n tmp_frac_medium_2_diff_phases_dict[\"S\"] = np.random.uniform(0.0, 1.0)\n tmp_frac_medium_2_diff_phases_dict[\"surface\"] = np.random.uniform(0.0, 1.0)\n # Generate associated greens functions:\n green_func_array = np.zeros(np.shape(green_func_array_total_both_media[:,:,:,0]), dtype=float)\n # Loop over greens function for each station-phase:\n for j in range(len(green_func_phase_labels)):\n tmp_frac_medium_2 = tmp_frac_medium_2_diff_phases_dict[green_func_phase_labels[j]] # Get fraction for specific phase, for specific greens functions for specific station-phase\n green_func_array[j, :, :] = (1. - tmp_frac_medium_2)*green_func_array_total_both_media[j,:,:,0] + tmp_frac_medium_2*green_func_array_total_both_media[j,:,:,1] \n # Otherwise generate single fraction value and associated greens functions:\n else:\n frac_medium_2 = np.random.uniform(0.0, 1.0)\n green_func_array = (1. - frac_medium_2)*green_func_array[:,:,:,0] + frac_medium_2*green_func_array[:,:,:,1]\n \n # 4. Generate synthetic waveform for current sample:\n # Vary moment amplitude randomly if specified:\n if invert_for_relative_magnitudes_switch:\n M_amplitude_exp_factor = np.random.uniform(low=rel_exp_mag_range[0], high=rel_exp_mag_range[1])\n M_amplitude = 10.**M_amplitude_exp_factor\n # And generate waveform from source mechanism tensor:\n if inversion_type==\"full_mt\":\n MT_curr_sample = generate_random_MT()*M_amplitude # Generate a random MT sample\n elif inversion_type==\"full_mt_Lune_samp\":\n MT_curr_sample = generate_random_MT_Lune_samp()*M_amplitude # Generate a random MT sample, sampled uniformly in Lune space\n elif inversion_type==\"DC\":\n MT_curr_sample = generate_random_DC_MT()*M_amplitude # Generate a random DC sample\n elif inversion_type==\"single_force\":\n MT_curr_sample = generate_random_single_force_vector()*M_amplitude # Generate a random single force sample\n elif inversion_type == \"DC_single_force_couple\":\n MT_curr_sample, random_DC_to_single_force_amp_frac = generate_random_DC_single_force_coupled_tensor() # Generate a random DC-single-force coupled sample, with associated relative amplitude of DC to single force\n MT_curr_sample = MT_curr_sample*M_amplitude\n elif inversion_type == \"DC_single_force_no_coupling\":\n MT_curr_sample, random_DC_to_single_force_amp_frac = generate_random_DC_single_force_uncoupled_tensor()\n MT_curr_sample = MT_curr_sample*M_amplitude\n elif inversion_type == \"DC_crack_couple\":\n MT_curr_sample, random_DC_to_single_force_amp_frac = generate_random_DC_crack_coupled_tensor()\n MT_curr_sample = MT_curr_sample*M_amplitude\n elif inversion_type == \"single_force_crack_no_coupling\":\n MT_curr_sample, random_DC_to_single_force_amp_frac = generate_random_single_force_crack_uncoupled_tensor()\n MT_curr_sample = MT_curr_sample*M_amplitude\n synth_waveform_curr_sample = forward_model(green_func_array, MT_curr_sample) # Note: Greens functions must be of similar amplitude units going into here...\n \n # 5. Compare real data to synthetic waveform (using variance reduction or other comparison metric), to assign probability that data matches current model:\n similarity_curr_sample, shift_idxs = compare_synth_to_real_waveforms(real_data_array, synth_waveform_curr_sample, comparison_metric, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, auto_shift_for_best_fit) \n \n # 6. Append results to data store:\n tmp_MTs[:,i] = MT_curr_sample[:,0]\n tmp_similarity_values_all_samples[i] = similarity_curr_sample\n tmp_shift_idxs_all_samples.append(list(shift_idxs))\n if inversion_type == \"DC_single_force_couple\" or inversion_type == \"DC_single_force_no_coupling\" or inversion_type == \"DC_crack_couple\" or inversion_type == \"single_force_crack_no_coupling\":\n tmp_MT_single_force_rel_amps[i] = random_DC_to_single_force_amp_frac\n if invert_for_ratio_of_multiple_media_greens_func_switch:\n if num_phase_types_for_media_ratios>0:\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases[i,0] = tmp_frac_medium_2_diff_phases_dict[\"P\"]\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases[i,1] = tmp_frac_medium_2_diff_phases_dict[\"S\"]\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases[i,2] = tmp_frac_medium_2_diff_phases_dict[\"surface\"]\n else:\n tmp_medium_1_medium_2_rel_amp_ratios[i] = frac_medium_2\n \n if i % 10000 == 0:\n print(\"Processor number:\", procnum, \"- Processed for\",i,\"samples out of\",num_samples_per_processor,\"samples\")\n \n # 7. And convert misfit measure to likelihood function probability:\n tmp_similarity_values_all_samples = np.exp(-(1.-tmp_similarity_values_all_samples)/2.)\n \n # And return values back to script:\n return_dict_MTs[procnum] = tmp_MTs\n return_dict_similarity_values_all_samples[procnum] = tmp_similarity_values_all_samples\n return_dict_shift_idxs[procnum] = tmp_shift_idxs_all_samples\n return_dict_MT_single_force_rel_amps[procnum] = tmp_MT_single_force_rel_amps\n if num_phase_types_for_media_ratios>0:\n return_dict_medium_1_medium_2_rel_amp_ratios[procnum] = tmp_medium_1_medium_2_rel_amp_ratios_multi_phases\n else:\n return_dict_medium_1_medium_2_rel_amp_ratios[procnum] = tmp_medium_1_medium_2_rel_amp_ratios\n print(\"Finished processing process:\", procnum, \"for \", num_samples_per_processor, \"samples.\")","def run_preprocessing(run):\n def _process(run):\n \"\"\" Process a run/flowcell and transfer to analysis server\n :param taca.illumina.Run run: Run to be processed and transferred\n \"\"\"\n logger.info('Checking run {}'.format(run.id))\n t_file = os.path.join(CONFIG['analysis']['status_dir'], 'transfer.tsv')\n if run.is_transferred(t_file):\n # In this case I am either processing a run that is in transfer\n # or that has been already transferred. Do nothing.\n # time to time this situation is due to runs that are copied back from NAS after a reboot.\n # This check avoid failures\n logger.info('Run {} already transferred to analysis server, skipping it'.format(run.id))\n return\n\n if run.get_run_status() == 'SEQUENCING':\n # Check status files and say i.e Run in second read, maybe something\n # even more specific like cycle or something\n logger.info('Run {} is not finished yet'.format(run.id))\n elif run.get_run_status() == 'TO_START':\n if run.get_run_type() == 'NON-NGI-RUN':\n # For now MiSeq specific case. Process only NGI-run, skip all the others (PhD student runs)\n logger.warn(\"Run {} marked as {}, \"\n \"TACA will skip this and move the run to \"\n \"no-sync directory\".format(run.id, run.get_run_type()))\n # Archive the run if indicated in the config file\n if 'storage' in CONFIG:\n run.archive_run(CONFIG['storage']['archive_dirs'])\n return\n # Otherwise it is fine, process it\n logger.info((\"Starting BCL to FASTQ conversion and demultiplexing for run {}\".format(run.id)))\n try:\n run.demultiplex_run()\n except:\n logger.info((\"Error demultiplexing for run {}\".format(run.id)))\n pass\n elif run.get_run_status() == 'IN_PROGRESS':\n logger.info((\"BCL conversion and demultiplexing process in \"\n \"progress for run {}, skipping it\".format(run.id)))\n elif run.get_run_status() == 'COMPLETED':\n logger.info((\"Preprocessing of run {} is finished, transferring it\".format(run.id)))\n\n # Transfer to analysis server if flag is True\n if run.transfer_to_analysis_server:\n logger.info('Transferring run {} to {} into {}'\n .format(run.id,\n run.CONFIG['analysis_server']['host'],\n run.CONFIG['analysis_server']['sync']['data_archive']))\n run.transfer_run(t_file)\n\n # Archive the run if indicated in the config file\n if 'storage' in CONFIG:\n run.archive_run(CONFIG['storage']['archive_dirs'])\n\n if run:\n # Needs to guess what run type I have (NextSeq)\n runObj = get_runObj(run)\n if not runObj:\n logger.warning(\"Unrecognized instrument type or incorrect run folder {}\".format(run))\n raise RuntimeError(\"Unrecognized instrument type or incorrect run folder {}\".format(run))\n else:\n _process(runObj)\n else:\n data_dirs = CONFIG.get('analysis').get('data_dirs')\n for data_dir in data_dirs:\n # Run folder looks like DATE_*_*_*, the last section is the FC name. \n # See Courtesy information from illumina of 10 June 2016 (no more XX at the end of the FC)\n runs = glob.glob(os.path.join(data_dir, '[1-9]*_*_*_*'))\n for _run in runs:\n runObj = get_runObj(_run)\n if not runObj:\n logger.warning(\"Unrecognized instrument type or incorrect run folder {}\".format(_run))\n else:\n try:\n _process(runObj)\n except:\n # this function might throw and exception,\n # it is better to continue processing other runs\n logger.warning(\"There was an error processing the run {}\".format(_run))\n pass","def process(self):","def process(self):","def process(self):","def process_thread(self):","def custom_processing(self, funct: callable, data_tmp: np.ndarray, **kwargs) -> np.ndarray:\n tic = time.time()\n data_tmp = funct(data_tmp, **kwargs)\n self.process_time.append(time.time() - tic)\n return data_tmp","def receptor_score(self, method='auto', multiprocessing=False):\n init_arguments = self.init_arguments\n init_arguments['parameters']['initialize_state']['sensitivity'] = 'exact'\n init_arguments['parameters']['sensitivity_matrix'] = self.sens_mat\n joblist = [(copy.deepcopy(self.init_arguments), 'mutual_information',\n {'method': method})]\n \n # add one job for each receptor\n for n in range(self.Nr):\n init_arguments = self.init_arguments\n init_arguments['num_receptors'] -= 1\n \n # modify the current state and add it to the job list\n sens_mat = np.delete(self.sens_mat, n, axis=0)\n init_arguments['parameters']['sensitivity_matrix'] = sens_mat\n joblist.append((copy.deepcopy(init_arguments), 'mutual_information',\n {'method': method}))\n \n if multiprocessing:\n # calculate all results in parallel\n pool = mp.Pool(processes=self.get_number_of_cores())\n results = pool.map(_run_job, joblist)\n \n else:\n # create a generator over which we iterate later\n results = [_run_job(job) for job in joblist]\n \n # find the scores of all receptors\n scores = results[0] - np.array(results[1:])\n return scores","def _optimize(self) -> None:\n\n for i, agent in enumerate(self.agents):\n states, actions, rewards, next_states, dones = self.memory.sample()\n\n actor_next_state = self._agent_states(i, next_states)\n next_actions = torch.cat(\n [a.actor_target(actor_next_state) for a in self.agents], 1\n )\n next_q = agent.critic_target(next_states, next_actions).detach()\n target_q = rewards[:, i].view(-1, 1) + self.gamma * next_q * (\n 1 - dones[:, i].view(-1, 1)\n )\n local_q = agent.critic_local(states, actions)\n\n value_loss = agent.loss_fn(local_q, target_q)\n agent.value_optimizer.zero_grad()\n value_loss.backward()\n agent.value_optimizer.step()\n\n local_actions = []\n for i, a in enumerate(self.agents):\n local_states = self._agent_states(i, states)\n local_actions.append(\n a.actor_local(local_states)\n if a == agent\n else a.actor_local(local_states).detach()\n )\n local_actions = torch.cat(local_actions, 1)\n policy_loss = -agent.critic_local(states, local_actions).mean()\n\n agent.policy_optimizer.zero_grad()\n policy_loss.backward()\n agent.policy_optimizer.step()\n\n self._update_target_model(agent.critic_local, agent.critic_target)\n self._update_target_model(agent.actor_local, agent.actor_target)","def process():\n pass","def _preprocess(self):\n if self.gt_matrix_PCs is None:\n start = time.time()\n gt_matrix = self._process_vcf().get('gt_matrix')\n print('gt_matrix took {} secs'.format(time.time() - start))\n \n # Normalize gt_matrix by site\n gt_matrix_norm = gt_matrix - np.mean(gt_matrix, axis=1)[:, np.newaxis]\n \n # PCA\n start = time.time()\n u, s, vh = np.linalg.svd(gt_matrix_norm.T, full_matrices=False)\n print('SVD took {} secs'.format(time.time() - start))\n self.gt_matrix_PCs = -u @ np.diag(s)\n \n # Get relevant objects from result of ripser\n if self.ripser_result is None:\n start = time.time()\n print(\"Getting ripser object\")\n self.ripser_result = ripser(self.gt_matrix_PCs, coeff=2, maxdim=1, do_cocycles=True)\n print('Ripser took {} secs'.format(time.time() - start))","def compute(args, fun, max_workers=6):\n print(\"\\nProcessing symbols in parallel\")\n ex = futures.ThreadPoolExecutor(max_workers=max_workers)\n ex.map(fun, args)","def __init__(self, feature_store=None, batch_size=100):\n if feature_store:\n if type(feature_store) is dict: # A silly way to avoid multiple reading\n self.features = feature_store\n self.image_w = 640\n self.image_h = 480\n self.vfov = 60\n self.feature_size = next(iter(self.features.values())).shape[-1]\n # print('The feature size is %d' % self.feature_size)\n else:\n print('Image features not provided')\n self.features = None\n self.image_w = 640\n self.image_h = 480\n self.vfov = 60\n self.featurized_scans = set([key.split(\"_\")[0] for key in list(self.features.keys())])\n self.sims = []\n self.qin = []\n self.qout = []\n self.qtraj = []\n self.feature_states = None\n self.batch_size = batch_size\n for i in range(batch_size):\n sim = MatterSim.Simulator()\n sim.setRenderingEnabled(False)\n sim.setDiscretizedViewingAngles(True) # Set increment/decrement to 30 degree. (otherwise by radians)\n sim.setCameraResolution(self.image_w, self.image_h)\n sim.setCameraVFOV(math.radians(self.vfov))\n sim.init()\n self.sims.append(sim)\n\n self.qin.append(queue.Queue())\n self.qout.append(queue.Queue())\n self.qtraj.append(queue.Queue())\n \n self.pool = []\n\n def function(i, sim, qin, qout, qtraj):\n env_actions = {\n 'left': (0,-1, 0), # left\n 'right': (0, 1, 0), # right\n 'up': (0, 0, 1), # up\n 'down': (0, 0,-1), # down\n 'forward': (1, 0, 0), # forward\n '<end>': (0, 0, 0), # <end>\n '<start>': (0, 0, 0), # <start>\n '<ignore>': (0, 0, 0) # <ignore>\n }\n while True:\n op, x = qin.get()\n \n # while not qout.empty():\n # qout.get()\n # while not qtraj.empty():\n # qtraj.get()\n\n if op == 'act':\n select_candidate, src_point, trg_point, src_level, trg_level = x\n traj = []\n def take_action(i, name):\n if type(name) is int: # Go to the next view\n sim.makeAction(name, 0, 0)\n else: # Adjust\n sim.makeAction(*env_actions[name])\n state = sim.getState()\n \n traj.append((state.location.viewpointId, state.heading, state.elevation))\n \n\n while src_level < trg_level: # Tune up\n take_action(i, 'up')\n src_level += 1\n while src_level > trg_level: # Tune down\n take_action(i, 'down')\n src_level -= 1\n while sim.getState().viewIndex != trg_point: # Turn right until the target\n take_action(i, 'right')\n assert select_candidate['viewpointId'] == \\\n sim.getState().navigableLocations[select_candidate['idx']].viewpointId\n take_action(i, select_candidate['idx'])\n\n state = sim.getState()\n qout.put((state.scanId, state.location.viewpointId, state.heading, state.elevation))\n # print(traj)\n qtraj.put(traj)\n\n elif op == 'new':\n scanId, viewpointId, heading, elevation = x\n sim.newEpisode(scanId, viewpointId, heading, elevation)\n\n elif op == 'state':\n state = sim.getState()\n state = State(state)\n # if name != 'env':\n # setattr(env_copy,name,value)\n \n qout.put(state)\n\n for i in range(batch_size):\n p = threading.Thread(target=function, args=(i, self.sims[i], self.qin[i], self.qout[i], self.qtraj[i]), daemon=True)\n \n p.start()\n self.pool.append(p)","def read_data_split_and_search():\n\n\n\n dataReader = Movielens10MReader()\n dataset = dataReader.load_data()\n\n URM_train, URM_test = split_train_in_two_percentage_global_sample(dataset.get_URM_all(), train_percentage = 0.80)\n URM_train, URM_validation = split_train_in_two_percentage_global_sample(URM_train, train_percentage = 0.80)\n\n output_folder_path = \"result_experiments/\"\n\n\n # If directory does not exist, create\n if not os.path.exists(output_folder_path):\n os.makedirs(output_folder_path)\n\n\n\n\n\n\n\n collaborative_algorithm_list = [\n Random,\n TopPop,\n P3alphaRecommender,\n RP3betaRecommender,\n ItemKNNCFRecommender,\n UserKNNCFRecommender,\n MatrixFactorization_BPR_Cython,\n MatrixFactorization_FunkSVD_Cython,\n PureSVDRecommender,\n SLIM_BPR_Cython,\n SLIMElasticNetRecommender\n ]\n\n\n\n\n from Base.Evaluation.Evaluator import EvaluatorHoldout\n\n evaluator_validation = EvaluatorHoldout(URM_validation, cutoff_list=[5])\n evaluator_test = EvaluatorHoldout(URM_test, cutoff_list=[5, 10])\n\n\n runParameterSearch_Collaborative_partial = partial(runParameterSearch_Collaborative,\n URM_train = URM_train,\n metric_to_optimize = \"MAP\",\n n_cases = 10,\n evaluator_validation_earlystopping = evaluator_validation,\n evaluator_validation = evaluator_validation,\n evaluator_test = evaluator_test,\n output_folder_path = output_folder_path,\n similarity_type_list = [\"cosine\"],\n parallelizeKNN = False)\n\n\n\n\n\n pool = multiprocessing.Pool(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)\n pool.map(runParameterSearch_Collaborative_partial, collaborative_algorithm_list)\n\n #\n #\n # for recommender_class in collaborative_algorithm_list:\n #\n # try:\n #\n # runParameterSearch_Collaborative_partial(recommender_class)\n #\n # except Exception as e:\n #\n # print(\"On recommender {} Exception {}\".format(recommender_class, str(e)))\n # traceback.print_exc()\n #","def main():\n model = sys.argv[1]\n maxfun = int(sys.argv[2])\n n_threads = int(sys.argv[3])\n\n # Validate input.\n assert maxfun >= 0, \"Maximum number of function evaluations cannot be negative.\"\n assert n_threads >= 1 or n_threads == -1, (\n \"Use -1 to impose no restrictions on maximum number of threads or choose a \"\n \"number higher than zero.\"\n )\n\n # Set number of threads\n os.environ[\"NUMBA_NUM_THREADS\"] = f\"{n_threads}\"\n os.environ[\"MKL_NUM_THREADS\"] = f\"{n_threads}\"\n os.environ[\"OMP_NUM_THREADS\"] = f\"{n_threads}\"\n os.environ[\"NUMEXPR_NUM_THREADS\"] = f\"{n_threads}\"\n\n # Late import of respy to ensure that environment variables are read by Numpy, etc..\n import respy as rp\n\n # Get model\n params, options = rp.get_example_model(model, with_data=False)\n\n # Simulate the data\n simulate = rp.get_simulate_func(params, options)\n df = simulate(params)\n\n # Get the criterion function and the parameter vector.\n crit_func = rp.get_log_like_func(params, options, df)\n\n # Run the estimation\n start = dt.datetime.now()\n\n for _ in range(maxfun):\n crit_func(params)\n\n end = dt.datetime.now()\n\n # Aggregate information\n output = {\n \"model\": model,\n \"maxfun\": maxfun,\n \"n_threads\": n_threads,\n \"start\": str(start),\n \"end\": str(end),\n \"duration\": str(end - start),\n }\n\n # Save time to file\n with open(\"scalability_results.txt\", \"a+\") as file:\n file.write(json.dumps(output))\n file.write(\"\\n\")","def do(self, argin):\n device=self.target\n # Code here\n errs = [] # list of error messages\n receptor_to_vcc = dict([*map(int, pair.split(\":\"))] for pair in\n device._proxy_cbf_controller.receptorToVcc)\n for receptorID in argin:\n try:\n vccID = receptor_to_vcc[receptorID]\n vccProxy = device._proxies_vcc[vccID - 1]\n\n # Update the VCC receptorID attribute:\n\n self.logger.debug( (\"receptorID = {}, vccProxy.receptorID = {}\"\n .format(receptorID, vccProxy.receptorID)))\n\n vccProxy.receptorID = receptorID # TODO - may not be needed?\n\n self.logger.debug( (\"receptorID = {}, vccProxy.receptorID = {}\"\n .format(receptorID, vccProxy.receptorID)))\n\n subarrayID = vccProxy.subarrayMembership\n\n # only add receptor if it does not already belong to a different subarray\n if subarrayID not in [0, device._subarray_id]:\n errs.append(\"Receptor {} already in use by subarray {}.\".format(\n str(receptorID), str(subarrayID)))\n else:\n if receptorID not in device._receptors:\n # change subarray membership of vcc\n vccProxy.subarrayMembership = device._subarray_id\n\n # TODO: is this note still relevant? \n # Note:json does not recognize NumPy data types. \n # Convert the number to a Python int \n # before serializing the object.\n # The list of receptors is serialized when the FSPs are \n # configured for a scan.\n\n device._receptors.append(int(receptorID))\n device._proxies_assigned_vcc.append(vccProxy)\n device._group_vcc.add(device._fqdn_vcc[vccID - 1])\n\n # subscribe to VCC state and healthState changes\n event_id_state = vccProxy.subscribe_event(\n \"State\",\n tango.EventType.CHANGE_EVENT,\n device._state_change_event_callback\n )\n\n event_id_health_state = vccProxy.subscribe_event(\n \"healthState\",\n tango.EventType.CHANGE_EVENT,\n device._state_change_event_callback\n )\n\n device._events_state_change_vcc[vccID] = [event_id_state,\n event_id_health_state]\n else:\n log_msg = \"Receptor {} already assigned to current subarray.\".format(\n str(receptorID))\n self.logger.warn(log_msg)\n\n except KeyError: # invalid receptor ID\n errs.append(\"Invalid receptor ID: {}\".format(receptorID))\n\n\n if errs:\n msg = \"\\n\".join(errs)\n self.logger.error(msg)\n # tango.Except.throw_exception(\"Command failed\", msg, \"AddReceptors execution\",\n # tango.ErrSeverity.ERR)\n \n return (ResultCode.FAILED, msg)\n\n message = \"CBFSubarray AddReceptors command completed OK\"\n self.logger.info(message)\n return (ResultCode.OK, message)","def _multiprocess_handler(month_year):\n trmm_data = TRMM_data(month_year)\n trmm_data.load_creds()\n if args.type == 's3_push':\n trmm_data.data_fetch_netcdf()\n elif args.type == 's3_pull':\n trmm_data.data_pull_s3()","def simplify_functions_parallel(expressions):\n manager = multiprocessing.Manager()\n return_dict = manager.dict()\n\n processes = []\n factorised_expressions = []\n for index, item in enumerate(expressions):\n # print(\"item \", item, \"index\", index)\n processes.append(multiprocessing.Process(target=bar, args=(item, index, return_dict)))\n for p in processes:\n p.start()\n\n for p in processes:\n p.join()\n\n ## Showing the difference in an example:\n # print(return_dict)\n for i in sorted(return_dict.keys()):\n factorised_expressions.append(return_dict[i])\n return factorised_expressions","def precompute_options_values_multipool(adj, skills, g):\n import os\n import multiprocessing\n processes=[]\n pool = multiprocessing.Pool(processes=len(skills))\n out = pool.map(multi_pov, [['fsdfa', [skill], g] for skill in skills])\n print out\n rewards = np.zeros((4604, len(skills)))\n dests = np.zeros((4604, len(skills)))\n discounts = np.zeros((4604, len(skills)))\n skill_vals_2 = np.zeros((4604, len(skills)))\n skill_Zs_2 = np.zeros((4604, len(skills)))\n if not os.path.exists('./povs/' + str(len(skills)) + '/' + str(skills[0][1])):\n os.makedirs('./povs/' + str(len(skills)) + '/' + str(skills[0][1]))\n names = ['rewards', 'dests', 'discounts', 'skill_vals_2', 'skill_Zs_2']\n for n in range(len(skills)):\n for index, array in enumerate([rewards, dests, discounts, skill_vals_2, skill_Zs_2]):\n array[:, n] = out[n][index][:, 0]\n if index == 1:\n dests = np.array(dests, dtype='int')\n np.save('./povs/' + str(len(skills)) + '/' + str(skills[0][1]) + '/' + str(names[index]), array)\n return [rewards, dests, discounts, skill_vals_2, skill_Zs_2]","def __init__(self, feature_store=None, batch_size=100):\n if feature_store:\n if type(feature_store) is dict: # A silly way to avoid multiple reading\n self.features = feature_store\n self.image_w = 640\n self.image_h = 480\n self.vfov = 60\n self.feature_size = next(iter(self.features.values())).shape[-1]\n # print('The feature size is %d' % self.feature_size)\n else:\n print('Image features not provided')\n self.features = None\n self.image_w = 640\n self.image_h = 480\n self.vfov = 60\n self.featurized_scans = set([key.split(\"_\")[0] for key in list(self.features.keys())])\n self.sims = []\n self.qin = []\n self.qout = []\n self.qtraj = []\n self.feature_states = None\n self.batch_size = batch_size\n for i in range(batch_size):\n sim = MatterSim.Simulator()\n sim.setRenderingEnabled(False)\n sim.setDiscretizedViewingAngles(True) # Set increment/decrement to 30 degree. (otherwise by radians)\n sim.setCameraResolution(self.image_w, self.image_h)\n sim.setCameraVFOV(math.radians(self.vfov))\n sim.init()\n self.sims.append(sim)\n\n self.qin.append(Queue())\n self.qout.append(Queue())\n self.qtraj.append(Queue())\n \n self.pool = []\n\n def function(i, sim, qin, qout, qtraj):\n env_actions = {\n 'left': (0,-1, 0), # left\n 'right': (0, 1, 0), # right\n 'up': (0, 0, 1), # up\n 'down': (0, 0,-1), # down\n 'forward': (1, 0, 0), # forward\n '<end>': (0, 0, 0), # <end>\n '<start>': (0, 0, 0), # <start>\n '<ignore>': (0, 0, 0) # <ignore>\n }\n while True:\n op, x = qin.get()\n \n # while not qout.empty():\n # qout.get()\n # while not qtraj.empty():\n # qtraj.get()\n\n if op == 'act':\n select_candidate, src_point, trg_point, src_level, trg_level = x\n traj = []\n def take_action(i, name):\n if type(name) is int: # Go to the next view\n sim.makeAction(name, 0, 0)\n else: # Adjust\n sim.makeAction(*env_actions[name])\n state = sim.getState()\n \n traj.append((state.location.viewpointId, state.heading, state.elevation))\n \n\n while src_level < trg_level: # Tune up\n take_action(i, 'up')\n src_level += 1\n while src_level > trg_level: # Tune down\n take_action(i, 'down')\n src_level -= 1\n while sim.getState().viewIndex != trg_point: # Turn right until the target\n take_action(i, 'right')\n assert select_candidate['viewpointId'] == \\\n sim.getState().navigableLocations[select_candidate['idx']].viewpointId\n take_action(i, select_candidate['idx'])\n\n state = sim.getState()\n qout.put((state.scanId, state.location.viewpointId, state.heading, state.elevation))\n # print(traj)\n qtraj.put(traj)\n\n elif op == 'new':\n scanId, viewpointId, heading, elevation = x\n sim.newEpisode(scanId, viewpointId, heading, elevation)\n\n elif op == 'state':\n state = sim.getState()\n state = State(state)\n # if name != 'env':\n # setattr(env_copy,name,value)\n \n qout.put(state)\n\n for i in range(batch_size):\n p = Process(target=function, args=(i, self.sims[i], self.qin[i], self.qout[i], self.qtraj[i]), daemon=True)\n \n p.start()\n self.pool.append(p)","def __init__(self, state_size, action_size, random_seed=0):\n self.state_size = state_size\n self.action_size = action_size\n self.seed = random.seed(random_seed)\n\n self.epsilon = EPSILON\n\n # Actor Network (w/ Target Network)\n self.actor_local = Actor(state_size, action_size, random_seed, leakiness=LEAKINESS, kaiming=USEKAIMING).to(device)\n self.actor_target = Actor(state_size, action_size, random_seed, leakiness=LEAKINESS, kaiming=USEKAIMING).to(device)\n if OPTIM == \"AdamW\" and hasattr(optim,'AdamW'):\n self.actor_optimizer = optim.AdamW(self.actor_local.parameters(), lr=LR_ACTOR)\n else: \n self.actor_optimizer = optim.Adam(self.actor_local.parameters(), lr=LR_ACTOR)\n\n # Critic Network (w/ Target Network)\n self.critic_local = Critic(state_size, action_size, random_seed, leakiness=LEAKINESS, kaiming=USEKAIMING).to(device)\n self.critic_target = Critic(state_size, action_size, random_seed, leakiness=LEAKINESS, kaiming=USEKAIMING).to(device)\n if OPTIM == \"AdamW\" and hasattr(optim,'AdamW'):\n self.critic_optimizer = optim.AdamW(self.critic_local.parameters(), lr=LR_CRITIC, weight_decay=AWEIGHT_DECAY)\n else: \n self.critic_optimizer = optim.Adam(self.critic_local.parameters(), lr=LR_CRITIC, weight_decay=WEIGHT_DECAY)\n\n # Noise process\n self.noise = OUNoise(action_size, random_seed)\n\n # Replay memory\n if not PRIORITIZED:\n self.memory = ReplayBuffer(BUFFER_SIZE, BATCH_SIZE, random_seed)\n else:\n self.memory = NaivePrioritizedBuffer(BUFFER_SIZE, BATCH_SIZE, random_seed)","def execute_objective(arguments):\n #later call define_tr_val from within this function for speedup.\n #score, pred_ = self.define_tr_val() #just get the train and test...\n \n\n cv_samples, parallel_arguments, parameters, windowsOS, id_ = arguments\n device = parallel_arguments[\"device\"]\n declaration_args = parallel_arguments[\"declaration_args\"]\n backprop_args = parallel_arguments[\"backprop_args\"]\n #del declaration_args['reservoir']\n\n cv_args = parallel_arguments[\"cv_args\"]\n log_score, rounds, tr_score_prop = cv_args[\"log_score\"], cv_args[\"rounds\"], cv_args[\"tr_score_prop\"]\n\n # if windowsOS == True:\n # #move specific arguments to the gpu.\n # cv_samples_ = []\n # for i, cv_sample in enumerate(cv_samples):\n # if cv_sample[\"tr_y\"].device != device:\n # #if cv_sample[\"tr_x\"]:\n # train_x, validate_x = cv_sample[\"tr_x\"].to(device), cv_sample[\"val_x\"].to(device)\n\n # train_y, validate_y = cv_sample[\"tr_y\"].to(device), cv_sample[\"val_y\"].to(device)\n # else:\n # #consider not sending the cv_sample[\"x\"] if it's a pure prediction.\n # train_x, train_y = cv_sample[\"tr_x\"], cv_sample[\"tr_y\"]\n # validate_x, validate_y = cv_sample[\"val_x\"], cv_sample[\"val_y\"]\n # cv_samples_.append((train_x, train_y, validate_x, validate_y))\n\n # #now move the input weights and the reservoir arguments to the gpu.\n # #deepcopy()\n # assert declaration_args[\"reservoir\"] != None\n # if declaration_args[\"reservoir\"] != None:\n # declaration_args[\"reservoir\"].in_weights = declaration_args[\"reservoir\"].in_weights.to(device)\n # declaration_args[\"reservoir\"].accept = declaration_args[\"reservoir\"].accept.to(device)\n # declaration_args[\"reservoir\"].reservoir_pre_weights = declaration_args[\"reservoir\"].reservoir_pre_weights.to(device)\n\n # RC = EchoStateNetwork(**declaration_args, **parameters, id_ = id_)\n \n RC = EchoStateNetwork(**declaration_args, **parameters, id_ = id_)\n cv_samples_ = []\n for i, cv_sample in enumerate(cv_samples):\n cv_samples_.append((cv_sample[\"tr_x\"], cv_sample[\"tr_y\"], cv_sample[\"val_x\"], cv_sample[\"val_y\"]))\n\n ODE_order = parallel_arguments[\"train_args\"][\"ODE_order\"]\n\n train_args = parallel_arguments[\"train_args\"]\n test_args = parallel_arguments[\"test_args\"]\n\n total_score = 0\n\n backprop_f = backprop_args[\"backprop_f\"]\n\n if type(train_args[\"init_conditions\"][0]) == list:\n multiple_ICs = True if len(train_args[\"init_conditions\"][0]) > 1 else False\n else:\n multiple_ICs = False\n\n for i, cv_sample in enumerate(cv_samples_):\n #print(i)\n train_x, train_y, validate_x, validate_y = cv_sample\n\n cv_sample_score = 0\n\n #divis = rounds *2\n if ODE_order:\n if multiple_ICs:\n # if train_score:\n # return {\"scores\" : scores, \n # \"weights\": gd_weights, \n # \"biases\" : gd_biases,\n # \"ys\" : ys,\n # \"ydots\" : ydots,\n # \"losses\" : Ls}\n dictt = RC.fit(X = train_x, y = train_y, train_score = True, **train_args)\n train_scores = dictt[\"scores\"]\n val_scores, pred_, id_ = RC.test(X=validate_x, y= validate_y, **test_args)\n\n \n for i, train_score in enumerate(train_scores):\n \n train_scores[i] = process_score(train_score, device = device)\n\n val_score = process_score(val_scores[i], device = device)# / divis\n\n round_score = combine_score(train_score, val_score, tr_score_prop, log_score) \n cv_sample_score += round_score \n total_score += cv_sample_score\n\n else:\n #train_score = RC.fit(X = train_x, y = train_y, train_score = True, **parallel_arguments[\"train_args\"])\n results = RC.fit(X = train_x, y = train_y, train_score = True, **train_args)\n train_scores = results[\"scores\"]\n train_score = train_scores[0]\n\n train_score = process_score(train_score, device = device)# / divis\n\n val_scores, pred_, id_ = RC.test(X=validate_x, y= validate_y, **test_args)\n val_score = process_score(val_scores[0], device = device)# / divis\n\n cv_sample_score = combine_score(train_score, val_score, tr_score_prop, log_score) \n\n \n else:\n _ = RC.fit(X = train_x, y = train_y,**parallel_arguments[\"train_args\"])\n #train_score = process_score(train_score)\n \n val_score, pred_, id_ = RC.test(X=validate_x, y= validate_y, **parallel_arguments[\"test_args\"])\n val_score = process_score(val_score)\n\n cv_sample_score = val_score #combine_score(train_score, val_score)\n\n #del train_x; del train_y;\n #del validate_x;\n\n if id_ != 0:\n del validate_y; del pred_;\n\n total_score += cv_sample_score\n #if device == torch.device('cuda'):\n # torch.cuda.empty_cache()\n\n #del RC;\n #score_mu = total_score/len(cv_samples)\n #del cv_samples;\n nn = len(cv_samples_) * len(train_scores)\n\n total_score = total_score / nn\n if id_ == 0:\n try:\n validate_y = validate_y.to(\"cpu\")\n except:\n pass\n return float(total_score), {\"pred\": pred_.to(\"cpu\"), \"val_y\" : validate_y}, id_\n else:\n return float(total_score), None, id_","def makeLargeTracts(input_queue, output_queue, config, db_config):\n\n \n # capture the process name\n my_name = mp.current_process().name\n my_ip_address = socket.gethostbyname(socket.gethostname())\n\n while True:\n try:\n # get the next element out of the queue\n inputs = input_queue.get()\n try:\n if inputs[0] is None: break\n\n # extract the terms from the queue list\n numprov_path = inputs[0] \n blockm_df = inputs[1] \n out_tract_path = inputs[2] \n out_county_path = inputs[3] \n out_tract_df = inputs[4]\n out_county_df = inputs[5] \n start_time = inputs[6] \n worker_speed = inputs[7]\n config = inputs[8]\n geom = 'geoid%s' % config['census_vintage'][2:]\n\n continue_run, block_numprov = openNumprovFile(numprov_path, geom, \n my_name, my_ip_address, worker_speed, \n start_time, output_queue)\n\n if continue_run:\n continue_run, block_numprov = mergeWithDataFrame(\n block_numprov, blockm_df, geom, my_name, \n my_ip_address, worker_speed, start_time, \n output_queue) \n\n if continue_run:\n for geo in ['tract', 'county']:\n continue_run, out_df = findPerCapitaProviders(my_name, \n my_ip_address, geo, block_numprov, \n output_queue, start_time, config, \n worker_speed, eval('out_%s_df' % geo))\n \n if continue_run:\n continue_run = outputGeoData(out_df, \n eval('out_%s_path' % geo), my_name, \n my_ip_address, geo, worker_speed, \n start_time, output_queue)\n\n except:\n pass\n\n except:\n # nothing in the queue, wait and check again\n time.sleep(1)\n\n return True","def ExecuteInstanceStochasticAdaptiveRefinementAux_Functionality(current_global_index,pickled_coarse_model,pickled_coarse_project_parameters,pickled_custom_metric_refinement_parameters,pickled_custom_remesh_refinement_parameters,random_variable,current_index,current_analysis_stage,previous_computational_time,open_mp_threads,mapping_flag,pickled_mapping_reference_model,print_to_file,filename):\n\n start_time = time.time()\n # unpickle model and build Kratos Model object\n serialized_model = pickle.loads(pickled_coarse_model)\n current_model = KratosMultiphysics.Model()\n serialized_model.Load(\"ModelSerialization\",current_model)\n del(serialized_model)\n # unpickle parameters and build Kratos Parameters object\n serialized_project_parameters = pickle.loads(pickled_coarse_project_parameters)\n current_project_parameters = KratosMultiphysics.Parameters()\n serialized_project_parameters.Load(\"ParametersSerialization\",current_project_parameters)\n del(serialized_project_parameters)\n # refine if current current_global_index > 0, adaptive refinement based on the solution of previous index\n if (current_index > 0):\n # unpickle metric and remesh refinement parameters and build Kratos Parameters objects\n serialized_custom_metric_refinement_parameters = pickle.loads(pickled_custom_metric_refinement_parameters)\n serialized_custom_remesh_refinement_parameters = pickle.loads(pickled_custom_remesh_refinement_parameters)\n current_custom_metric_refinement_parameters = KratosMultiphysics.Parameters()\n current_custom_remesh_refinement_parameters = KratosMultiphysics.Parameters()\n serialized_custom_metric_refinement_parameters.Load(\"MetricRefinementParametersSerialization\",current_custom_metric_refinement_parameters)\n serialized_custom_remesh_refinement_parameters.Load(\"RemeshRefinementParametersSerialization\",current_custom_remesh_refinement_parameters)\n del(serialized_custom_metric_refinement_parameters,serialized_custom_remesh_refinement_parameters)\n # refine the model Kratos object\n adaptive_refinement_manager = AdaptiveRefinement(current_index,current_model,current_project_parameters,current_custom_metric_refinement_parameters,current_custom_remesh_refinement_parameters)\n refined_model,refined_project_parameters = adaptive_refinement_manager.ComputeAdaptiveRefinement()\n current_model = refined_model\n del(refined_model,refined_project_parameters)\n # constructor analysis stage\n simulation = current_analysis_stage(current_model,current_project_parameters,random_variable)\n # add filename flag print_to_file is true\n if (print_to_file):\n simulation.filename = filename\n # add flag if current index is maximum index\n if (current_index == current_global_index):\n simulation.is_current_index_maximum_index = True\n else:\n simulation.is_current_index_maximum_index = False\n # mapping if in current finest level and mapping flag is true\n # otherwise standard behavior\n if (mapping_flag is True and current_index == current_global_index):\n # unpickle mapping reference model and build Kratos Model object\n serialized_mapping_reference_model = pickle.loads(pickled_mapping_reference_model)\n mapping_reference_model = KratosMultiphysics.Model()\n serialized_mapping_reference_model.Load(\"ModelSerialization\",mapping_reference_model)\n del(serialized_mapping_reference_model)\n # send reference model to analysis stage for mapping and set mapping flag to true\n simulation.mapping_reference_model = mapping_reference_model\n simulation.mapping = True\n simulation.Run()\n # mapping if in current finest level and mapping flag is true\n # otherwise standard qoi evaluation\n if (mapping_flag is True and current_index == current_global_index):\n qoi = simulation.MappingAndEvaluateQuantityOfInterest()\n else:\n qoi = simulation.EvaluateQuantityOfInterest()\n # save model and parameters as MpiSerializer Kratos objects\n serialized_finer_model = KratosMultiphysics.MpiSerializer()\n serialized_finer_model.Save(\"ModelSerialization\",simulation.model)\n # pickle model and parameters\n pickled_finer_model = pickle.dumps(serialized_finer_model, 2) # second argument is the protocol and is NECESSARY (according to pybind11 docs)\n del(simulation)\n end_time = time.time()\n computational_time = previous_computational_time + open_mp_threads*(end_time-start_time) # multiply by open mp threads to consider real machine cost\n return qoi,pickled_finer_model,computational_time","def make_processing_functions(self):\n return","def run(self):\n #parse requests\n self.bqSession.update_mex('Calculating Features...')\n log.debug('Forming Feature Requests...')\n #get rectanle gobjects for roi\n r_xml = self.bqSession.fetchxml(self.options.mexURL, view='deep')\n\n rectangles = r_xml.xpath('//tag[@name=\"inputs\"]/tag[@name=\"image_url\"]/gobject[@name=\"roi\"]/rectangle')\n image_xml = self.bqSession.fetchxml(self.options.image_url)\n image_url = self.bqSession.service_url('image_service',path=image_xml.attrib['resource_uniq'])\n if rectangles: #On chooses the first rectangle\n #construct operation node\n x1 = int(float(rectangles[0][0].attrib['x']))\n y1 = int(float(rectangles[0][0].attrib['y']))\n x2 = int(float(rectangles[0][1].attrib['x']))\n y2 = int(float(rectangles[0][1].attrib['y']))\n log.debug('Adding Crop: roi=%s,%s,%s,%s' % (x1, y1, x2, y2))\n image_url = self.bqSession.c.prepare_url(image_url, roi='%s,%s,%s,%s' % (x1, y1, x2, y2))\n \n try:\n feature_vectors = extract_bush_feature(self.bqSession, image_url)\n except FeatureCommError as e:\n raise BotanicamError(str(e))\n \n #parse features\n self.bqSession.update_mex('Classifying Results...')\n log.debug('Classifying Results...')\n results= []\n pca = joblib.load(os.path.join(self.model_path,'pca_model'))\n clf = joblib.load(os.path.join(self.model_path,'svm_model'))\n \n for f in feature_vectors:\n f_norm = pca.transform(f)\n results.append(int(clf.predict(f_norm)))\n \n\n class_count = np.bincount(np.array(results))\n self.class_number = np.argmax(class_count)\n self.confidence = float(class_count[self.class_number])/np.sum(class_count)\n log.debug('Found Class %s'%str(self.class_number))","def RUN_PULSAR(numTrials, rateMap, numPhotons=48,numPulsars = 6, angularSize=10.0, outputSize=100, mcList='MCOut.pickle',flatLevel = 0.0,HESS=False, Sig = -1,numProcs = 10):\r\n import FermiPSF, ParseFermi\r\n \r\n print 'Beginning MC Series\\nProgress'\r\n\r\n mcOut = []\r\n map = pickle.load(open(rateMap, \"r\" )) # load rate-map\r\n PSFTableFront = FermiPSF.PSF_130(convType='front') # load PSF front converting\r\n PSFTableBack = FermiPSF.PSF_130(convType='back') # load PSF back converting\r\n start = time.time();\r\n \r\n ppa = outputSize/angularSize # pixel per degree\r\n\r\n # Import background template\r\n bgmap = 'BGRateMap.pickle'\r\n if (HESS == True):\r\n bgmap = 'BGRateMap_HESS_2_deg.pickle'\r\n \r\n bgTemplate = pickle.load(open(bgmap , \"r\" ))\r\n \r\n mcOut = np.zeros(numTrials)\r\n p = pool.Pool(numProcs)\r\n partial_MC_PULSAR_THREAD = partial( MC_PULSAR_THREAD, map = map,bgTemplate=bgTemplate,PSFTableFront=PSFTableFront, PSFTableBack=PSFTableBack, HESS=HESS, angularSize=angularSize, numPhotons=numPhotons, outputSize=outputSize, numPulsars = numPulsars,Sig=Sig)\r\n mcOut = p.map(partial_MC_PULSAR_THREAD, mcOut)\r\n \r\n# for i in range(numTrials):\r\n# np.random.seed()\r\n# # Compute number of background photons\r\n# numSignal = np.random.poisson(lam = .25*numPhotons)\r\n# if (HESS == True):\r\n# numSignal = np.random.poisson(lam = .05*numPhotons)\r\n# if Sig >= 0:\r\n# numSignal = np.random.poisson(lam = Sig*numPhotons)\r\n# \r\n# bg = numPhotons-numSignal # number of BG photons\r\n# \r\n# # Build the background \r\n## background = Build_Background_Sideband(bgMean, lowSideband, highSideband, PSFTable)\r\n# background = Build_Background_Template(bg, bgTemplate, PSFTableFront, PSFTableBack ,HESS=HESS, angularSize = angularSize )\r\n# \r\n# \r\n# # Run MC for source photons \r\n# data = MC_PULSAR(map,numSignal, numPulsars,angularSize,outputSize,PSFTableFront, PSFTableBack, HESS = HESS)\r\n# # Concatenate and append this run to the simulation output\r\n# mcOut.append((data[0]+background[0], data[1]+background[1]))\r\n# \r\n# # Compute Speed Statistics\r\n# sys.stdout.write('\\r' + str(i+1)+'/'+str(numTrials)) \r\n# sys.stdout.flush()\r\n elapsed = time.time()-start;\r\n if (elapsed != 0.0):\r\n print '\\nSimulations Completed in', elapsed, 's', '(',numTrials/elapsed, ' sims per second)'\r\n \r\n outFile = open(mcList, \"wb\" )\r\n pickle.dump(mcOut, outFile)\r\n print 'Results saved to ', mcList\r\n return mcOut","def get_all_leak(df, cols=None, nlags=15):\r\n df = df.copy()\r\n# print(df.head())\r\n# with Pool(processes=CPU_CORES) as p:\r\n if True:\r\n begin_ind = 0\r\n end_ind = 0\r\n leak_target = pd.Series(0, index = df.index)\r\n while begin_ind < nlags:\r\n end_ind = min(begin_ind + CPU_CORES, nlags)\r\n search_ind = (leak_target == 0)\r\n # print(search_ind)\r\n print('begin_ind: ', begin_ind, 'end_ind: ', end_ind, \"search_ind_len: \", search_ind.sum())\r\n# res = [p.apply_async(_get_leak, args=(df, cols, search_ind, i)) for i in range(begin_ind, end_ind)]\r\n# for r in res:\r\n# target_vals, lag = r.get()\r\n# # print ('target_vale', target_vals.head())\r\n# # leak_target[target_vals.index] = target_vals\r\n# df['leak_target_' + str(lag)] = target_vals\r\n target_vals, lag = _get_leak(df, cols, search_ind, begin_ind)\r\n df['leak_target_' + str(lag)] = target_vals\r\n for i in range(begin_ind, end_ind):\r\n leak_target[leak_target == 0] = df.loc[leak_target == 0, 'leak_target_' + str(i)]\r\n leak_train = 0 #leak_target[train.index]\r\n leak_train_len = 0 #leak_train[leak_train != 0].shape[0]\r\n leak_test_len = 0 #leak_target[test.index][leak_target != 0].shape[0]\r\n leak_train_right_len = 0 #leak_train[leak_train.round(0) == train['target'].round(0)].shape[0]\r\n leak_train_right_ratio = 0 #leak_train_right_len / leak_train_len\r\n if IsTrain:\r\n leak_train = leak_target[train.index]\r\n# print (leak_train.head())\r\n leak_train_len = leak_train[leak_train != 0].shape[0]\r\n leak_train_right_len = leak_train[leak_train.round(0) == train['target'].round(0)].shape[0]\r\n leak_train_right_ratio = leak_train_right_len / leak_train_len\r\n else:\r\n leak_test_len = leak_target[test.index][leak_target != 0].shape[0]\r\n print('Find leak in train and test: ', leak_train_len, leak_test_len, \\\r\n \"leak train right: \", leak_train_right_len, leak_train_right_ratio)\r\n begin_ind = end_ind\r\n # for i in range(nlags):\r\n # df.loc[df['leak_target'] == 0, 'leak_target'] = df.loc[df['leak_target'] == 0, 'leak_target_' + str(i)]\r\n df['leak_target'] = leak_target\r\n return df","def preprocess(self):","def optimization_step(self):\n \n if \"CSS\" in self.algorithm:\n \n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\n \n var_list = [self.x_tilda, self.minibatch_set]\n \n if (self.num_samples > 0) and (not self.mixture):\n \n if ((self.mf_steps > 0) and self.alpha >0) or\\\n self.gibbs_steps > 0: \n \n var_list.append(self.sampler_theta)\n \n elif \"CD\" in self.algorithm:\n \n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \n \n var_list = [self.minibatch_set]\n \n var_list.append(self.learning_rate)\n \n if self.use_momentum:\n \n var_list.append(self.momentum)\n \n output_vars = [self.pseudo_cost]\n \n if self.report_p_tilda:\n \n output_vars.append(self.p_tilda)\n \n else:\n \n output_vars.append(theano.shared(0))\n \n opt_step = theano.function(inputs = var_list,\n outputs = output_vars,\n updates = self.updates,\n givens = input_dict,\n on_unused_input='warn')\n \n return opt_step","def run_demultiplex_and_trim(self, opts, **kwargs):\n \n import logging\n self.logger = logging.getLogger('demultip')\n \n sample_primer_dict = {}\n \n if not opts:\n sys.exit(\"command line options not getting to main method\")\n \n metafile = opts.m\n \n # extract .gz to temp file location\n if 'gzipFilename' in kwargs:\n self.logger.info(\"Incoming kwargs detected...gzip file?\")\n #sequence_file = kwargs.get('gzipFilename')\n else:\n self.logger.info(\"No kwargs, normal Fastq file\")\n #sequence_file = opts.f\n self.logger.info(\"processing {0} total sequences\".format(str((self.r1_tot+self.r2_tot)/4)))\n self.logger.info(\"using the first {0} bases of primer in search\".format(self.search_length))\n\n \n #extract the relevant data from the metadata file, can maybe change this to non-qiime1\n self.logger.info(\"Getting header and mapping data...\")\n header, mapping_data, run_description, errors, warnings = process_id_map(metafile)\n self.logger.debug(\"metadata headers {0}\".format(header))\n self.logger.debug(\"csv mapping data from {0}...\\n{1}\".format(metafile, \"\\n\".join([str(x) for x in mapping_data])))\n \n # get the primer regex search patterns\n self.logger.info(\"Generating regex search patterns...\")\n forward_primers, forward_primers_rc, reverse_primers, reverse_primers_rc = self.create_primer_regex_patterns(header, mapping_data)\n self.primer_pattern_dict_list = {'fp' : forward_primers, 'fprc' : forward_primers_rc, 'rp' : reverse_primers, 'rprc' : reverse_primers_rc}\n \n \n self.logger.debug(\"forward_primer patterns\\n{0}\\n\".format(\"\\n\".join([str(x.pattern) for x in self.primer_pattern_dict_list.get('fp')])))\n self.logger.debug(\"reverse_primers patterns\\n{0}\\n\".format(\"\\n\".join([str(x.pattern) for x in self.primer_pattern_dict_list.get('rp')])))\n \n # replace all extra characters in header with underscore\n intab = '.-+|=:;,&$'\n outtab = '__________'\n trantab = maketrans(intab, outtab)\n \n for samples in mapping_data:\n try:\n sample_primer_dict[samples[header.index('SampleID')].translate(trantab)] = (samples[header.index('LinkerPrimerSequence')], samples[header.index('ReversePrimer')])\n except Exception as e:\n self.logger.error(\"Can not find {0} in header fields, please make sure metadata file has the required fields\".format(e))\n \n self.logger.debug(\"sample_primer_dict...{0}\".format(\"\\n\".join(x) for x in sample_primer_dict.items()))\n self.logger.info(\"Starting demultiplex process...\")\n \n bar = progressbar.ProgressBar(max_value=(self.r1_tot+self.r2_tot)/4,redirect_stdout=True)\n \n for r1, r2 in itertools.izip(self.R1.itervalues(), self.R2.itervalues()):\n #self.logger.debug(\"r1 {0}\".format(r1))\n #self.logger.debug(\"r2 {0}\".format(r1))\n\n pair_seq_dict = {'r1' : r1, 'r2' : r2}\n self.logger.debug(\"new read pair\\n\")\n self.logger.debug(\"processing new read pair {0}\".format(pair_seq_dict.keys()))\n \n self.logger.debug(\"processing seq ID - R1 {0}... R2 {1}\".format(r1.id, r2.id))\n self.logger.debug(\"R1 sequence - {0}...\".format(r1.seq[0:50]))\n self.logger.debug(\"R2 sequence - {0}...\".format(r2.seq[0:50]))\n\n self.sample_id = \"\"\n # because we process two sequences at a time (R1 and R2)\n self.processed_seqs += 2\n\n self.f_primer_found = []\n self.r_primer_found = []\n \n self.logger.debug(\"Looking in pair read for patterns...\")\n \n search_result = self.regex_search_through_sequence(pair_seq_dict, self.primer_pattern_dict_list)\n #self.logger.debug(\"pre read correction search_result - {0}\".format(search_result))\n #search_result = self.correct_orientation_of_reads(search_result)\n #self.logger.debug(\"post read correction search_result - {0}\".format(search_result))\n \n try:\n if type(search_result) == list and len(search_result) > 1:\n self.logger.debug(\"search result - {0}\".format(search_result[0]))\n self.logger.debug(\"search result - {0}\".format(search_result[1]))\n except IndexError as e:\n self.logger.debug(\"search result - {0}\".format(search_result))\n self.logger.debug(\"error in list index {0}\".format(e))\n \n \n read_pair_proceed = self.screen_read_pair_suitability(search_result)\n \n self.logger.debug(\"proceed with read pair ? {0}\".format(read_pair_proceed))\n \n if read_pair_proceed != 'failed':\n try:\n sample_id = self.get_sample_id_from_primer_sequence(sample_primer_dict, \n search_result[0].get('pattern'), \n search_result[1].get('pattern'))\n self.logger.debug(\"- R1 ID -> {0} & R2 ID -> {1} from sample {2}\".format(r1.id, r2.id, sample_id))\n except IndexError as e:\n # sample is missing one or both the patterns keys\n self.logger.debug(\"Sample seq is missing a pattern, {0}- discarding read\".format(e))\n output = self.record_buffer_and_writer({'discarded' : pair_seq_dict})\n self.unmapped_count += 2\n continue\n try:\n new_seq = self.clip_primers_from_seq(search_result, self.primer_pattern_dict_list, pair_seq_dict, sample_primer_dict, sample_id)\n self.logger.debug(\"clipped read returned...{0} seqs\".format(len(new_seq)))\n output = self.record_buffer_and_writer(new_seq)\n self.both_primers_count += 2\n except Exception as e:\n output = self.record_buffer_and_writer({'discarded' : pair_seq_dict})\n self.logger.debug(\"attempt to clip sequence failed - errmsg - {0} - discarding read {1}\".format(e, output))\n self.unmapped_count += 2\n continue\n \n bar.update(self.processed_seqs) \n \n if output == \"cleared\":\n self.record_buffer = {}\n self.logger.debug(\"buffer check {0}\".format(self.record_buffer))\n\n elif read_pair_proceed == 'failed':\n self.unmapped_count += 2\n output = self.record_buffer_and_writer({'discarded' : pair_seq_dict})\n bar.update(self.processed_seqs) \n \n self.logger.info(\"__________________________\")\n self.logger.info(\"Samples successfully mapped (F+R found): {0}\".format(self.both_primers_count))\n self.logger.info(\"Read pairs in alternate orientation - {0}\".format(str(len(self.alternate_orientation))))\n self.logger.info(\"Sequences not mapped: {0}\".format(self.unmapped_count))\n self.logger.info(\"Total sequences checked: {0}\".format(self.processed_seqs))\n \n self.logger.info(\"writing alternate record IDs...\")\n with open(\"alternate_orientation_records.txt\", 'w') as f:\n for sequence_id in self.alternate_orientation:\n output_id = ''.join(sequence_id)\n f.write(output_id) \n \n self.logger.info(\"Run finished\")","def _optimise_acquisition(acq_fn, acq_optimiser, anc_data):\n return acq_optimiser(acq_fn, anc_data.max_evals)","def max_pool_forward_naive(x, pool_param):\n out = None\n #############################################################################\n # TODO: Implement the max pooling forward pass #\n #############################################################################\n pass\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n cache = (x, pool_param)\n return out, cache","def jit(func):\n return func","def REDS(mode):\n #### configurations\n read_all_imgs = False # whether real all images to memory with multiprocessing\n # Set False for use limited memory\n BATCH = 5000 # After BATCH images, lmdb commits, if read_all_imgs = False\n if mode == 'train_sharp':\n img_folder = '../../datasets/REDS/train_sharp'\n lmdb_save_path = '../../datasets/REDS/train_sharp_wval.lmdb'\n H_dst, W_dst = 720, 1280\n elif mode == 'train_sharp_bicubic':\n img_folder = '../../datasets/REDS/train_sharp_bicubic'\n lmdb_save_path = '../../datasets/REDS/train_sharp_bicubic_wval.lmdb'\n H_dst, W_dst = 180, 320\n elif mode == 'train_blur_bicubic':\n img_folder = '../../datasets/REDS/train_blur_bicubic'\n lmdb_save_path = '../../datasets/REDS/train_blur_bicubic_wval.lmdb'\n H_dst, W_dst = 180, 320\n elif mode == 'train_blur':\n img_folder = '../../datasets/REDS/train_blur'\n lmdb_save_path = '../../datasets/REDS/train_blur_wval.lmdb'\n H_dst, W_dst = 720, 1280\n elif mode == 'train_blur_comp':\n img_folder = '../../datasets/REDS/train_blur_comp'\n lmdb_save_path = '../../datasets/REDS/train_blur_comp_wval.lmdb'\n H_dst, W_dst = 720, 1280\n elif mode == 'train_sharp_flowx4':\n img_folder = '../../datasets/REDS/train_sharp_flowx4'\n lmdb_save_path = '../../datasets/REDS/train_sharp_flowx4.lmdb'\n H_dst, W_dst = 360, 320\n n_thread = 40\n ########################################################\n if not lmdb_save_path.endswith('.lmdb'):\n raise ValueError(\"lmdb_save_path must end with \\'lmdb\\'.\")\n if osp.exists(lmdb_save_path):\n print('Folder [{:s}] already exists. Exit...'.format(lmdb_save_path))\n sys.exit(1)\n\n #### read all the image paths to a list\n print('Reading image path list ...')\n all_img_list = data_util._get_paths_from_images(img_folder)\n keys = []\n for img_path in all_img_list:\n split_rlt = img_path.split('/')\n folder = split_rlt[-2]\n img_name = split_rlt[-1].split('.png')[0]\n keys.append(folder + '_' + img_name)\n\n if read_all_imgs:\n #### read all images to memory (multiprocessing)\n dataset = {} # store all image data. list cannot keep the order, use dict\n print('Read images with multiprocessing, #thread: {} ...'.format(n_thread))\n pbar = util.ProgressBar(len(all_img_list))\n\n def mycallback(arg):\n '''get the image data and update pbar'''\n key = arg[0]\n dataset[key] = arg[1]\n pbar.update('Reading {}'.format(key))\n\n pool = Pool(n_thread)\n for path, key in zip(all_img_list, keys):\n pool.apply_async(read_image_worker, args=(path, key), callback=mycallback)\n pool.close()\n pool.join()\n print('Finish reading {} images.\\nWrite lmdb...'.format(len(all_img_list)))\n\n #### create lmdb environment\n data_size_per_img = cv2.imread(all_img_list[0], cv2.IMREAD_UNCHANGED).nbytes\n print('data size per image is: ', data_size_per_img)\n data_size = data_size_per_img * len(all_img_list)\n env = lmdb.open(lmdb_save_path, map_size=data_size * 10)\n\n #### write data to lmdb\n pbar = util.ProgressBar(len(all_img_list))\n txn = env.begin(write=True)\n for idx, (path, key) in enumerate(zip(all_img_list, keys)):\n pbar.update('Write {}'.format(key))\n key_byte = key.encode('ascii')\n data = dataset[key] if read_all_imgs else cv2.imread(path, cv2.IMREAD_UNCHANGED)\n if 'flow' in mode:\n H, W = data.shape\n assert H == H_dst and W == W_dst, 'different shape.'\n else:\n H, W, C = data.shape\n assert H == H_dst and W == W_dst and C == 3, 'different shape.'\n txn.put(key_byte, data)\n if not read_all_imgs and idx % BATCH == 0:\n txn.commit()\n txn = env.begin(write=True)\n txn.commit()\n env.close()\n print('Finish writing lmdb.')\n\n #### create meta information\n meta_info = {}\n meta_info['name'] = 'REDS_{}_wval'.format(mode)\n channel = 1 if 'flow' in mode else 3\n meta_info['resolution'] = '{}_{}_{}'.format(channel, H_dst, W_dst)\n meta_info['keys'] = keys\n pickle.dump(meta_info, open(osp.join(lmdb_save_path, 'meta_info.pkl'), \"wb\"))\n print('Finish creating lmdb meta info.')","def PPO(parclass):\n class PPO(parclass):\n \"\"\"\n Proximal Policy Optimization algorithm (PPO).\n Requires parent class inherited from A2C.\n Based on: https://arxiv.org/abs/1707.06347\n \n Args:\n ppo_clip - clipping rate of pi_new / pi_old fraction\n epochs - number of epochs to run through rollout on each update\n batch_size - size of mini-batch to select without replacement on each gradient ascent step\n \"\"\"\n __doc__ += parclass.__doc__\n PARAMS = parclass.PARAMS | {\"ppo_clip\", \"epochs\", \"batch_size\"} \n \n def __init__(self, config):\n super().__init__(config)\n \n self.config.setdefault(\"ppo_clip\", 0.2)\n self.config.setdefault(\"epochs\", 3)\n self.config.setdefault(\"batch_size\", 32)\n \n assert self.env.num_envs * self.config.rollout >= self.config.batch_size, \"batch_size is bigger than rollout * number of threads!\"\n \n def optimized_function(self):\n # advantage is estimated using advantage function for previous policy\n # so we take advantage from original rollout\n advantages = (self.returns_b - self.old_values_b).detach() #self.advantages_b.detach() - КОСТЫЛЬ\n \n # importance sampling for making an update of current policy using samples from old policy\n # the gradients to policy will flow through the numerator.\n ratio = torch.exp(self.action_log_probs_b - self.old_action_log_probs_b.detach())\n \n # PPO clipping! Prevents from \"too high updates\".\n surr1 = ratio * advantages\n surr2 = torch.clamp(ratio, 1.0 - self.config.ppo_clip, 1.0 + self.config.ppo_clip) * advantages\n return -torch.min(surr1, surr2)\n \n def update(self):\n \"\"\"One step of optimization based on rollout memory\"\"\"\n with torch.no_grad():\n self.preprocess_rollout()\n \n # DEEP-RL TUTORIALS: КОСТЫЛЬ\n #self.advantages = self.returns[:-1] - self.values[:-1]\n #self.advantages = (self.advantages - self.advantages.mean()) / (self.advantages.std() + 1e-5)\n \n # going through rollout several (config.epochs) times:\n for epoch in range(self.config.epochs):\n # TODO: drop last = False? What if there is 1 sample?\n sampler = BatchSampler(SubsetRandomSampler(range(self.env.num_envs * self.config.rollout)), self.config.batch_size, drop_last=False)\n \n for indices in sampler:\n # retrieving new batch as part of rollout\n self.returns_b = self.returns.view(-1, *self.config.value_repr_shape)[indices]\n self.old_values_b = self.values.view(-1, *self.config.value_repr_shape)[indices]\n self.old_action_log_probs_b = self.action_log_probs.view(-1)[indices]\n #self.advantages_b = self.advantages.view(-1)[indices] # КОСТЫЛЬ\n \n # calculating current value, action_log_prob, entropy\n dist, self.values_b = self.policy(self.observations.view(-1, *self.config.observation_shape)[indices])\n self.values_b = self.values_b.squeeze() # IMPORTANT ([32] - [32, 1] problem)\n self.action_log_probs_b = dist.log_prob(self.actions.view(-1, *self.config.actions_shape)[indices])#.sum(dim=-1) \n self.entropy_b = dist.entropy()#.sum(dim=-1)\n \n # performing step\n self.gradient_ascent_step()\n return PPO","def local_mediation(task):\n\tatlas = 'power'\n\tproject='hcp'\n\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\n\tsubjects = np.load('%s/dynamic_mod/results/%s_%s_%s_subs_fz.npy' %(homedir,'hcp',task,atlas))\n\tstatic_results = graph_metrics(subjects,task,atlas,run_version='fz')\n\tmatrices = static_results['matrices']\n\tsubject_pcs = static_results['subject_pcs']\n\tsubject_wmds = static_results['subject_wmds']\n\tsubject_mods = static_results['subject_mods']\n\tmod_wmd_corr = np.zeros(subject_wmds.shape[1])\n\tfor i in range(subject_pcs.shape[1]):\n\t\tmod_wmd_corr[i] = nan_pearsonr(subject_mods,subject_wmds[:,i])[0]\n\tmean_conn = np.nanmean(matrices,axis=0)\n\te_tresh = np.percentile(mean_conn,85)\n\tsubject_wmds[np.isnan(subject_pcs)] = 0.0\n\tm = np.zeros((264,264,264))\n\tpool = Pool(40)\n\tfor n in range(264):\n\t\tprint n\n\t\tsys.stdout.flush()\n\t\tvariables = []\n\t\tfor i,j in combinations(range(264),2):\n\t\t\tvariables.append(pd.DataFrame(data={'pc':subject_wmds[:,n],'weight':matrices[:,i,j],'q':subject_mods},index=range(len(subject_pcs))))\n\t\tresults = pool.map(multi_med,variables)\n\t\tfor r,i in zip(results,combinations(range(264),2)):\n\t\t\tm[n,i[0],i[1]] = r\n\t\t\tm[n,i[1],i[0]] = r\n\t\tnp.save('/home/despoB/mb3152/dynamic_mod/results/full_med_matrix_new_%s_wmds.npy'%(task),m)","def MR1():\n global CO1_OUTPUT, MR1_OUTPUT\n\n for b in range(MR1_OB):\n for f in range(MR1_OF):\n # Maxpool begins here\n for r in range(MR1_OR):\n for c in range(MR1_OC):\n frame = np.zeros(4)\n frame[0] = CO1_OUTPUT[b][f][r*2 ][c*2 ]\n frame[1] = CO1_OUTPUT[b][f][r*2+1][c*2 ]\n frame[2] = CO1_OUTPUT[b][f][r*2 ][c*2+1]\n frame[3] = CO1_OUTPUT[b][f][r*2+1][c*2+1]\n\n # ReLU begins here\n maximum = 0\n for i in range(4):\n if frame[i] > maximum:\n maximum = frame[i]\n\n MR1_OUTPUT[b][f][r][c] = maximum","def miniAOD_customizeMETFiltersFastSim(process):\n for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter':\n process.globalReplace(X, cms.EDFilter(\"HLTBool\", result=cms.bool(True))) \n for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters':\n process.globalReplace(X, cms.EDFilter(\"HLTBool\", result=cms.bool(False)))\n return process","def _process(self):\n while True:\n with Timer() as data_timer:\n frame = self._frames_q.get()\n\n with Timer() as agent_timer:\n s, frame_metadata = self._unwrap_frame(frame)\n s = np.expand_dims(s, 0) # batch\n act = self.pred(s)[0][0].argmax()\n put_overwrite(self._actions_q, self._wrap_action(act, frame_metadata))\n\n print('.', end='', flush=True)\n if self.verbose:\n print('Avg data wait time: %.3f' % data_timer.time())\n print('Avg agent neural net eval time: %.3f' % agent_timer.time())","def handle_predictions(predict_fn, request_queue, response_queue):\n loop_times = []\n queue_get_times = []\n handle_times = []\n handle_start_times = []\n # trial_start = datetime.now()\n pred_count = 0\n loop_count = 0\n\n # last_loop_start = datetime.now()\n # loop_dur_file = \"/logs/loop_duration.log\"\n # handle_dur_file = \"/logs/handle_duration.log\"\n # handle_dur_file = \"/logs/handle_duration.log\"\n\n # Field order: clock_time, user time, sys time\n # kernel_measures = False\n # if not os.path.exists(\"/logs\"):\n # os.makedirs(\"/logs\")\n #\n # kernel_instr_file = \"/logs/kernel_measures.csv\"\n\n # with open(loop_dur_file, \"w\") as ld, open(handle_dur_file, \"w\") as hd:\n\n # with open(kernel_instr_file, \"w\") as kd:\n # kd.write(\"wall_clock_secs, user_clock_ticks, kernel_clock_ticks\\n\")\n while True:\n # cur_loop_start = datetime.now()\n # loop_duration = (cur_loop_start - last_loop_start).microseconds\n # loop_times.append(loop_duration)\n # ld.write(\"{}\\n\".format(loop_duration))\n # last_loop_start = cur_loop_start\n\n # t1 = datetime.now()\n prediction_request, recv_time = request_queue.get(block=True)\n # t2 = datetime.now()\n # queue_get_times.append((t2 - t1).microseconds)\n\n # handle_start_times.append(time.time()*1000)\n before_predict_lineage_point = datetime.now()\n # proc_stat_before = check_output([\"cat\", \"/proc/1/stat\"]).strip().split()\n # user_before = int(proc_stat_before[13])\n # sys_before = int(proc_stat_before[14])\n\n\n outputs = predict_fn(prediction_request.inputs)\n # proc_stat_after = check_output([\"cat\", \"/proc/1/stat\"]).strip().split()\n # user_after = int(proc_stat_after[13])\n # sys_after = int(proc_stat_after[14])\n\n after_predict_lineage_point = datetime.now()\n # clock_time = (after_predict_lineage_point - before_predict_lineage_point).total_seconds()\n # user_time = user_after - user_before\n # sys_time = sys_after - sys_before\n # user_time = 0\n # sys_time = 0\n # kd.write(\"{clock},{user},{kernel}\\n\".format(clock=clock_time, user=user_time, kernel=sys_time))\n\n if loop_count <= 50 and loop_count % 10 == 0:\n print((after_predict_lineage_point - before_predict_lineage_point).total_seconds())\n\n pred_count += len(prediction_request.inputs)\n # t3 = datetime.now()\n # handle_times.append((t3 - t2).microseconds)\n # hd.write(\"{}\\n\".format((t3 - t2).microseconds))\n # Type check the outputs:\n if not type(outputs) == list:\n raise PredictionError(\"Model did not return a list\")\n if len(outputs) != len(prediction_request.inputs):\n raise PredictionError(\n \"Expected model to return %d outputs, found %d outputs\" %\n (len(prediction_request.inputs), len(outputs)))\n\n outputs_type = type(outputs[0])\n if outputs_type == np.ndarray:\n outputs_type = outputs[0].dtype\n if outputs_type not in SUPPORTED_OUTPUT_TYPES_MAPPING.keys():\n raise PredictionError(\n \"Model outputs list contains outputs of invalid type: {}!\".\n format(outputs_type))\n\n if outputs_type == str:\n for i in range(0, len(outputs)):\n outputs[i] = unicode(outputs[i], \"utf-8\").encode(\"utf-8\")\n else:\n for i in range(0, len(outputs)):\n outputs[i] = outputs[i].tobytes()\n\n total_length_elements = sum(len(o) for o in outputs)\n\n response = PredictionResponse(prediction_request.msg_id,\n len(outputs), total_length_elements,\n outputs_type)\n for output in outputs:\n response.add_output(output)\n\n response_queue.put((response, recv_time,\n before_predict_lineage_point,\n after_predict_lineage_point))\n # response_queue.put((response, recv_time,\n # None,\n # None))\n\n # if len(loop_times) > 1000:\n # print(\"\\nLoop duration: {} +- {}\".format(np.mean(loop_times), np.std(loop_times)))\n # print(\"Request dequeue duration: {} +- {}\".format(np.mean(queue_get_times), np.std(queue_get_times)))\n # print(\"Handle duration: {} +- {}\".format(np.mean(handle_times), np.std(handle_times)))\n # # throughput = float(pred_count) / (datetime.now() - trial_start).total_seconds()\n # # print(\"Throughput: {}\".format(throughput))\n # # ld.flush()\n # # hd.flush()\n # # kd.flush()\n #\n # loop_times = []\n # queue_get_times = []\n # handle_times = []\n # pred_count = 0\n # trial_start = datetime.now()\n\n # if len(handle_start_times) % 200 == 0:\n # print(json.dumps(handle_start_times))\n loop_count += 1\n sys.stdout.flush()\n sys.stderr.flush()","def preprocess(generator):\n\n def preprocess_decorator(method):\n\n @wrapper(method)\n def preprocess_wrapper(self, *args, **kwargs):\n self.increment_pc()\n pc = tuple(self.program_counter)\n try:\n return self._pool.pop(pc), True\n except KeyError:\n key = (generator, args)\n pcs = self._needed_data.setdefault(key, [])\n pcs.append(pc)\n self.fork_pc()\n try:\n return method(self, *args, **kwargs), False\n finally:\n self.unfork_pc()\n\n return preprocess_wrapper\n return preprocess_decorator","def with_cpu(ops, model):\n ...","def minimize(self):\n pass","def compute(self,n_speed,s_speed,msize,thershold):\n X=self.image\n for layer in self.CNN:\n #layer dictonary {type,kernel,bias,hparams}\n #offloading decisions\n kernel=layer[\"kernel\"]\n hparam=layer[\"hparams\"]\n if layer[l_type]==\"conv\":\n off_dec=offload(n_speed,s_speed,msize,X,kernel,hparam)\n if(off_dec.checkOffload(thershold)):\n #get the result form the server\n conv_dict={ \"data\":X,\"l_type\":layer[l_type],\"hpara\":hparam,\"pos\":0}\n c=client(conv_dict,self.edge[\"ip\"],self.edge[\"port\"])\n c.send()\n X=c.receive_array()\n \n else:\n X=self.thread_Compute(X,layer)\n\n else:\n X=self.thread_Compute(X,layer)","def __init__(self, envs0, envs1, acmodel0, acmodel1, num_frames_per_proc, discount, lr, gae_lambda, entropy_coef,\n value_loss_coef, max_grad_norm, recurrence, preprocess_obss, reshape_reward, aux_info):\n # Store parameters\n\n self.env0 = ParallelEnv(envs0)\n self.acmodel0 = acmodel0\n self.acmodel0.train()\n \n self.env1 = ParallelEnv(envs1)\n self.acmodel1 = acmodel1\n self.acmodel1.train()\n \n self.num_frames_per_proc = num_frames_per_proc\n self.discount = discount\n self.lr = lr\n self.gae_lambda = gae_lambda\n self.entropy_coef = entropy_coef\n self.value_loss_coef = value_loss_coef\n self.max_grad_norm = max_grad_norm\n self.recurrence = recurrence\n self.preprocess_obss = preprocess_obss or default_preprocess_obss\n self.reshape_reward = reshape_reward\n self.aux_info = aux_info\n\n # Store helpers values\n\n self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n self.num_procs = len(envs0)\n self.num_frames = self.num_frames_per_proc * self.num_procs\n\n\n assert self.num_frames_per_proc % self.recurrence == 0\n\n # Initialize experience values\n\n shape = (self.num_frames_per_proc, self.num_procs)\n\n self.obs0 = self.env0.reset()\n self.obss0 = [None]*(shape[0])\n \n self.obs1 = self.env1.reset()\n self.obss1 = [None]*(shape[0])\n\n self.memory0 = torch.zeros(shape[1], self.acmodel0.memory_size, device=self.device)\n self.memories0 = torch.zeros(*shape, self.acmodel0.memory_size, device=self.device)\n \n self.memory1 = torch.zeros(shape[1], self.acmodel1.memory_size, device=self.device)\n self.memories1 = torch.zeros(*shape, self.acmodel1.memory_size, device=self.device)\n \n self.msg0 = torch.zeros( self.acmodel0.max_len_msg, shape[1], self.acmodel0.num_symbols, device=self.device)\n self.msgs0 = torch.zeros(shape[0], self.acmodel0.max_len_msg, shape[1], self.acmodel0.num_symbols, device=self.device)\n \n self.msg1 = torch.zeros( self.acmodel1.max_len_msg, shape[1], self.acmodel1.num_symbols, device=self.device)\n self.msgs1 = torch.zeros(shape[0], self.acmodel1.max_len_msg, shape[1], self.acmodel1.num_symbols, device=self.device)\n \n self.msgs_out0 = torch.zeros(shape[0], self.acmodel0.max_len_msg, shape[1], self.acmodel0.num_symbols, device=self.device)\n \n self.msgs_out1 = torch.zeros(shape[0], self.acmodel1.max_len_msg, shape[1], self.acmodel1.num_symbols, device=self.device)\n\n #self.rng_states0 = torch.zeros(*shape, *torch.get_rng_state().shape, dtype=torch.uint8)\n #if torch.cuda.is_available():\n # self.cuda_rng_states0 = torch.zeros(*shape, *torch.cuda.get_rng_state().shape, dtype=torch.uint8)\n \n #self.rng_states1 = torch.zeros(*shape, *torch.get_rng_state().shape, dtype=torch.uint8)\n #if torch.cuda.is_available():\n # self.cuda_rng_states1 = torch.zeros(*shape, *torch.cuda.get_rng_state().shape, dtype=torch.uint8)\n \n self.mask0 = torch.ones(shape[1], device=self.device)\n self.masks0 = torch.zeros(*shape, device=self.device)\n self.actions0 = torch.zeros(*shape, device=self.device, dtype=torch.int)\n self.values0 = torch.zeros(*shape, device=self.device)\n self.rewards0 = torch.zeros(*shape, device=self.device)\n self.advantages0 = torch.zeros(*shape, device=self.device)\n self.log_probs0 = torch.zeros(*shape, device=self.device)\n self.speaker_log_probs0 = torch.zeros(*shape, device=self.device)\n \n self.mask1 = torch.ones(shape[1], device=self.device)\n self.masks1 = torch.zeros(*shape, device=self.device)\n self.actions1 = torch.zeros(*shape, device=self.device, dtype=torch.int)\n self.values1 = torch.zeros(*shape, device=self.device)\n self.rewards1 = torch.zeros(*shape, device=self.device)\n self.advantages1 = torch.zeros(*shape, device=self.device)\n self.log_probs1 = torch.zeros(*shape, device=self.device)\n self.speaker_log_probs1 = torch.zeros(*shape, device=self.device)\n\n if self.aux_info:\n self.aux_info_collector0 = ExtraInfoCollector(self.aux_info, shape, self.device)\n self.aux_info_collector1 = ExtraInfoCollector(self.aux_info, shape, self.device)\n\n # Initialize log values\n\n self.log_episode_return0 = torch.zeros(self.num_procs, device=self.device)\n self.log_episode_reshaped_return0 = torch.zeros(self.num_procs, device=self.device)\n \n self.log_episode_return1 = torch.zeros(self.num_procs, device=self.device)\n self.log_episode_reshaped_return1 = torch.zeros(self.num_procs, device=self.device)\n \n self.log_episode_num_frames0 = torch.zeros(self.num_procs, device=self.device)\n self.log_episode_num_frames1 = torch.zeros(self.num_procs, device=self.device)\n\n self.log_done_counter0 = 0\n self.log_return0 = [0] * self.num_procs\n self.log_reshaped_return0 = [0] * self.num_procs\n self.log_num_frames0 = [0] * self.num_procs\n \n self.log_done_counter1 = 0\n self.log_return1 = [0] * self.num_procs\n self.log_reshaped_return1 = [0] * self.num_procs\n self.log_num_frames1 = [0] * self.num_procs\n \n self.been_done0 = torch.zeros(self.num_procs, device=self.device)\n self.been_done1 = torch.zeros(self.num_procs, device=self.device)","def optimizermt(self,server_,port_): # 3\n res,resargs = self.__obj.optimizermt(server_,port_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n _trmcode_return_value = resargs\n _trmcode_return_value = rescode(_trmcode_return_value)\n return _trmcode_return_value","def opt_wrapper(m, **kwargs):\r\n m.optimize(**kwargs)\r\n return m.optimization_runs[-1]","def task_process(args):\n if args.mode == 'change model':\n for i in range(config.center_len):\n h, w = config.center_list[i][0], config.center_list[i][1]\n os.system('rm -rf ctpn_change_{}x{}.onnx'.format(h, w))\n for i in range(config.center_len):\n h, w = config.center_list[i][0], config.center_list[i][1]\n os.system('{} change_model.py --input_path={}/ctpn_{}x{}.onnx --output_path={}/ctpn_change_{}x{}.onnx' \\\n .format(args.interpreter, args.src_dir, h, w,args.res_dir, h, w)) \n if args.mode == 'preprocess':\n for i in range(config.center_len):\n os.system('mkdir -p {}_{}x{}'.format(args.res_dir, config.center_list[i][0], config.center_list[i][1]))\n os.system('{} ctpn_preprocess.py --src_dir={} --save_path={}' \\\n .format(args.interpreter, args.src_dir, args.res_dir))\n if args.mode == 'ais_infer':\n fps_all = 0\n os.system('mkdir -p {}/inf_output'.format(args.res_dir))\n for i in range(config.center_len):\n h, w = config.center_list[i][0], config.center_list[i][1]\n\n os.system('{} --model={} --input={}_{}x{} --dymHW {},{} --device {} --batchsize={} --output={}/inf_output' \\\n .format(args.interpreter, args.om_path, args.src_dir ,h , w, h, w,args.device, args.batch_size, args.res_dir))\n\n sumary_path = glob.glob('{}/inf_output/*ary.json'.format(args.res_dir))[0]\n with open(sumary_path, 'r') as f:\n output = json.load(f)\n throughput = output['throughput'] \n fps_all = fps_all + throughput * config.center_count[i]\n os.system('rm -f {}'.format(sumary_path))\n os.system('mv {}/inf_output/*/*.bin {}'.format(args.res_dir, args.res_dir))\n os.system('rm {}/inf_output -rf'.format(args.res_dir))\n fps_all = fps_all / config.imgs_len\n print(\"====performance data====\")\n print('CTPN bs{} models fps:{}'.format(args.batch_size, fps_all))","def multi_run_wrapper(args):\n\treturn img_preprocessing(*args)","def _remove_receptors_helper(self, argin):\n receptor_to_vcc = dict([*map(int, pair.split(\":\"))] for pair in\n self._proxy_cbf_controller.receptorToVcc)\n for receptorID in argin:\n if receptorID in self._receptors:\n vccID = receptor_to_vcc[receptorID]\n vccProxy = self._proxies_vcc[vccID - 1]\n\n # unsubscribe from events\n vccProxy.unsubscribe_event(self._events_state_change_vcc[vccID][0]) # state\n vccProxy.unsubscribe_event(self._events_state_change_vcc[vccID][1]) # healthState\n del self._events_state_change_vcc[vccID]\n del self._vcc_state[self._fqdn_vcc[vccID - 1]]\n del self._vcc_health_state[self._fqdn_vcc[vccID - 1]]\n\n # reset receptorID and subarrayMembership Vcc attribute:\n vccProxy.receptorID = 0\n vccProxy.subarrayMembership = 0\n\n self._receptors.remove(receptorID)\n self._proxies_assigned_vcc.remove(vccProxy)\n self._group_vcc.remove(self._fqdn_vcc[vccID - 1])\n else:\n log_msg = \"Receptor {} not assigned to subarray. Skipping.\".format(str(receptorID))\n self.logger.warn(log_msg)\n\n # transitions to EMPTY if not assigned any receptors\n if not self._receptors:\n self._update_obs_state(ObsState.EMPTY)","def replay(i):\n\n i['module_uoa']=cfg['module_deps']['program.optimization']\n i['module_ref_uoa']=work['self_module_uid']\n i['module_cfg']=copy.deepcopy(cfg)\n i['module_work']=copy.deepcopy(work)\n return ck.access(i)","def __init__process(self, n_cpu):\n global shared_slices\n global shared_data\n\n shared_slices_base = sharedctypes.RawArray(ctypes.c_double,\n self._projection.shape[0])\n shared_slices = np.frombuffer(shared_slices_base)\n shared_slices = shared_slices.reshape((len(self._q.R), -1))\n\n shared_grad_base = sharedctypes.RawArray(ctypes.c_double,\n self._projection.shape[0])\n shared_grad = np.frombuffer(shared_grad_base)\n shared_grad = shared_grad.reshape((len(self._q.R), -1))\n\n shared_data_base = mp.Array(ctypes.c_double,\n self._data.size,\n lock=False)\n shared_data = np.ctypeslib.as_array(shared_data_base)\n shared_data = shared_data.reshape(self._data.shape)\n shared_data[:] = self._data\n\n self._pool = mp.Pool(n_cpu)","def opt_wrapper(m, **kwargs):\n m.optimize(**kwargs)\n return m.optimization_runs[-1]","def _apply_individual_nbody1_accumulate_python(\n coeff: 'Nparray', ocoeff: 'Nparray', icoeff: 'Nparray',\n amap: 'Nparray', btarget: 'Nparray', bsource: 'Nparray',\n bparity: 'Nparray') -> None:\n for sourcea, targeta, paritya in amap:\n ocoeff[targeta, btarget] += coeff * paritya * numpy.multiply(\n icoeff[sourcea, bsource], bparity)","def vectorize(func, processes=1, on_complete=None):\n if processes > 1:\n return __multiprocess_wrapper(func, processes, on_complete)\n else:\n return single_process_wrapper(func, on_complete)","def run(self, C, p0 = None):\n global algorithm \n algorithm = AdaptiveMM(self.g, C, p0 = p0, lambda0 = 2000)\n solve()","def processor2(readq, baseq, bamrcPath, ref_fasta, tumor_bam, bedfile, bedHeader, varList, annoList, ncpu):\n\n #create the region file for the first set of filtered variants\n # use annovar's list because it already provides adjusted first and last positions of indels\n \n tfile = open('bamrc.region', 'w')\n tvc_maf = []; tvc_depth = []\n for el in annoList:\n tfile.write('\\t'.join(el.split('\\t')[:5])+'\\n')\n \n \n # store the TVC-reported MAF and depth for the variant in the T\n # this will be used for those TVC variants that don't match with bam-readcount\n for el in varList:\n tvc_maf.append(float(el.split('\\t')[9])) \n tvc_depth.append(int(el.split('\\t')[10]))\n \n tfile.close()\n\n\n # get the expected length of reads supporting the variant\n old_exprlenFile = '_tmp_/expected_readlen.txt'\n if not os.path.exists(old_exprlenFile):\n print \" Calculating estimated read length around the variant positions...\"\n exp_readlen = expected_readlen(bedfile, bedHeader, annoList)\n else:\n print \" Expected read lengths already have been calculated, delete the old file _tmp_/expected_readlen.txt to recompute\"\n with open(old_exprlenFile,'r') as rf:\n exp_readlen = [float(line.strip()) for line in rf] \n\n\n # run bam-readcount on the tumor bam file using the region file\n oldbamrc_outfile = '_tmp_/bamrc.out'\n \n if not os.path.exists(oldbamrc_outfile):\n execute_multiprocess(bamrcPath,'bamrc.region',tumor_bam,ref_fasta,ncpu)\n \n #command = '%s -q %s -b %s -d 2000 -l bamrc.region -f %s %s\\\n # > bamrc.out 2>/dev/null' %(bamreadcount, readq, baseq, ref_fasta, tumor_bam)\n #os.system(command)\n \n bamrc_outfile = 'bamrc.out'\n else:\n print \" bamrc has already been run, delete the bamrc.out file to rerun\"\n bamrc_outfile = oldbamrc_outfile\n\n\n ref = []; alt = []; fields = []; diff_q = []; diff_mmqs = []; diff_readlen = []; diffpos = []; altpos = []; dist3p = []; \n alt_readlen_ = []; diff_expec_readlen = []; alt_depth = []; depth = []; alt_maf = []\n\n bases = ['A', 'C', 'G', 'T']\n\n with open('bamrc.region', 'r') as region:\n ref = [line.split('\\t')[3] for line in region]\n with open('bamrc.region', 'r') as region:\n alt = [line.split('\\t')[4].strip('\\n')for line in region]\n with open('bamrc.region', 'r') as region:\n start = [line.split('\\t')[1] for line in region]\n\n # get the info from bam-readcount output % store as list\n with open(bamrc_outfile, 'r') as bamread:\n for line in bamread:\n fields.append(line)\n\n #store the positions for all lines in bamrc out\n bamrcpos = [int(line.split('\\t')[1]) for line in fields]\n\n\n # if a variant position is very close to the amplicon edge, bam-readcount\n # will not return any values, identify these variants; these should be potential\n # FPs anyways\n\n missidx= []\n with open('bamrc.region', 'r') as region:\n idlist1 = ['_'.join(line.split('\\t')[:2]) for line in region]\n with open(bamrc_outfile, 'r') as bamread:\n idlist2 = ['_'.join(line.split('\\t')[:2]) for line in bamread]\n\n missingvars = list(set(idlist1) - set(idlist2))\n missidx = [idlist1.index(var) for var in missingvars]\n\n #------------ the main loop -----------\n\n # extract the relevant metrics from bam-readcount file and\n # append those into the existing info for the stage-1 filtered variants \n\n #------------ the main loop -----------\n\n linecount = 0 # counter for keeping track of variant's start position in bam-readcount output\n\n for idx in range(len(ref)):\n #print idx,linecount \n #--------- if amplicon-edge variants------------ \n # set the metrics values to ridiculously high/low values so these \n # will be filtered out later\n\n if idx in missidx:\n diff_q.append('1000')\n diff_mmqs.append('1000')\n diff_readlen.append('1000')\n altpos.append('0')\n diffpos.append('1')\n dist3p.append('1')\n alt_readlen_.append('0')\n alt_depth.append('0')\n depth.append('1')\n alt_maf.append('0')\n diff_expec_readlen.append('100') \n\n \n #-------------------------------------------------------\n #------------------first deal with snps-----------------\n #-------------------------------------------------------\n\n elif len(ref[idx]) == 1 and len(alt[idx]) == 1 and\\\n ref[idx] != '-' and alt[idx] != '-':\n depth.append(int(fields[linecount].split('\\t')[3]))\n\n for ib, base in enumerate(bases):\n if ref[idx] == base:\n stats = fields[linecount].split('\\t')[ib+5] # 6-9 columns are for A,C,G,T\n ref_q = float(stats.split(':')[2])\n ref_mmqs = float(stats.split(':')[9])\n ref_readlen = float(stats.split(':')[-2])\n refpos = float(stats.split(':')[7])\n if alt[idx] == base:\n stats = fields[linecount].split('\\t')[ib+5]\n alt_q = float(stats.split(':')[2])\n altpos.append(float(stats.split(':')[7]))\n alt_mmqs = float(stats.split(':')[9])\n alt_readlen = float(stats.split(':')[-2])\n dist3p.append(float(stats.split(':')[-1]))\n alt_depth.append(int(stats.split(':')[1]))\n \n diff_q.append(ref_q - alt_q)\n diff_mmqs.append(alt_mmqs - ref_mmqs)\n diff_readlen.append(ref_readlen - alt_readlen)\n diffpos.append(refpos - altpos[idx])\n alt_readlen_.append(alt_readlen)\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-alt_readlen))\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-ref_readlen))\n \n if int(depth[idx])>0:\n alt_maf.append('%5.4f' %(alt_depth[idx]/depth[idx]))\n else:\n alt_maf.append('0.0')\n\n\n #update the line no. to match the start of next variant in the bam-readcount output \n linecount += 1\n \n\n #-------------------------------------------------------\n #--------------Multi Nucleotide Substitutions-----------\n #-------------------------------------------------------\n \n elif len(ref[idx]) > 1 and (len(ref[idx]) == len(alt[idx])):\n refb = list(ref[idx]) # ref. bases spanning\n altb = list(alt[idx]) # alt. bases spanning\n runlen = len(ref[idx]) # length of MNPs\n\n tot = len(fields[linecount].split('\\t')) #total tab-seprated fields\n \n depth_i = []; ref_q_i = []; ref_mmqs_i = []; ref_readlen_i = []; refpos_i = []\n alt_q_i = []; alt_mmqs_i = []; alt_readlen_i = []; altpos_i = []; dist3p_i = []; alt_depth_i = []\n npos = 0\n\n for jj in range(linecount,linecount+runlen):\n npos += 1\n #only get the stats for positions that are mismatches\n if refb[npos-1] != altb[npos-1]:\n depth_i.append(int(fields[jj].split('\\t')[3]))\n for ib, base in enumerate(bases):\n if refb[npos-1] == base:\n stats = fields[jj].split('\\t')[ib+5]\n ref_q_i.append(float(stats.split(':')[2]))\n ref_mmqs_i.append(float(stats.split(':')[9]))\n ref_readlen_i.append(float(stats.split(':')[-2]))\n refpos_i.append(float(stats.split(':')[7]))\n if altb[npos-1] == base: \n stats = fields[jj].split('\\t')[ib+5]\n alt_q_i.append(float(stats.split(':')[2]))\n altpos_i.append(float(stats.split(':')[7]))\n alt_mmqs_i.append(float(stats.split(':')[9]))\n alt_readlen_i.append(float(stats.split(':')[-2]))\n dist3p_i.append(float(stats.split(':')[-1]))\n alt_depth_i.append(int(stats.split(':')[1]))\n \n depth.append(int(np.mean(depth_i)))\n diff_q.append('%6.2f' %(np.mean(ref_q_i)-np.mean(alt_q_i)))\n diff_mmqs.append('%6.2f' %(np.mean(alt_mmqs_i)-np.mean(ref_mmqs_i)))\n diff_readlen.append('%6.2f' %(np.mean(ref_readlen_i) - np.mean(alt_readlen_i)))\n altpos.append('%3.2f' %np.mean(altpos_i))\n dist3p.append('%3.2f' %np.mean(dist3p_i))\n diffpos.append('%3.2f' %(np.mean(refpos_i) - np.mean(altpos_i)))\n alt_readlen_.append(np.mean(alt_readlen_i))\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-np.mean(alt_readlen_i)))\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\n alt_depth.append(int(np.mean(alt_depth_i)))\n\n if int(depth[idx])>0:\n alt_maf.append('%5.4f' %(alt_depth[idx]/depth[idx]))\n else:\n alt_maf.append('0.0')\n\n linecount += runlen \n \n\n\n #-------------------------------------------------------\n #--------------- Insertions and substitution------------\n #-------------------------------------------------------\n \n elif ref[idx] == '-' or \\\n (len(alt[idx])-len(ref[idx])>0 and ref[idx] != '-'):\n\n runlen = len(ref[idx]) # length of the actual region \n \n # get the reference base/bases spanning these positions\n if ref[idx] != '-':\n refb = list(ref[idx]) \n else:\n refb = [fields[linecount].split('\\t')[2]]\n \n ref_q_i = []; ref_mmqs_i = []; ref_readlen_i = []; refpos_i = []\n npos = 0\n\n for jj in range(linecount,linecount+runlen):\n npos += 1\n \n for ib, base in enumerate(bases):\n if refb[npos-1] == base:\n stats = fields[jj].split('\\t')[ib+5].strip('\\n')\n ref_q_i.append(float(stats.split(':')[2]))\n ref_mmqs_i.append(float(stats.split(':')[9]))\n ref_readlen_i.append(float(stats.split(':')[-2]))\n refpos_i.append(float(stats.split(':')[7]))\n \n # stats for insertion reads\n depth.append(int(fields[linecount].split('\\t')[3]))\n tot = len(fields[linecount].split('\\t')) #total tab-seprated fields\n\n # get readcounts for all insertions at this position\n # the insertions will be 11th & subsequent fields\n counts = [int(fields[linecount].split('\\t')[j].split(':')[1]) for j in range(10,tot)]\n \n if len(counts) > 0:\n # index of the most abundant insertion\n ib = counts.index(max(counts)) + 10\n \n isnstats = fields[linecount].split('\\t')[ib].strip('\\n')\n alt_q = float(isnstats.split(':')[2])\n altpos.append(float(isnstats.split(':')[7]))\n alt_mmqs = float(isnstats.split(':')[9])\n alt_readlen = float(isnstats.split(':')[-2])\n dist3p.append(float(isnstats.split(':')[-1]))\n alt_depth.append(int(isnstats.split(':')[1]))\n \n diff_q.append('%6.2f' %(np.mean(ref_q_i) - alt_q))\n diff_mmqs.append('%6.2f' %(alt_mmqs - np.mean(ref_mmqs_i)))\n diffpos.append('%3.2f' %(np.mean(refpos_i) - altpos[idx]))\n diff_readlen.append('%6.2f' %(np.mean(ref_readlen_i) - alt_readlen))\n alt_readlen_.append(alt_readlen)\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx]) - alt_readlen))\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\n\n #for insertion total depth will be total depth + insertion depth\n depth[idx] = depth[idx] + alt_depth[idx]\n if int(depth[idx])>0:\n alt_maf.append('%5.4f' %(alt_depth[idx]/depth[idx]))\n else:\n alt_maf.append('0.0')\n\n else:\n ###determine the most abundant variant allele when no insertion is detected by bamrc\n allelefields = fields[linecount].strip().split('\\t')[5:]\n #index of the reference base at the 1st insertion position\n refidx = [el.split(':')[0] for el in allelefields].index(refb[0])\n\n ref_q = float(allelefields[refidx].split(':')[2])\n ref_mmqs = float(allelefields[refidx].split(':')[9])\n ref_readlen = float(allelefields[refidx].split(':')[-2])\n ref_pos = float(allelefields[refidx].split(':')[7])\n\n #remove ref. fields\n allelefields.pop(refidx)\n #max depth of non-reference alleles\n maxdepth = max([int(el.split(':')[1]) for el in allelefields])\n if int(maxdepth) > 0:\n #variant allele (SNP) detected at this position\n maxalleleidx = [int(el.split(':')[1]) for el in allelefields].index(maxdepth)\n\n alt_depth.append(int(allelefields[maxalleleidx].split(':')[1]))\n alt_q = float(allelefields[maxalleleidx].split(':')[2])\n alt_mmqs = float(allelefields[maxalleleidx].split(':')[9])\n alt_readlen = float(allelefields[maxalleleidx].split(':')[-2])\n altpos.append(float(allelefields[maxalleleidx].split(':')[7]))\n dist3p.append(float(allelefields[maxalleleidx].split(':')[-1]))\n\n #alt_q_all.append(alt_q)\n diff_q.append('%6.2f' %(ref_q - alt_q))\n diff_mmqs.append('%6.2f' %(alt_mmqs - ref_mmqs))\n diffpos.append('%3.2f' %(ref_pos - altpos[idx]))\n diff_readlen.append('%6.2f' %(ref_readlen - alt_readlen))\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-alt_readlen))\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-ref_readlen))\n else:\n #no variant allele (SNP) detected at this position; set the metrics to '.'\n altpos.append('.')\n alt_depth.append('0')\n diff_q.append('.')\n diff_mmqs.append('.')\n diff_readlen.append('.')\n diffpos.append('.')\n dist3p.append('.')\n diff_expec_readlen.append('.')\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\n \n if int(depth[idx])>0:\n alt_maf.append('%5.4f' %(int(alt_depth[idx])/depth[idx]))\n else: \n alt_maf.append('0.0')\n \n linecount += runlen\n \n \n #-------------------------------------------------------\n #-----------------------Deletions------------------------\n #--------------------------------------------------------\n elif (alt[idx] == '-') or \\\n (len(ref[idx]) > len(alt[idx]) and alt[idx] != '-'):\n\n runlen = len(ref[idx]) # length of the actual region\n\n #check if bamrc outputs QC for all positions, if not, correct for that\n # this happens for really long positions where TVC reports deletion\n templen = []\n for k, g in groupby(enumerate(bamrcpos[linecount:linecount+runlen]), lambda (i,x):i-x):\n group = map(itemgetter(1), g)\n templen.append(len(group))\n\n #length of bps where bamrc computes metrics\n bamrc_runlen = templen[0]\n\n if runlen == bamrc_runlen:\n refb = list(ref[idx]) # reference bases spanning these positions\n elif runlen > bamrc_runlen:\n refb = list(ref[idx])[:bamrc_runlen] # reference bases spanning these positions\n\n runlen = bamrc_runlen\n\n ref_q_i = []; ref_mmqs_i = []; ref_readlen_i = []; refpos_i = []\n npos = 0\n\n for jj in range(linecount,linecount+runlen):\n npos += 1\n \n for ib, base in enumerate(bases):\n if refb[npos-1] == base:\n stats = fields[jj].split('\\t')[ib+5].strip('\\n')\n ref_q_i.append(float(stats.split(':')[2]))\n ref_mmqs_i.append(float(stats.split(':')[9]))\n ref_readlen_i.append(float(stats.split(':')[-2]))\n refpos_i.append(float(stats.split(':')[7]))\n \n # stats for deletion reads\n depth.append(int(fields[linecount].split('\\t')[3]))\n tot = len(fields[linecount].split('\\t')) #total tab-seprated fields\n \n # get readcounts for all deletions at the first position\n counts = [int(fields[linecount].split('\\t')[j].split(':')[1]) for j in range(10,tot)]\n \n if len(counts) >0:\n # index of the most abundant deletion\n ib = counts.index(max(counts)) + 10\n \n delstats = fields[linecount].split('\\t')[ib].strip('\\n')\n alt_q = float(delstats.split(':')[2])\n altpos.append(float(delstats.split(':')[7]))\n alt_mmqs = float(delstats.split(':')[9])\n alt_readlen = float(delstats.split(':')[-2])\n dist3p.append(float(delstats.split(':')[-1]))\n alt_depth.append(int(delstats.split(':')[1]))\n\n diff_q.append('%6.2f' %(np.mean(ref_q_i) - alt_q))\n diff_mmqs.append('%6.2f' %(alt_mmqs - np.mean(ref_mmqs_i)))\n diffpos.append('%3.2f' %(np.mean(refpos_i) - altpos[idx]))\n diff_readlen.append('%6.2f' %(np.mean(ref_readlen_i) - alt_readlen))\n alt_readlen_.append(alt_readlen)\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-alt_readlen))\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\n \n if int(depth[idx])>0:\n alt_maf.append('%5.4f' %(alt_depth[idx]/depth[idx]))\n else:\n alt_maf.append('0.0')\n\n else:\n ###determine the most abundant variant allele when no deletion is detected by bamrc\n allelefields = fields[linecount].strip().split('\\t')[5:]\n #index of the reference base at the 1st deletion position\n refidx = [el.split(':')[0] for el in allelefields].index(refb[0])\n\n ref_q = float(allelefields[refidx].split(':')[2])\n ref_mmqs = float(allelefields[refidx].split(':')[9])\n ref_readlen = float(allelefields[refidx].split(':')[-2])\n ref_pos = float(allelefields[refidx].split(':')[7])\n\n #remove ref. fields\n allelefields.pop(refidx)\n #max depth of non-reference alleles\n maxdepth = max([int(el.split(':')[1]) for el in allelefields])\n if int(maxdepth) > 0:\n #variant allele (SNP) detected at this position\n maxalleleidx = [int(el.split(':')[1]) for el in allelefields].index(maxdepth)\n\n alt_depth.append(int(allelefields[maxalleleidx].split(':')[1]))\n alt_q = float(allelefields[maxalleleidx].split(':')[2])\n alt_mmqs = float(allelefields[maxalleleidx].split(':')[9])\n alt_readlen = float(allelefields[maxalleleidx].split(':')[-2])\n altpos.append(float(allelefields[maxalleleidx].split(':')[7]))\n dist3p.append(float(allelefields[maxalleleidx].split(':')[-1]))\n\n #alt_q_all.append(alt_q)\n diff_q.append('%6.2f' %(ref_q - alt_q))\n diff_mmqs.append('%6.2f' %(alt_mmqs - ref_mmqs))\n diffpos.append('%3.2f' %(ref_pos - altpos[idx]))\n diff_readlen.append('%6.2f' %(ref_readlen - alt_readlen))\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-alt_readlen))\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-ref_readlen))\n\n else:\n #no variant allele (SNP) detected at this position; set the metrics to '.'\n altpos.append('.')\n alt_depth.append('0')\n diff_q.append('.')\n diff_mmqs.append('.')\n diff_readlen.append('.')\n diffpos.append('.')\n dist3p.append('.')\n diff_expec_readlen.append('.')\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\n \n if int(depth[idx])>0:\n alt_maf.append('%5.4f' %(int(alt_depth[idx])/depth[idx]))\n else: \n alt_maf.append('0.0')\n \n linecount += runlen\n \n #clean up temp files\n #os.remove('temp.out')\n #os.remove('temp.region')\n \n return diff_q, diff_mmqs, diff_readlen, altpos, diffpos, dist3p, alt_readlen_, diff_expec_readlen ,alt_maf, alt_depth,depth","def optimize_parameters(self):\n pass","def optimize_parameters(self):\n pass","def optimize_parameters(self):\n pass","def main(self):\n lines=open(self.expttxt,'r').readlines()\n if self.parall:\n pool=Pool(self.prod)\n pool.map(self.mutatraj,lines)\n pool.close()\n pool.join()\n else:\n for line in lines:\n self.mutatraj(line)","def _pre_process_for_reg_model(\n self, context: np.ndarray, action: np.ndarray, action_context: np.ndarray,\n ) -> np.ndarray:\n return np.c_[context, action_context[action]]","def _pre_process_for_reg_model(\n self, context: np.ndarray, action: np.ndarray, action_context: np.ndarray,\n ) -> np.ndarray:\n return np.c_[context, action_context[action]]","def compute_batch(self, duplicate_manager=None,context_manager=None):\n x = self.acquisition.optimize(duplicate_manager=duplicate_manager)[0]\n return x","def __init__(self, optimizer):\n super(ShardedOptimizer, self).__init__(optimizer, name=\"ShardedOptimizer\")","def optimize(self):\n self.vbe_step()\n self.compute_responsibilities()\n self.compute_sufficient_stats()\n self.vbmstep()","def run_local_optimizer(self, local_optimizer_method,\n use_input_initial_poses=False, respawn_when_counterex=True):\n \n mug_initial_poses = []\n\n if use_input_initial_poses:\n mug_initial_poses = self.mug_initial_poses\n else:\n for i in range(self.num_mugs):\n mug_initial_poses += \\\n RollPitchYaw(np.random.uniform(0.0, 2.0*np.pi, size=3)).ToQuaternion().wxyz().tolist() + \\\n [np.random.uniform(-0.1, 0.1), np.random.uniform(-0.1, 0.1), np.random.uniform(0.1, 0.2)]\n\n start_time = time.time()\n\n manager = Manager()\n self.all_probabilities = manager.list()\n self.total_iterations = manager.Value('d', 0)\n num_counterexamples = manager.Value('d', 0)\n model_number = manager.Value('d', 0)\n model_number_lock = manager.Lock()\n counter_lock = manager.Lock()\n all_probabilities_lock = manager.Lock()\n\n file_q = manager.Queue()\n folder_name = ''\n\n if local_optimizer_method == OptimizerType.NELDER_MEAD:\n folder_name = os.path.join(self.package_directory, \"../data/optimization_comparisons/nelder_mead\")\n elif local_optimizer_method == OptimizerType.SLSQP:\n folder_name = os.path.join(self.package_directory, \"../data/optimization_comparisons/slsqp\")\n\n self.mug_pipeline.set_folder_names(folder_name)\n self.mug_pipeline.set_optimizer_type(local_optimizer_method)\n\n pool = Pool(self.num_processes + 1, maxtasksperchild=30)\n\n filename = '{}/results.csv'.format(folder_name)\n watcher = Process(target=self.listener, args=(file_q, filename))\n watcher.start()\n\n try:\n result = func_timeout(self.max_time, pool.starmap,\n args=(self.run_local_optimizer_helper,\n zip(repeat(local_optimizer_method),\n range(self.num_processes), repeat(self.mug_pipeline), repeat(self.num_mugs),\n repeat(self.all_probabilities), repeat(self.total_iterations),\n repeat(num_counterexamples),\n repeat(model_number), repeat(model_number_lock),\n repeat(counter_lock), repeat(all_probabilities_lock),\n repeat(file_q), repeat(use_input_initial_poses), repeat(mug_initial_poses),\n repeat(respawn_when_counterex))))\n except FunctionTimedOut:\n elapsed_time = time.time() - start_time\n print('ran for {} minutes! total number of iterations is {}, with {} sec/image'.format(\n elapsed_time/60.0, self.total_iterations.value,\n elapsed_time/self.total_iterations.value), flush=True)\n\n file_q.put('kill')\n pool.terminate()\n pool.join()\n\n end_time = time.time()\n\n print('probabilities:', self.all_probabilities, flush=True)\n\n sys.stdout.flush()","def _worker_fn(example, transform):\n feature = transform(example)\n return feature","def forward(self, x):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\n x = F.relu(self.batch3a(self.conv3a(x)))\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\n x = F.relu(self.batch4a(self.conv4a(x)))\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\n x = F.relu(self.batch5a(self.conv5a(x)))\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\n x = self.avgpool(x)\n x = x.reshape(x.shape[0], -1)\n out = self.fc1(x)\n\n# raise NotImplementedError\n ########################\n # END OF YOUR CODE #\n #######################\n\n return out","def __init__(self, model_source = None, train_log_dir = None, name = \"DNN2\", auto_reload = False, only_final=False, denorm_out=True): \n super().__init__(name = name)\n self.model_source = model_source\n self.train_log_dir = train_log_dir\n \n self.feat_in_pipe_out, self.feat_in_pipe_in = multiprocessing.Pipe(False)\n self.mapping_process = None\n self.run_map = multiprocessing.Value('b', False)\n self.auto_reload = auto_reload\n self.observer = None\n self.only_final = only_final\n self.denorm_out = denorm_out","def run(self):\n\t\t## findMinError\n\t\tself.count = 0\n\t\tprint 'Starting Process type', self.ftype\n\t\tself.min_error = 1\n\t\t# it = 0\n\t\t#self.threadnum = min(500, len(self.pool))\n\t\trows = 3\n\t\tself.threadnum = (len(self.pool)+2)/3\n\t\trows = len(self.pool)/self.threadnum\n\t\tlist_rowlists = [self.pool[x:x+rows] for x in xrange(0, len(self.pool), rows)]\n\t\tmapper = SimpleMapReduce(self.MapFind, self.Reduce, num_workers=self.threadnum)\n\t\tprint 'before mapper'\n\t\tresult = mapper(list_rowlists)\n\t\tprint result\n\t\t#self.min_row, error_infor\n\n\t\tself.min_threshold = error_infor[0]\n\t\tself.min_error = error_infor[1]\n\t\tself.min_flag = error_infor[2]\n\t\t# it += 1\n\t\t# if it%10==0:\n\t\t# \tprint 'type'+str(self.ftype),\"{0:.1%}\".format(float(it)/len(self.pool)), ' search completed'\n\t\treturn","def __init__(self,\n num_actions,\n\n tau,\n alpha=1,\n clip_value_min=-10,\n\n net_conf = None,\n env = \"CartPole\", \n normalize_obs = True,\n hidden_layer=2, \n neurons=512,\n replay_scheme='prioritized',\n noisy = False,\n dueling = False,\n initzer = 'xavier_uniform',\n target_opt=0,\n mse_inf=False,\n network=networks.NatureDQNNetwork,\n optimizer='adam',\n epsilon_fn=dqn_agent.linearly_decaying_epsilon,\n seed=None):\n # We need this because some tools convert round floats into ints.\n seed = int(time.time() * 1e6) if seed is None else seed\n self._net_conf = net_conf\n self._env = env \n self._normalize_obs = normalize_obs\n self._hidden_layer = hidden_layer\n self._neurons=neurons \n self._noisy = noisy\n self._dueling = dueling\n self._initzer = initzer\n self._target_opt = target_opt\n self._mse_inf = mse_inf\n self._tau = tau\n self._alpha = alpha\n self._clip_value_min = clip_value_min\n self._rng = jax.random.PRNGKey(seed)\n\n super(JaxDQNAgentNew, self).__init__(\n num_actions= num_actions,\n network= functools.partial(network, \n num_actions=num_actions,\n net_conf=self._net_conf,\n env=self._env,\n normalize_obs=self._normalize_obs,\n hidden_layer=self._hidden_layer, \n neurons=self._neurons,\n noisy=self._noisy,\n dueling=self._dueling,\n initzer=self._initzer),\n optimizer=optimizer,\n epsilon_fn=dqn_agent.identity_epsilon if self._noisy == True else epsilon_fn)\n\n \n self._replay_scheme = replay_scheme","def prepare_so_condor_job(self, pool_type, pool_address, subtask_index=1, rank='0', extraArgs=''):\n #New: only prepares a single job which allows multiple jobs to be queued\n #We must change the ownership of each of the copasi files to the user running this script\n #\n #We assume that we have write privileges on each of the files through our group, but don't have permission to actually change ownership (must be superuser to do this)\n #Thus, we workaround this by copying the original file, deleting the original, and moving the copy back to the original filename\n \n# import shutil\n# for i in range(len(self.get_optimization_parameters())):\n# for max in (0, 1):\n# copasi_file = os.path.join(self.path, 'auto_copasi_%d.cps' % (2*i + max))\n# temp_file = os.path.join(self.path, 'temp.cps')\n# shutil.copy2(copasi_file, temp_file)\n# os.remove(copasi_file)\n# os.rename(temp_file, copasi_file)\n# os.chmod(copasi_file, 0664) #Set as group readable and writable\n \n ############\n #Build the appropriate .job files for the sensitivity optimization task, write them to disk, and make a note of their locations\n condor_jobs = []\n \n copasi_file = 'auto_copasi_%d.$(Process).cps' % subtask_index\n output_file = 'output_%d.$(Process).txt' % subtask_index\n \n n = len(self.get_optimization_parameters()) * 2\n \n if pool_type == 'ec2':\n binary_dir = '/usr/local/bin'\n transfer_executable = 'NO'\n else:\n binary_dir, binary = os.path.split(settings.COPASI_LOCAL_BINARY)\n transfer_executable = 'YES'\n \n \n condor_job_string = Template(condor_spec.raw_condor_job_string).substitute(copasiFile=copasi_file, \n otherFiles='',\n rank=rank,\n binary_dir = binary_dir,\n transfer_executable = transfer_executable,\n pool_type = pool_type,\n pool_address = pool_address,\n subtask=str(subtask_index),\n n = n,\n outputFile = output_file,\n extraArgs='',\n )\n \n condor_job_filename = 'auto_condor_%d.job'%subtask_index\n condor_job_full_filename = os.path.join(self.path, condor_job_filename)\n condor_file = open(condor_job_full_filename, 'w')\n condor_file.write(condor_job_string)\n condor_file.close()\n\n return condor_job_filename","def parallel(mech, predicate, nProcs, nTemps):\n P = ct.one_atm\n X = 'CH4:1.0, O2:1.0, N2:3.76'\n pool = multiprocessing.Pool(processes=nProcs, \n initializer=init_process, \n initargs=(mech,))\n\n y = pool.map(predicate, \n zip(itertools.repeat(mech),\n np.linspace(300, 900, nTemps),\n itertools.repeat(P),\n itertools.repeat(X)))\n return y","def _fast_reduction(self, x_ori, best_position, q_times, auxiliary_inputs, gt_boxes, gt_labels, model):\n LOGGER.info(TAG, 'Reduction begins...')\n model = check_model('model', model, BlackModel)\n x_ori = check_numpy_param('x_ori', x_ori)\n _, gt_num = self._detection_scores((x_ori,) + auxiliary_inputs, gt_boxes, gt_labels, model)\n best_position = check_numpy_param('best_position', best_position)\n x_ori, best_position = check_equal_shape('x_ori', x_ori, 'best_position', best_position)\n _, original_num = self._detection_scores((best_position,) + auxiliary_inputs, gt_boxes, gt_labels, model)\n reduction_iters = 6 # recover 10% difference each time and recover 60% totally.\n for _ in range(reduction_iters):\n block_num = 30 # divide the image into 30 segments\n block_width = best_position.shape[0] // block_num\n if block_width > 0:\n for i in range(block_num):\n diff = x_ori[i*block_width: (i+1)*block_width, :, :]\\\n - best_position[i*block_width:(i+1)*block_width, :, :]\n if np.max(np.abs(diff)) >= 0.1*(self._bounds[1] - self._bounds[0]):\n res = diff*0.1\n best_position[i*block_width: (i+1)*block_width, :, :] += res\n _, correct_num = self._detection_scores((best_position,) + auxiliary_inputs, gt_boxes,\n gt_labels, model)\n q_times += 1\n if correct_num[0] > max(original_num[0], gt_num[0]*self._reserve_ratio):\n best_position[i*block_width:(i+1)*block_width, :, :] -= res\n return best_position, q_times","def run_random(self):\n manager = Manager()\n self.all_probabilities = manager.list()\n self.total_iterations = manager.Value('d', 0)\n num_counterexamples = manager.Value('d', 0)\n counter_lock = manager.Lock()\n all_probabilities_lock = manager.Lock()\n\n file_q = manager.Queue()\n\n self.mug_pipeline.set_folder_names(self.folder_name)\n self.mug_pipeline.set_optimizer_type(OptimizerType.RANDOM)\n pool = Pool(self.num_processes + 1, maxtasksperchild=60)\n\n filename = '{}/logs/results_{}.csv'.format(self.folder_name, self.trial_folder)\n watcher = Process(target=self.listener, args=(file_q, filename))\n watcher.start()\n\n iter_num = 0\n start_time = time.time()\n max_time_per_map = 60*60\n\n try:\n # TODO: change this from while true to terminate by timeout (try/except)\n while ((self.retrain_with_random and self.total_iterations.value < self.max_added_to_training) or\n (self.retrain_with_counterexamples and num_counterexamples.value < self.max_added_to_training)):\n result = None\n\n while result is None:\n try:\n result = func_timeout(max_time_per_map, pool.starmap,\n args=(self.mug_pipeline.run_inference,\n zip(self.generate_all_mug_initial_poses(), \n range(iter_num, iter_num + self.num_processes),\n repeat(self.all_probabilities), repeat(all_probabilities_lock), \n repeat(self.total_iterations), repeat(num_counterexamples),\n repeat(counter_lock), repeat(file_q), repeat(False), repeat(False))))\n except FunctionTimedOut:\n print('FUNCTION TIMED OUT, MORE THAN {} SECONDS!!!!'.format(max_time_per_map))\n\n # all_mug_initial_poses = []\n # for j in range(self.num_processes):\n # mug_initial_poses = []\n # for i in range(self.num_mugs):\n # mug_initial_poses += \\\n # RollPitchYaw(np.random.uniform(0.0, 2.0*np.pi, size=3)).ToQuaternion().wxyz().tolist() + \\\n # [np.random.uniform(-0.1, 0.1), np.random.uniform(-0.1, 0.1), np.random.uniform(0.1, 0.2)]\n # all_mug_initial_poses.append(mug_initial_poses)\n\n # result = pool.starmap(self.mug_pipeline.run_inference,\n # zip(all_mug_initial_poses, \n # range(iter_num, iter_num + self.num_processes),\n # repeat(self.all_probabilities), repeat(all_probabilities_lock), \n # repeat(self.total_iterations), repeat(num_counterexamples),\n # repeat(counter_lock), repeat(file_q), repeat(False), repeat(False)))\n\n iter_num += self.num_processes\n print('new iter_num: {}'.format(iter_num), flush=True)\n total_min = (time.time() - start_time)/60.0\n print('avg min/image: {}, total minutes: {}'.format(total_min/(iter_num + 1), total_min))\n print('------------------------------------------------', flush=True)\n sys.stdout.flush()\n except Exception as e:\n raise e\n\n pool.close()\n pool.join()\n\n sys.stdout.flush()","def post_processor(self):","def main():\n\n # cProfile capitulation\n # https://stackoverflow.com/questions/53890693/cprofile-causes-pickling-error-when-running-multiprocessing-python-code\n import cProfile\n if sys.modules['__main__'].__file__ == cProfile.__file__:\n import qbic # re-import main (does *not* use cache or execute as __main__)\n globals().update(vars(qbic)) # Replaces current contents with newly imported stuff\n sys.modules['__main__'] = qbic # Ensures pickle lookups on __main__ find matching version\n\n\n parser = argparse.ArgumentParser(description = 'TF Mutation Predictions')\n parser.add_argument('-i', '--inputfile', action=\"store\", dest=\"inputfile\", type=str,\n help='Input mutation file in .vcf, .tsv, .csv, or .txt format.')\n parser.add_argument('-g', '--genefile', action=\"store\", dest=\"genefile\", type=str,\n help='A file that contains all TF genes that are desired.')\n parser.add_argument('-t', '--filetype', action=\"store\", dest=\"filetype\", type=str,\n default=\"\", help='File type can specify: vcf, icgc, customseq, or mut')\n parser.add_argument('-o', '--outpath', action=\"store\", dest=\"outpath\", type=str,\n default=\"out.tsv\", help='name of the .tsv file that is made')\n parser.add_argument('-f', '--filteropt', action=\"store\", dest=\"filteropt\", type=str,\n default=\"p-value\", help='p-value or z-score')\n parser.add_argument('-v', '--filterval', action=\"store\", dest=\"filterval\", type=float,\n default=0.0001, help='# TFs for opt z-score and p-val cutoff for p-value')\n parser.add_argument('-c', '--chrver', action=\"store\", dest=\"chrver\", type=str,\n default=\"hg19\", help='Chromosome version, can be hg19 or hg38')\n parser.add_argument('-E', '--escorespec', action=\"store\", dest=\"escorespec\", type=float,\n default=0.4, help='PBM E-score specific cutoff.')\n parser.add_argument('-e', '--escorenonspec', action=\"store\", dest=\"escorenonspec\", type=float,\n default=0.35, help='PBM E-score non-specific cutoff.')\n parser.add_argument('-n', '--numthreads', action=\"store\", dest=\"numthreads\", type=int,\n default=None, help='Number of concurrent file I/O threads to use (per core)')\n args = parser.parse_args()\n\n #python3 qbic.py -i testing_resources/single_mutations_sample.tsv -g testing_resources/gene_input.txt -c hg19\n # input_mutation_test.vcf\n # -t mut\n #TfX E2F\n\n if not args.inputfile or not args.genefile:\n raise Exception('-i (--inputfile) and -g (--genefile) are required')\n\n tbl = inittbl(args.inputfile, args.chrver, filetype = args.filetype)\n\n input_genes = parse_tfgenes(args.genesfile)\n res = do_prediction(tbl, input_genes[\"pbms\"], input_genes[\"genes\"], args.filteropt, args.filterval,\n args.escorespec, args.escorenonspec, args.numthreads)\n\n print(\"Writing output to %s\" % args.outpath)\n res.to_csv(args.outpath, index = False, sep=\"\\t\")"],"string":"[\n \"def _optimise(self):\\n pass\",\n \"def computeIntercepts():\\n pass\",\n \"def propose_optimize():\\n pass\",\n \"def process():\",\n \"def reduce_run():\",\n \"def test_3():\\n \\n\\n # Functions wrapped by agents\\n def f(in_streams, out_streams):\\n multiply_and_add(in_streams[0], out_streams[0],\\n multiplicand=2, addend=1)\\n\\n def g(in_streams, out_streams):\\n t = Stream('t')\\n filter_then_square(in_streams[0], t,\\n filter_threshold=20)\\n print_stream(t, name='p1')\\n\\n def sums(in_streams, out_streams):\\n s = Stream('s')\\n sum_window(in_streams[0], s, window_size=3, step_size=3)\\n print_stream(s, name=' p2')\\n\\n processes = \\\\\\n {\\n 'source_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': f,\\n 'sources':\\n {'acceleration':\\n {'type': 'i',\\n 'func': source_thread_target\\n },\\n }\\n },\\n 'process_1':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': g,\\n 'sources': {}\\n },\\n 'process_2':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': sums,\\n 'sources': {}\\n }\\n }\\n \\n connections = \\\\\\n {\\n 'source_process' :\\n {\\n 'out' : [('process_1', 'in'), ('process_2', 'in')],\\n 'acceleration' : [('source_process', 'in')]\\n },\\n 'process_1':\\n {\\n },\\n 'process_2':\\n {\\n }\\n }\\n\\n multicore(processes, connections)\",\n \"def test_2():\\n \\n # Functions wrapped by agents\\n def f(in_streams, out_streams):\\n multiply_and_add(in_streams[0], out_streams[0],\\n multiplicand=2, addend=1)\\n\\n def g(in_streams, out_streams):\\n filter_then_square(in_streams[0], out_streams[0],\\n filter_threshold=20)\\n\\n def h(in_streams, out_streams):\\n s = Stream('s')\\n sum_window(in_streams[0], s, window_size=3, step_size=3)\\n print_stream(s, name=s.name)\\n \\n\\n # Specify processes and connections.\\n processes = \\\\\\n {\\n 'source_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': f,\\n 'sources':\\n {'acceleration':\\n {'type': 'i',\\n 'func': source_thread_target\\n },\\n },\\n 'actuators': {}\\n },\\n 'filter_and_square_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('filtered', 'i')],\\n 'compute_func': g,\\n 'sources': {},\\n 'actuators': {}\\n },\\n 'aggregate_and_output_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': h,\\n 'sources': {},\\n 'actuators': {}\\n }\\n }\\n \\n connections = \\\\\\n {\\n 'source_process' :\\n {\\n 'out' : [('filter_and_square_process', 'in')],\\n 'acceleration' : [('source_process', 'in')]\\n },\\n 'filter_and_square_process' :\\n {\\n 'filtered' : [('aggregate_and_output_process', 'in')],\\n },\\n 'aggregate_and_output_process':\\n {}\\n }\\n\\n multicore(processes, connections)\",\n \"def test_4():\\n\\n # Functions wrapped by agents\\n def f(in_streams, out_streams):\\n identity(in_streams[0], out_streams[0])\\n\\n def g(in_streams, out_streams):\\n multiply(in_streams[0], out_streams[0],\\n multiplicand=2)\\n\\n def h(in_streams, out_streams):\\n square(in_streams[0], out_streams[0])\\n\\n def m(in_streams, out_streams):\\n s = Stream('s')\\n sum_numbers(in_streams, s)\\n print_stream(s, name='s')\\n\\n processes = \\\\\\n {\\n 'source_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': f,\\n 'sources':\\n {'acceleration':\\n {'type': 'i',\\n 'func': source_thread_target\\n },\\n }\\n },\\n 'multiply_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': g,\\n 'sources': {}\\n },\\n 'square_process':\\n {'in_stream_names_types': [('in', 'i')],\\n 'out_stream_names_types': [('out', 'i')],\\n 'compute_func': h,\\n 'sources': {}\\n },\\n 'merge_process':\\n {'in_stream_names_types': [('in_multiply', 'i'),\\n ('in_square', 'i')],\\n 'out_stream_names_types': [],\\n 'compute_func': m,\\n 'sources': {}\\n }\\n }\\n \\n connections = \\\\\\n {\\n 'source_process' :\\n {\\n 'out' : [('multiply_process', 'in'), ('square_process', 'in')],\\n 'acceleration' : [('source_process', 'in')]\\n },\\n 'multiply_process':\\n {\\n 'out' : [('merge_process', 'in_multiply')]\\n },\\n 'square_process':\\n {\\n 'out' : [('merge_process', 'in_square')]\\n },\\n 'merge_process':\\n {\\n }\\n }\\n\\n multicore(processes, connections)\",\n \"def ParallelToserial(self):\\n pass\",\n \"def models_optimize_parallel(model, react_set, fract_opt=0.1, save_file_loc=None, fva=False, processes=cpu_count()):\\n with ProcessPool(processes, initializer=species_init_Objective, initargs=(model,react_set,fract_opt)) as pool:\\n try:\\n if fva==True:\\n future = pool.map(models_optimize_fva, [x.id for x in model.strains], timeout=100)\\n future_iterable = future.result()\\n pheno = list(future_iterable)\\n else:\\n future = pool.map(models_optimize_objective, [x.id for x in model.strains], timeout=20)\\n future_iterable = future.result()\\n pheno = list(future_iterable)\\n except TimeoutError as error:\\n print(\\\"function took longer than %d seconds\\\" % error.args[1])\\n except Exception as error:\\n print(\\\"function raised %s\\\" % error)\\n\\n if save_file_loc!=None:\\n save_json_obj(dict(pheno), save_samples_dir+\\\"sample_\\\"+str(t)+\\\".json\\\")\\n save_json_obj(variant_id_dec_dict, save_samples_dir+\\\"sample_\\\"+str(t)+\\\"_varDecision.json\\\")\\n \\n pool.close()\\n pool.stop()\\n pool.join()\\n return pheno\",\n \"def executor(self):\",\n \"def optimize(self):\\n\\t\\ts1,a1,r1,s2 = self.ram.agg_sample(self.batch_size)\\n\\n\\t\\ts1 = Variable(torch.from_numpy(s1))\\n\\t\\ta1 = Variable(torch.from_numpy(a1))\\n\\t\\tr1 = Variable(torch.from_numpy(r1))\\n\\t\\ts2 = Variable(torch.from_numpy(s2))\\n\\n\\t\\tfor i in range(self.critic_step):\\n\\t\\t\\t# ---------------------- optimize critic ----------------------\\n\\t\\t\\t# Use target actor exploitation policy here for loss evaluation\\n\\t\\t\\t\\n\\t\\t\\t# a2 = self.target_actor.forward(s2).detach()\\n\\t\\t\\t# next_val = torch.squeeze(self.target_critic.forward(s2, a2).detach())\\n\\t\\t\\t\\n\\t\\t\\t# y_exp = r + gamma*Q'( s2, pi'(s2))\\n\\t\\t\\ty_expected = r1 #+ GAMMA*next_val\\n\\t\\t\\t# y_pred = Q( s1, a1)\\n\\t\\t\\ty_predicted = torch.squeeze(self.critic.forward(s1, a1))\\n\\t\\t\\t# compute critic loss, and update the critic\\n\\t\\t\\t#print(y_predicted,y_expected,\\\"hi\\\")\\n\\t\\t\\tloss_critic = F.smooth_l1_loss(y_predicted, y_expected.squeeze())\\n\\t\\t\\tself.critic_optimizer.zero_grad()\\n\\t\\t\\tloss_critic.backward()\\n\\t\\t\\tself.critic_optimizer.step()\\n\\n\\t\\t# ---------------------- optimize actor ----------------------\\n\\t\\tpred_a1 = self.actor.forward(s1)\\n\\t\\tloss_actor = -1*torch.sum(self.critic.forward(s1, pred_a1))\\n\\t\\tself.actor_optimizer.zero_grad()\\n\\t\\tloss_actor.backward()\\n\\t\\tself.actor_optimizer.step()\\n\\n\\t\\tutils.soft_update(self.target_actor, self.actor, TAU)\\n\\t\\tutils.soft_update(self.target_critic, self.critic, TAU)\\n\\n\\t\\t# if self.iter % 100 == 0:\\n\\t\\tif self.batch_size > 1:\\n\\t\\t\\ty_1 = y_predicted.data.numpy()[0]\\n\\t\\t\\tr_1 = r1.data.numpy()[0]\\n\\t\\telse:\\n\\t\\t\\ty_1 = y_predicted.data.numpy()\\n\\t\\t\\tr_1 = r1.data.numpy()\\n\\t\\tprint ('Iteration :- ', self.iter, ' Loss_actor :- ', loss_actor.data.numpy(),\\\\\\n\\t\\t\\t' Loss_critic :- ', loss_critic.data.numpy(), ' Critic Pred Reward :- ', y_1, ' Actual Reward :- ', r_1)\\n\\t\\tself.iter += 1\",\n \"def accept_optimize():\\n pass\",\n \"def run_RL_sync(mapname,n_trials = int, seed = int,alpha = 0.15, beta = 0.2, tau = 5, gamma = 0.9, max_steps = 1000, reward_size = 100):\\n\\n # Softmax can't be from external file, because multiprocessing messes up the seed values\\n np.random.seed(seed)\\n def softmax_action(action_weights = [], tau = int):\\n action_indices = list(range(len(action_weights)))\\n f = np.exp((action_weights - np.max(action_weights))/tau) # shift values\\n action_prob = f / f.sum(axis=0)\\n action_index = np.random.choice(action_indices, 1, p=action_prob)\\n return action_index[0]\\n\\n srate = 500 #sample rate\\n \\n total_time = int(1.5*srate) #total timesteps or \\\"time the agent gets to think about moving\\\"\\n\\n time0 = time.perf_counter()\\n\\n print(\\\"Running the RL model but with sync !\\\")\\n srate = 500 #sample rate\\n \\n total_time = int(1.5*srate) #total timesteps or \\\"time the agent gets to think about moving\\\"\\n\\n # Learning Parameters\\n parameters = {\\\"alpha\\\": alpha\\n ,\\\"beta\\\": beta\\n ,\\\"gamma\\\": gamma\\n ,\\\"tau\\\": tau}\\n n_steps = max_steps\\n n_trials = n_trials\\n \\n sub_reward_size = 0 # no subgoals!\\n # # # # # # # # # # # # # #\\n # # Setting up the map # #\\n # # # # # # # # # # # # # #\\n \\\"\\\"\\\" The agent begins in a walled grid and has to find \\n the goal to obtain a reward.\\\"\\\"\\\"\\n # Grid #\\n states = create_grid_from_file(map_file=mapname,goal_location = [10,3],reward_size=reward_size,sub_reward_size=sub_reward_size)\\n state_set = list(range(int(states.shape[0]*states.shape[1]))) #index of states\\n\\n #set of actions\\n move_name=[\\\"UP\\\", \\\"R-UP\\\", \\\"RIGHT\\\",\\\"R-DOWN\\\",\\\"DOWN\\\",\\\"L-DOWN\\\", \\\"LEFT\\\" ,\\\"LEFT-UP\\\"] \\n moves = [[-1, 0],[-1, 1], [0, 1], [1, 1], [1, 0],[1, -1], [0, -1], [-1, -1]]\\n action_set = list(range(len(moves))) #index list\\n\\n # # # # # # # # # # # # # # # # # # # # # # # #\\n # # Setting up the synchronization modules # #\\n # # # # # # # # # # # # # # # # # # # # # # # #\\n\\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n Processing module\\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n\\n # Initial variables #\\n\\n r2_max = 1 #maximum amplitude of nodes\\n drift = .8 #rate of drift between coupling parameters\\n\\n cg_1 = (30/srate)*np.pi #gamma band coupling parameter for input information\\n cg_2 = cg_1 + (drift/srate)*2*np.pi #gamma band coupling parameter for actions\\n \\n damp = 0.3 #damping parameter\\n decay = 0.9 #decay parameter\\n noise = 0.5 #noise parameter\\n\\n # Initial matrices #\\n\\n n_states = len(state_set)\\n n_actions= len(action_set)\\n\\n #Setting up phase code neurons across entire task\\n S_Phase = np.zeros((2,states.shape[0],states.shape[1],total_time)) #State phase code units\\n A_Phase = np.zeros((2,n_actions,total_time)) #Action phase code units\\n\\n #Setting up rate code neurons across entire task\\n S_Rate = np.zeros((states.shape[0],states.shape[1],total_time)) #State rate code units\\n A_Rate = np.zeros((n_actions,total_time)) #Action rate code units\\n #State-Action Weight Matrix\\n W = np.zeros((states.shape[0],states.shape[1],n_actions))#*0.001 #initial state-action weights\\n V = np.zeros((states.shape[0],states.shape[1]))#*0.001 #initial state weights\\n\\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n Control module\\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n\\n # MFC #\\n # Initial variables \\n r2_MFC = 0.7 #maximum amplitude MFC node\\n damp_MFC = 0.03 # damping parameter MFC\\n acc_slope = 10 # MFC slope parameter ---> steepness of burst probability distribution\\n ct = (5/srate)*2*np.pi #theta band coupling parameter for MFC\\n\\n #Setting up phase code nodes for the MFC\\n MFC = np.zeros((2,total_time))\\n #Setting up phase code neuron for MFC -> Bernoulli rate code\\n Be = 0 \\n \\\"\\\"\\\"When the be value as the rate code of MFC\\n reaches certain threshold the MFC will send a burst to coupled neurons\\\"\\\"\\\"\\n\\n # LFC #\\n #Module indicating which states should be initiate action-state synchronization\\n LFC = np.zeros((states.shape[0],states.shape[1],n_steps))\\n\\n #Module that gives the right indices to synchronize\\n LFC_sync = 0\\n\\n\\n\\n # # # # # # # # # # # # # #\\n # # Simulation # #\\n # # # # # # # # # # # # # #\\n\\n # Logging dependent variables\\n Hit = np.zeros((total_time,n_steps,n_trials)) #log when there is a burst from the MFC\\n # Goal_reach = np.zeros((n_steps,n_trials)) #record if goal is reached \\n # Move = np.zeros((n_steps,n_trials)) #record move\\n # Bernoulli = np.zeros((total_time,n_steps,n_trials)) #Logging the bernoulli process variables (should be in between -.8 and .8)\\n # pred_err = np.zeros((states.shape[0],states.shape[1],n_steps,n_trials)) #logging the prediction error\\n trial_length = np.zeros((n_trials))\\n\\n # Recording sync\\n sync = np.zeros((n_states,n_actions,n_steps,n_trials)) \\n\\n \\\"\\\"\\\" L O O P \\\"\\\"\\\"\\n\\n exploration = 0\\n exploration_intent =0\\n sync_fail=0\\n greedy=0\\n for trial in range(n_trials):\\n \\\"\\\"\\\"A trial is considered as each journey the actor makes until the goal\\n or until it runs out of steps\\\"\\\"\\\"\\n at_goal = False\\n start_loc = [1,int(states.shape[1]-2)] #start in the top left\\n step = 0 \\n S_Phase[:,:,:,0] = (2*np.random.random_sample((2,states.shape[0],states.shape[1])))-1 # random starting points processing module\\n A_Phase[:,:,0] = (2*np.random.random_sample((2,n_actions)))-1 # idem\\n while not at_goal:\\n #starting location at first trial\\n if step == 0:\\n current_loc = start_loc\\n else:\\n S_Phase[:,:,:,0] = S_Phase[:,:,:,total_time-1] # random starting points processing module\\n A_Phase[:,:,0] = A_Phase[:,:,total_time-1] # idem\\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n Synchronization\\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n\\n \\n #phase reset\\n MFC[:,0]=np.ones((2))*r2_MFC \\n\\n\\n # LFC setting instruction per step: each state is an input\\n LFC[current_loc[0],current_loc[1],step] = 1\\n\\n # What we want is the lfc to indicate the state and then have the LFC sync pro actively select an action based on state action value maps\\n \\n action_to_sync = softmax_action(action_weights=W[current_loc[0],current_loc[1],:],tau=10)\\n if action_to_sync in np.where(W[current_loc[0],current_loc[1],:]== max(W[current_loc[0],current_loc[1],:]))[0]:\\n greedy+=0\\n else:\\n exploration_intent+=1\\n \\n \\n #Which action does LFC sync to current state\\n LFC_sync = int(action_to_sync)\\n LFC_desync = list(range(len(moves)))\\n LFC_desync.pop(LFC_sync) \\n\\n # The actor makes the move #\\n for t in range(total_time-1):\\n\\n \\n #Update phase code neurons for actions and states in processing module\\n #State phase code neurons \\n S_Phase[:,:,:,t+1] = update_phase(nodes=S_Phase[:,:,:,t], grid = True, radius=r2_max, damp = damp, coupling = cg_1,multiple=True )\\n \\n #Action phase code neurons\\n A_Phase[:,:,t+1] = update_phase(nodes=A_Phase[:,:,t], grid = False, radius=r2_max, damp = damp, coupling = cg_2,multiple=True )\\n\\n #Update phase code untis of MFC\\n MFC[:,t+1] = update_phase(nodes=MFC[:,t], grid = False, radius=r2_MFC, damp=damp_MFC, coupling=ct,multiple=False)\\n\\n #MFC rate code neuron-> Bernoulli process\\n\\n Be = 1/(1 + np.exp(-acc_slope*(MFC[0,t]-1))) # Bernoulli process \\n #Bernoulli[time,step,trial] = Be # logging Be value\\n\\n p = random.random()\\n\\n if p < Be:\\n\\n Gaussian = np.random.normal(size = [1,2]) #noise factor as normal distribution\\n #Hit[tijd,step,trial] = 1\\n \\n \\n x, y = current_loc[1], current_loc[0]\\n\\n #the LFC decides which state is paired with which actions\\n\\n if LFC[y,x,step]:\\n #The state the actor is in receives a burst because it is the only input\\n S_Phase[:,y,x,t+1] = decay*S_Phase[:,y,x,t] + Gaussian\\n\\n # and all the actions that are to be synchronized to that state receive a burst\\n if type(LFC_sync) is int:\\n A_Phase[:,LFC_sync,t+1] = decay*A_Phase[:,LFC_sync,t] + Gaussian\\n \\n # Desynchronize all other actions !\\n for node in LFC_desync:\\n A_Phase[:,int(node),t+1] = decay*A_Phase[:,int(node),t] - Gaussian*noise\\n\\n #Updating rate code units\\n #Only the rate code neuron of a single state is updated because the actor can only be in one place at the same time\\n S_Rate[current_loc[0],current_loc[1],t]= (1/(1+np.exp(-5*S_Phase[0,current_loc[0],current_loc[1],t]-0.6)))\\n A_Rate[:,t]=(S_Rate[current_loc[0],current_loc[1],t]*(W[current_loc[0],current_loc[1],:]+1))*(1/(1+np.exp(-5*A_Phase[0,:,t]-0.6)))\\n #A_Rate[:,t]=(S_Rate[current_loc[0],current_loc[1],t])*(1/(1+np.exp(-5*A_Phase[0,:,t]-0.6)))\\n \\n # select action\\n action_index = int(np.argmax(np.sum(A_Rate[:,:],axis=1)))\\n if action_index in np.where(W[current_loc[0],current_loc[1],:] == max(W[current_loc[0],current_loc[1],:]))[0]:\\n greedy+=1\\n else:\\n exploration+=1\\n\\n if action_index != LFC_sync:\\n sync_fail+=1\\n \\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n Learning\\n \\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\n\\n #update location\\n new_loc= update_location(grid = states, loc=current_loc,move = moves[action_index])\\n\\n #log coordinates for weight matrices\\n coordinates = [current_loc[0], current_loc[1], new_loc[0], new_loc[1], action_index] #location coordinates\\n\\n #update weights according to TD-learning\\n V, W, delta, at_goal = update_weights(param=parameters, index=coordinates, V=V, W=W, states=states, reward_size = reward_size)\\n\\n\\n #update_location\\n current_loc = new_loc\\n step+=1\\n if step ==n_steps:\\n #print(\\\"Agent did not reach goal\\\")\\n break\\n \\n trial_length[trial] = step \\n \\n print(\\\"I took {0} exploratory steps and {1} greedy steps this simulation\\\".format(exploration,greedy))\\n print(\\\"I intended to explore {} times\\\".format(exploration_intent))\\n print(\\\"Sync of correct action failed {} times\\\".format(sync_fail))\\n print(\\\"In this sim I took a total {} steps\\\".format(np.sum(trial_length)))\\n \\n time1 = time.perf_counter()\\n print(\\\"For the second model I took {} minutes\\\".format((time1-time0)/60))\\n return trial_length, V\",\n \"def precompute(self, features, mode, params):\\n return None\",\n \"def test_inter_process_cache():\\r\\n\\r\\n x, y = theano.tensor.dvectors('xy')\\r\\n f = theano.function([x, y], [MyOp()(x), MyOp()(y)])\\r\\n f(numpy.arange(60), numpy.arange(60))\\r\\n if theano.config.mode == 'FAST_COMPILE' or theano.config.cxx == \\\"\\\":\\r\\n assert MyOp.nb_called == 0\\r\\n else:\\r\\n assert MyOp.nb_called == 1\\r\\n\\r\\n # What if we compile a new function with new variables?\\r\\n x, y = theano.tensor.dvectors('xy')\\r\\n f = theano.function([x, y], [MyOp()(x), MyOp()(y)])\\r\\n f(numpy.arange(60), numpy.arange(60))\\r\\n if theano.config.mode == 'FAST_COMPILE' or theano.config.cxx == \\\"\\\":\\r\\n assert MyOp.nb_called == 0\\r\\n else:\\r\\n assert MyOp.nb_called == 1\",\n \"def preprocess_main():\",\n \"def RUN(numTrials, rateMap, numPhotons=48, angularSize=10.0, outputSize=300, mcList='MCOut.pickle',HESS=False, Sig = -1 ,numProcs = 10):\\r\\n print 'Beginning MC Series\\\\nProgress'\\r\\n \\r\\n import FermiPSF, ParseFermi\\r\\n mcOut = []\\r\\n map = pickle.load(open(rateMap, \\\"r\\\" )) # load rate-map\\r\\n PSFTableFront = FermiPSF.PSF_130(convType='front') # load PSF front converting\\r\\n PSFTableBack = FermiPSF.PSF_130(convType='back') # load PSF back converting\\r\\n\\r\\n start = time.time();\\r\\n \\r\\n ppa = outputSize/angularSize # pixel per degree\\r\\n\\r\\n # Import background template\\r\\n bgmap = 'BGRateMap.pickle'\\r\\n if (HESS == True):\\r\\n bgmap = 'BGRateMap_HESS_2_deg.pickle'\\r\\n \\r\\n bgTemplate = pickle.load(open(bgmap , \\\"r\\\" ))\\r\\n \\r\\n mcOut = np.zeros(numTrials)\\r\\n p = pool.Pool(numProcs)\\r\\n \\r\\n partial_MC_THREAD = partial( MC_THREAD, map = map,bgTemplate=bgTemplate,PSFTableFront=PSFTableFront, PSFTableBack=PSFTableBack, HESS=HESS, angularSize=angularSize, numPhotons=numPhotons, outputSize=outputSize,Sig = Sig)\\r\\n mcOut = p.map(partial_MC_THREAD, mcOut)\\r\\n \\r\\n# for i in range(numTrials): \\r\\n# # Build the background \\r\\n## background = Build_Background_Sideband(bgMean, lowSideband, highSideband, PSFTable)\\r\\n# background = Build_Background_Template(bg, bgTemplate, PSFTableFront, PSFTableBack,flatLevel = 0.0,HESS= HESS,angularSize = angularSize)\\r\\n# # Compute number of source photons\\r\\n# numMC = numPhotons - len(background[0])\\r\\n# # Run MC for source photons \\r\\n# data = MC(map,numMC,angularSize,outputSize,PSFTableFront, PSFTableBack,HESS=HESS)\\r\\n# # Append data\\r\\n# mcOut.append((data[0]+background[0], data[1]+background[1]))\\r\\n# \\r\\n# # Compute Speed Statistics\\r\\n# sys.stdout.write('\\\\r' + str(i+1)+'/'+str(numTrials)) \\r\\n# sys.stdout.flush()\\r\\n elapsed = time.time()-start;\\r\\n if (elapsed != 0.0):\\r\\n print '\\\\nSimulations Completed in', elapsed, 's', '(',numTrials/elapsed, ' sims per second)'\\r\\n \\r\\n outFile = open(mcList, \\\"wb\\\" )\\r\\n pickle.dump(mcOut, outFile)\\r\\n print 'Results saved to ', mcList\\r\\n return mcOut\",\n \"def main():\\n pool = Pool(processes=50)\\n results = pool.imap_unordered(experiment, range(50), chunksize=1)\\n\\n # Output\\n offset = 1\\n # for i, (data_surv, data_order, data_ctrl) in enumerate(results):\\n for i, (data_surv, data_ctrl) in enumerate(results):\\n with open(f'../data/reproductive_barrier/hybrid_survival_percentage/experiment_{i+offset}.csv', 'w') as fp:\\n for t, surv in data_surv:\\n fp.write(f'{int(t)},{float(surv)}\\\\n')\\n\\n with open(f'../data/reproductive_barrier/order_of_incompatibility/experiment_{i+offset}.csv', 'w') as fp:\\n for x in data_order:\\n fp.write('%d,' % int(x[0]) + ','.join(map(str, x[1:])) + '\\\\n')\\n\\n with open(f'../data/reproductive_barrier/control_survival_percentage/experiment_{i+offset}.csv', 'w') as fp:\\n for t, surv in data_ctrl:\\n fp.write(f'{int(t)},{float(surv)}\\\\n')\\n\\n return\",\n \"def start_processing(self):\",\n \"def __init__(self, limit, noise, random_seed, n_state=33, n_action=4):\\n # Actor Model: Local, Target, & Optimizer\\n self.Actor, self.ActorTarget, self.actorOpt = [], [], []\\n for i in range(limit):\\n self.Actor.append(Actor(n_state, n_action, random_seed).to(device)) \\n self.actorOpt.append(optim.Adam(self.Actor[i].parameters(), lr=LR_ACTOR))\\n self.ActorTarget = Actor(n_state, n_action, random_seed).to(device) \\n # Critic Model: Local, Target, & Optimizer\\n self.Critic = Critic(n_state, n_action, random_seed).to(device)\\n self.CriticTarget = Critic(n_state, n_action, random_seed).to(device)\\n self.criticOpt = optim.Adam(self.Critic.parameters(), lr=LR_CRITIC)\\n # Replay Buffer\\n self.Memory = ReplayBuffer2(n_action, BUFFER_SIZE, BATCH_SIZE, device, random_seed)\\n self.step = 0\\n # OUNoise Process\\n self.noise = noise\\n # Display\\n print('\\\\nBUFFER_SIZE', BUFFER_SIZE,\\n '\\\\nBATCH_SIZE', BATCH_SIZE,\\n '\\\\nGAMMA', GAMMA,\\n '\\\\nTAU', TAU,\\n '\\\\nLR_ACTOR', LR_ACTOR,\\n '\\\\nLR_CRITIC', LR_CRITIC)\\n # Display Actor & Critic\\n print('\\\\nACTOR[i]:\\\\n', self.Actor[0])\\n print('CRITIC:\\\\n', self.Critic)\",\n \"def main():\\n # Handle CLI.\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--molecule\\\", type=str, default=\\\"H2\\\", help=\\\"the \\\"\\n \\\"UCCSD molecule to perform HPO on\\\")\\n parser.add_argument(\\\"--slice-index\\\", type=int, default=-1, help=\\\"the \\\"\\n \\\"slice to perform HPO on, do not specify to run HPO \\\"\\n \\\"on the full circuit\\\")\\n parser.add_argument(\\\"--core-count\\\", type=int, default=1, help=\\\"the \\\"\\n \\\"number of cpu cores this run may use\\\")\\n args = vars(parser.parse_args())\\n molecule = args[\\\"molecule\\\"]\\n slice_index = args[\\\"slice_index\\\"]\\n core_count = args[\\\"core_count\\\"]\\n\\n # Generate the state object that encapsulates the optimization for the circuit.\\n state = ProcessState(molecule, slice_index)\\n\\n # Redirect everything the central process puts out to a log file.\\n # By default, ray redirects the stdout of each worker process\\n # to the central process.\\n log_file = state.file_name + \\\".log\\\"\\n log_file_path = os.path.join(state.data_path, log_file)\\n with open(log_file_path, \\\"a+\\\") as log:\\n sys.stdout = sys.stderr = log\\n\\n # Display run characteristics.\\n print(\\\"PID={}\\\\nWALL_TIME={}\\\\nSLICE_INDEX={}\\\\nPULSE_TIME={}\\\\n\\\"\\n \\\"(LR_LB, LR_UB)=({}, {})\\\\n(DECAY_LB, DECAY_UB)=({}, {})\\\\n\\\"\\n \\\"CORE_COUNT={}\\\\n{}\\\"\\n \\\"\\\".format(os.getpid(), time.time(), state.slice_index,\\n state.pulse_time, LR_LB, LR_UB, DECAY_LB, DECAY_UB, \\n core_count, state.circuit))\\n\\n # Define the search space on the parameters: learning rate and\\n # learning rate decay.\\n space = {\\n \\\"lr\\\": hp.loguniform(\\\"lr\\\", np.log(LR_LB), np.log(LR_UB)),\\n \\\"decay\\\": hp.uniform(\\\"decay\\\", DECAY_LB, DECAY_UB),\\n }\\n \\n # We want to minimize QOC error/loss, i.e. we want to maximize\\n # negative loss.\\n algo = ray.tune.suggest.HyperOptSearch(space, max_concurrent=core_count,\\n reward_attr=\\\"neg_loss\\\")\\n run_config = {\\n \\\"num_samples\\\": HPO_MAX_ITERATIONS,\\n \\\"name\\\": state.file_name,\\n \\\"loggers\\\": [ray.tune.logger.NoopLogger],\\n \\\"search_alg\\\": algo,\\n \\\"verbose\\\": 1,\\n \\\"local_dir\\\": state.data_path,\\n \\\"resume\\\": True,\\n }\\n \\n # Ray cannot serialize python objects in its object store,\\n # so we have to pass the state in a lambda wrapper.\\n objective_wrapper = lambda config, reporter: objective(state, config,\\n reporter)\\n \\n # Start ray and run HPO.\\n ray.init(num_cpus=core_count, object_store_memory=OBJECT_STORE_MEMORY,\\n redis_max_memory=REDIS_MAX_MEMORY)\\n ray.tune.register_trainable(\\\"lambda_id\\\", objective_wrapper)\\n ray.tune.run(\\\"lambda_id\\\", **run_config)\",\n \"def PARALLEL_worker_mc_inv(procnum, num_samples_per_processor, inversion_type, M_amplitude, green_func_array, real_data_array, comparison_metric, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, return_dict_MTs, return_dict_similarity_values_all_samples, return_dict_shift_idxs, return_dict_MT_single_force_rel_amps, return_dict_medium_1_medium_2_rel_amp_ratios, invert_for_ratio_of_multiple_media_greens_func_switch, green_func_phase_labels, num_phase_types_for_media_ratios, invert_for_relative_magnitudes_switch=False, rel_exp_mag_range=[1.,1.], auto_shift_for_best_fit=True):\\n print(\\\"Processing for process:\\\", procnum, \\\"for \\\", num_samples_per_processor, \\\"samples.\\\")\\n \\n # Define temp data stores for current process:\\n tmp_MTs = np.zeros((len(green_func_array[0,:,0]), num_samples_per_processor), dtype=float)\\n tmp_similarity_values_all_samples = np.zeros(num_samples_per_processor, dtype=float)\\n tmp_shift_idxs_all_samples = []\\n if inversion_type == \\\"DC_single_force_couple\\\" or inversion_type == \\\"DC_single_force_no_coupling\\\" or inversion_type == \\\"DC_crack_couple\\\" or inversion_type == \\\"single_force_crack_no_coupling\\\":\\n tmp_MT_single_force_rel_amps = np.zeros(num_samples_per_processor, dtype=float)\\n else:\\n tmp_MT_single_force_rel_amps = []\\n if invert_for_ratio_of_multiple_media_greens_func_switch:\\n tmp_medium_1_medium_2_rel_amp_ratios = np.zeros(num_samples_per_processor, dtype=float)\\n else:\\n tmp_medium_1_medium_2_rel_amp_ratios = []\\n if invert_for_ratio_of_multiple_media_greens_func_switch:\\n if num_phase_types_for_media_ratios>0:\\n tmp_frac_medium_2_diff_phases_dict = {} # Dictionary for temp storing of phase fractions of medium 1\\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases = np.zeros((num_samples_per_processor, 3), dtype=float)\\n else:\\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases = []\\n \\n # Sort greens function storage if processing for multiple media:\\n if invert_for_ratio_of_multiple_media_greens_func_switch:\\n green_func_array_total_both_media = green_func_array.copy()\\n \\n # 3. Loop over samples, checking how well a given MT sample synthetic wavefrom from the forward model compares to the real data:\\n for i in range(num_samples_per_processor):\\n # Generate random medium amplitude ratio and associated greens functions (if required):\\n if invert_for_ratio_of_multiple_media_greens_func_switch:\\n # If want to invert for ratio of meduim 1 to medium 2 separately for different phases:\\n if num_phase_types_for_media_ratios>0:\\n # Generate different phase fractions:\\n tmp_frac_medium_2_diff_phases_dict[\\\"P\\\"] = np.random.uniform(0.0, 1.0)\\n tmp_frac_medium_2_diff_phases_dict[\\\"S\\\"] = np.random.uniform(0.0, 1.0)\\n tmp_frac_medium_2_diff_phases_dict[\\\"surface\\\"] = np.random.uniform(0.0, 1.0)\\n # Generate associated greens functions:\\n green_func_array = np.zeros(np.shape(green_func_array_total_both_media[:,:,:,0]), dtype=float)\\n # Loop over greens function for each station-phase:\\n for j in range(len(green_func_phase_labels)):\\n tmp_frac_medium_2 = tmp_frac_medium_2_diff_phases_dict[green_func_phase_labels[j]] # Get fraction for specific phase, for specific greens functions for specific station-phase\\n green_func_array[j, :, :] = (1. - tmp_frac_medium_2)*green_func_array_total_both_media[j,:,:,0] + tmp_frac_medium_2*green_func_array_total_both_media[j,:,:,1] \\n # Otherwise generate single fraction value and associated greens functions:\\n else:\\n frac_medium_2 = np.random.uniform(0.0, 1.0)\\n green_func_array = (1. - frac_medium_2)*green_func_array[:,:,:,0] + frac_medium_2*green_func_array[:,:,:,1]\\n \\n # 4. Generate synthetic waveform for current sample:\\n # Vary moment amplitude randomly if specified:\\n if invert_for_relative_magnitudes_switch:\\n M_amplitude_exp_factor = np.random.uniform(low=rel_exp_mag_range[0], high=rel_exp_mag_range[1])\\n M_amplitude = 10.**M_amplitude_exp_factor\\n # And generate waveform from source mechanism tensor:\\n if inversion_type==\\\"full_mt\\\":\\n MT_curr_sample = generate_random_MT()*M_amplitude # Generate a random MT sample\\n elif inversion_type==\\\"full_mt_Lune_samp\\\":\\n MT_curr_sample = generate_random_MT_Lune_samp()*M_amplitude # Generate a random MT sample, sampled uniformly in Lune space\\n elif inversion_type==\\\"DC\\\":\\n MT_curr_sample = generate_random_DC_MT()*M_amplitude # Generate a random DC sample\\n elif inversion_type==\\\"single_force\\\":\\n MT_curr_sample = generate_random_single_force_vector()*M_amplitude # Generate a random single force sample\\n elif inversion_type == \\\"DC_single_force_couple\\\":\\n MT_curr_sample, random_DC_to_single_force_amp_frac = generate_random_DC_single_force_coupled_tensor() # Generate a random DC-single-force coupled sample, with associated relative amplitude of DC to single force\\n MT_curr_sample = MT_curr_sample*M_amplitude\\n elif inversion_type == \\\"DC_single_force_no_coupling\\\":\\n MT_curr_sample, random_DC_to_single_force_amp_frac = generate_random_DC_single_force_uncoupled_tensor()\\n MT_curr_sample = MT_curr_sample*M_amplitude\\n elif inversion_type == \\\"DC_crack_couple\\\":\\n MT_curr_sample, random_DC_to_single_force_amp_frac = generate_random_DC_crack_coupled_tensor()\\n MT_curr_sample = MT_curr_sample*M_amplitude\\n elif inversion_type == \\\"single_force_crack_no_coupling\\\":\\n MT_curr_sample, random_DC_to_single_force_amp_frac = generate_random_single_force_crack_uncoupled_tensor()\\n MT_curr_sample = MT_curr_sample*M_amplitude\\n synth_waveform_curr_sample = forward_model(green_func_array, MT_curr_sample) # Note: Greens functions must be of similar amplitude units going into here...\\n \\n # 5. Compare real data to synthetic waveform (using variance reduction or other comparison metric), to assign probability that data matches current model:\\n similarity_curr_sample, shift_idxs = compare_synth_to_real_waveforms(real_data_array, synth_waveform_curr_sample, comparison_metric, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, auto_shift_for_best_fit) \\n \\n # 6. Append results to data store:\\n tmp_MTs[:,i] = MT_curr_sample[:,0]\\n tmp_similarity_values_all_samples[i] = similarity_curr_sample\\n tmp_shift_idxs_all_samples.append(list(shift_idxs))\\n if inversion_type == \\\"DC_single_force_couple\\\" or inversion_type == \\\"DC_single_force_no_coupling\\\" or inversion_type == \\\"DC_crack_couple\\\" or inversion_type == \\\"single_force_crack_no_coupling\\\":\\n tmp_MT_single_force_rel_amps[i] = random_DC_to_single_force_amp_frac\\n if invert_for_ratio_of_multiple_media_greens_func_switch:\\n if num_phase_types_for_media_ratios>0:\\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases[i,0] = tmp_frac_medium_2_diff_phases_dict[\\\"P\\\"]\\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases[i,1] = tmp_frac_medium_2_diff_phases_dict[\\\"S\\\"]\\n tmp_medium_1_medium_2_rel_amp_ratios_multi_phases[i,2] = tmp_frac_medium_2_diff_phases_dict[\\\"surface\\\"]\\n else:\\n tmp_medium_1_medium_2_rel_amp_ratios[i] = frac_medium_2\\n \\n if i % 10000 == 0:\\n print(\\\"Processor number:\\\", procnum, \\\"- Processed for\\\",i,\\\"samples out of\\\",num_samples_per_processor,\\\"samples\\\")\\n \\n # 7. And convert misfit measure to likelihood function probability:\\n tmp_similarity_values_all_samples = np.exp(-(1.-tmp_similarity_values_all_samples)/2.)\\n \\n # And return values back to script:\\n return_dict_MTs[procnum] = tmp_MTs\\n return_dict_similarity_values_all_samples[procnum] = tmp_similarity_values_all_samples\\n return_dict_shift_idxs[procnum] = tmp_shift_idxs_all_samples\\n return_dict_MT_single_force_rel_amps[procnum] = tmp_MT_single_force_rel_amps\\n if num_phase_types_for_media_ratios>0:\\n return_dict_medium_1_medium_2_rel_amp_ratios[procnum] = tmp_medium_1_medium_2_rel_amp_ratios_multi_phases\\n else:\\n return_dict_medium_1_medium_2_rel_amp_ratios[procnum] = tmp_medium_1_medium_2_rel_amp_ratios\\n print(\\\"Finished processing process:\\\", procnum, \\\"for \\\", num_samples_per_processor, \\\"samples.\\\")\",\n \"def run_preprocessing(run):\\n def _process(run):\\n \\\"\\\"\\\" Process a run/flowcell and transfer to analysis server\\n :param taca.illumina.Run run: Run to be processed and transferred\\n \\\"\\\"\\\"\\n logger.info('Checking run {}'.format(run.id))\\n t_file = os.path.join(CONFIG['analysis']['status_dir'], 'transfer.tsv')\\n if run.is_transferred(t_file):\\n # In this case I am either processing a run that is in transfer\\n # or that has been already transferred. Do nothing.\\n # time to time this situation is due to runs that are copied back from NAS after a reboot.\\n # This check avoid failures\\n logger.info('Run {} already transferred to analysis server, skipping it'.format(run.id))\\n return\\n\\n if run.get_run_status() == 'SEQUENCING':\\n # Check status files and say i.e Run in second read, maybe something\\n # even more specific like cycle or something\\n logger.info('Run {} is not finished yet'.format(run.id))\\n elif run.get_run_status() == 'TO_START':\\n if run.get_run_type() == 'NON-NGI-RUN':\\n # For now MiSeq specific case. Process only NGI-run, skip all the others (PhD student runs)\\n logger.warn(\\\"Run {} marked as {}, \\\"\\n \\\"TACA will skip this and move the run to \\\"\\n \\\"no-sync directory\\\".format(run.id, run.get_run_type()))\\n # Archive the run if indicated in the config file\\n if 'storage' in CONFIG:\\n run.archive_run(CONFIG['storage']['archive_dirs'])\\n return\\n # Otherwise it is fine, process it\\n logger.info((\\\"Starting BCL to FASTQ conversion and demultiplexing for run {}\\\".format(run.id)))\\n try:\\n run.demultiplex_run()\\n except:\\n logger.info((\\\"Error demultiplexing for run {}\\\".format(run.id)))\\n pass\\n elif run.get_run_status() == 'IN_PROGRESS':\\n logger.info((\\\"BCL conversion and demultiplexing process in \\\"\\n \\\"progress for run {}, skipping it\\\".format(run.id)))\\n elif run.get_run_status() == 'COMPLETED':\\n logger.info((\\\"Preprocessing of run {} is finished, transferring it\\\".format(run.id)))\\n\\n # Transfer to analysis server if flag is True\\n if run.transfer_to_analysis_server:\\n logger.info('Transferring run {} to {} into {}'\\n .format(run.id,\\n run.CONFIG['analysis_server']['host'],\\n run.CONFIG['analysis_server']['sync']['data_archive']))\\n run.transfer_run(t_file)\\n\\n # Archive the run if indicated in the config file\\n if 'storage' in CONFIG:\\n run.archive_run(CONFIG['storage']['archive_dirs'])\\n\\n if run:\\n # Needs to guess what run type I have (NextSeq)\\n runObj = get_runObj(run)\\n if not runObj:\\n logger.warning(\\\"Unrecognized instrument type or incorrect run folder {}\\\".format(run))\\n raise RuntimeError(\\\"Unrecognized instrument type or incorrect run folder {}\\\".format(run))\\n else:\\n _process(runObj)\\n else:\\n data_dirs = CONFIG.get('analysis').get('data_dirs')\\n for data_dir in data_dirs:\\n # Run folder looks like DATE_*_*_*, the last section is the FC name. \\n # See Courtesy information from illumina of 10 June 2016 (no more XX at the end of the FC)\\n runs = glob.glob(os.path.join(data_dir, '[1-9]*_*_*_*'))\\n for _run in runs:\\n runObj = get_runObj(_run)\\n if not runObj:\\n logger.warning(\\\"Unrecognized instrument type or incorrect run folder {}\\\".format(_run))\\n else:\\n try:\\n _process(runObj)\\n except:\\n # this function might throw and exception,\\n # it is better to continue processing other runs\\n logger.warning(\\\"There was an error processing the run {}\\\".format(_run))\\n pass\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process_thread(self):\",\n \"def custom_processing(self, funct: callable, data_tmp: np.ndarray, **kwargs) -> np.ndarray:\\n tic = time.time()\\n data_tmp = funct(data_tmp, **kwargs)\\n self.process_time.append(time.time() - tic)\\n return data_tmp\",\n \"def receptor_score(self, method='auto', multiprocessing=False):\\n init_arguments = self.init_arguments\\n init_arguments['parameters']['initialize_state']['sensitivity'] = 'exact'\\n init_arguments['parameters']['sensitivity_matrix'] = self.sens_mat\\n joblist = [(copy.deepcopy(self.init_arguments), 'mutual_information',\\n {'method': method})]\\n \\n # add one job for each receptor\\n for n in range(self.Nr):\\n init_arguments = self.init_arguments\\n init_arguments['num_receptors'] -= 1\\n \\n # modify the current state and add it to the job list\\n sens_mat = np.delete(self.sens_mat, n, axis=0)\\n init_arguments['parameters']['sensitivity_matrix'] = sens_mat\\n joblist.append((copy.deepcopy(init_arguments), 'mutual_information',\\n {'method': method}))\\n \\n if multiprocessing:\\n # calculate all results in parallel\\n pool = mp.Pool(processes=self.get_number_of_cores())\\n results = pool.map(_run_job, joblist)\\n \\n else:\\n # create a generator over which we iterate later\\n results = [_run_job(job) for job in joblist]\\n \\n # find the scores of all receptors\\n scores = results[0] - np.array(results[1:])\\n return scores\",\n \"def _optimize(self) -> None:\\n\\n for i, agent in enumerate(self.agents):\\n states, actions, rewards, next_states, dones = self.memory.sample()\\n\\n actor_next_state = self._agent_states(i, next_states)\\n next_actions = torch.cat(\\n [a.actor_target(actor_next_state) for a in self.agents], 1\\n )\\n next_q = agent.critic_target(next_states, next_actions).detach()\\n target_q = rewards[:, i].view(-1, 1) + self.gamma * next_q * (\\n 1 - dones[:, i].view(-1, 1)\\n )\\n local_q = agent.critic_local(states, actions)\\n\\n value_loss = agent.loss_fn(local_q, target_q)\\n agent.value_optimizer.zero_grad()\\n value_loss.backward()\\n agent.value_optimizer.step()\\n\\n local_actions = []\\n for i, a in enumerate(self.agents):\\n local_states = self._agent_states(i, states)\\n local_actions.append(\\n a.actor_local(local_states)\\n if a == agent\\n else a.actor_local(local_states).detach()\\n )\\n local_actions = torch.cat(local_actions, 1)\\n policy_loss = -agent.critic_local(states, local_actions).mean()\\n\\n agent.policy_optimizer.zero_grad()\\n policy_loss.backward()\\n agent.policy_optimizer.step()\\n\\n self._update_target_model(agent.critic_local, agent.critic_target)\\n self._update_target_model(agent.actor_local, agent.actor_target)\",\n \"def process():\\n pass\",\n \"def _preprocess(self):\\n if self.gt_matrix_PCs is None:\\n start = time.time()\\n gt_matrix = self._process_vcf().get('gt_matrix')\\n print('gt_matrix took {} secs'.format(time.time() - start))\\n \\n # Normalize gt_matrix by site\\n gt_matrix_norm = gt_matrix - np.mean(gt_matrix, axis=1)[:, np.newaxis]\\n \\n # PCA\\n start = time.time()\\n u, s, vh = np.linalg.svd(gt_matrix_norm.T, full_matrices=False)\\n print('SVD took {} secs'.format(time.time() - start))\\n self.gt_matrix_PCs = -u @ np.diag(s)\\n \\n # Get relevant objects from result of ripser\\n if self.ripser_result is None:\\n start = time.time()\\n print(\\\"Getting ripser object\\\")\\n self.ripser_result = ripser(self.gt_matrix_PCs, coeff=2, maxdim=1, do_cocycles=True)\\n print('Ripser took {} secs'.format(time.time() - start))\",\n \"def compute(args, fun, max_workers=6):\\n print(\\\"\\\\nProcessing symbols in parallel\\\")\\n ex = futures.ThreadPoolExecutor(max_workers=max_workers)\\n ex.map(fun, args)\",\n \"def __init__(self, feature_store=None, batch_size=100):\\n if feature_store:\\n if type(feature_store) is dict: # A silly way to avoid multiple reading\\n self.features = feature_store\\n self.image_w = 640\\n self.image_h = 480\\n self.vfov = 60\\n self.feature_size = next(iter(self.features.values())).shape[-1]\\n # print('The feature size is %d' % self.feature_size)\\n else:\\n print('Image features not provided')\\n self.features = None\\n self.image_w = 640\\n self.image_h = 480\\n self.vfov = 60\\n self.featurized_scans = set([key.split(\\\"_\\\")[0] for key in list(self.features.keys())])\\n self.sims = []\\n self.qin = []\\n self.qout = []\\n self.qtraj = []\\n self.feature_states = None\\n self.batch_size = batch_size\\n for i in range(batch_size):\\n sim = MatterSim.Simulator()\\n sim.setRenderingEnabled(False)\\n sim.setDiscretizedViewingAngles(True) # Set increment/decrement to 30 degree. (otherwise by radians)\\n sim.setCameraResolution(self.image_w, self.image_h)\\n sim.setCameraVFOV(math.radians(self.vfov))\\n sim.init()\\n self.sims.append(sim)\\n\\n self.qin.append(queue.Queue())\\n self.qout.append(queue.Queue())\\n self.qtraj.append(queue.Queue())\\n \\n self.pool = []\\n\\n def function(i, sim, qin, qout, qtraj):\\n env_actions = {\\n 'left': (0,-1, 0), # left\\n 'right': (0, 1, 0), # right\\n 'up': (0, 0, 1), # up\\n 'down': (0, 0,-1), # down\\n 'forward': (1, 0, 0), # forward\\n '<end>': (0, 0, 0), # <end>\\n '<start>': (0, 0, 0), # <start>\\n '<ignore>': (0, 0, 0) # <ignore>\\n }\\n while True:\\n op, x = qin.get()\\n \\n # while not qout.empty():\\n # qout.get()\\n # while not qtraj.empty():\\n # qtraj.get()\\n\\n if op == 'act':\\n select_candidate, src_point, trg_point, src_level, trg_level = x\\n traj = []\\n def take_action(i, name):\\n if type(name) is int: # Go to the next view\\n sim.makeAction(name, 0, 0)\\n else: # Adjust\\n sim.makeAction(*env_actions[name])\\n state = sim.getState()\\n \\n traj.append((state.location.viewpointId, state.heading, state.elevation))\\n \\n\\n while src_level < trg_level: # Tune up\\n take_action(i, 'up')\\n src_level += 1\\n while src_level > trg_level: # Tune down\\n take_action(i, 'down')\\n src_level -= 1\\n while sim.getState().viewIndex != trg_point: # Turn right until the target\\n take_action(i, 'right')\\n assert select_candidate['viewpointId'] == \\\\\\n sim.getState().navigableLocations[select_candidate['idx']].viewpointId\\n take_action(i, select_candidate['idx'])\\n\\n state = sim.getState()\\n qout.put((state.scanId, state.location.viewpointId, state.heading, state.elevation))\\n # print(traj)\\n qtraj.put(traj)\\n\\n elif op == 'new':\\n scanId, viewpointId, heading, elevation = x\\n sim.newEpisode(scanId, viewpointId, heading, elevation)\\n\\n elif op == 'state':\\n state = sim.getState()\\n state = State(state)\\n # if name != 'env':\\n # setattr(env_copy,name,value)\\n \\n qout.put(state)\\n\\n for i in range(batch_size):\\n p = threading.Thread(target=function, args=(i, self.sims[i], self.qin[i], self.qout[i], self.qtraj[i]), daemon=True)\\n \\n p.start()\\n self.pool.append(p)\",\n \"def read_data_split_and_search():\\n\\n\\n\\n dataReader = Movielens10MReader()\\n dataset = dataReader.load_data()\\n\\n URM_train, URM_test = split_train_in_two_percentage_global_sample(dataset.get_URM_all(), train_percentage = 0.80)\\n URM_train, URM_validation = split_train_in_two_percentage_global_sample(URM_train, train_percentage = 0.80)\\n\\n output_folder_path = \\\"result_experiments/\\\"\\n\\n\\n # If directory does not exist, create\\n if not os.path.exists(output_folder_path):\\n os.makedirs(output_folder_path)\\n\\n\\n\\n\\n\\n\\n\\n collaborative_algorithm_list = [\\n Random,\\n TopPop,\\n P3alphaRecommender,\\n RP3betaRecommender,\\n ItemKNNCFRecommender,\\n UserKNNCFRecommender,\\n MatrixFactorization_BPR_Cython,\\n MatrixFactorization_FunkSVD_Cython,\\n PureSVDRecommender,\\n SLIM_BPR_Cython,\\n SLIMElasticNetRecommender\\n ]\\n\\n\\n\\n\\n from Base.Evaluation.Evaluator import EvaluatorHoldout\\n\\n evaluator_validation = EvaluatorHoldout(URM_validation, cutoff_list=[5])\\n evaluator_test = EvaluatorHoldout(URM_test, cutoff_list=[5, 10])\\n\\n\\n runParameterSearch_Collaborative_partial = partial(runParameterSearch_Collaborative,\\n URM_train = URM_train,\\n metric_to_optimize = \\\"MAP\\\",\\n n_cases = 10,\\n evaluator_validation_earlystopping = evaluator_validation,\\n evaluator_validation = evaluator_validation,\\n evaluator_test = evaluator_test,\\n output_folder_path = output_folder_path,\\n similarity_type_list = [\\\"cosine\\\"],\\n parallelizeKNN = False)\\n\\n\\n\\n\\n\\n pool = multiprocessing.Pool(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)\\n pool.map(runParameterSearch_Collaborative_partial, collaborative_algorithm_list)\\n\\n #\\n #\\n # for recommender_class in collaborative_algorithm_list:\\n #\\n # try:\\n #\\n # runParameterSearch_Collaborative_partial(recommender_class)\\n #\\n # except Exception as e:\\n #\\n # print(\\\"On recommender {} Exception {}\\\".format(recommender_class, str(e)))\\n # traceback.print_exc()\\n #\",\n \"def main():\\n model = sys.argv[1]\\n maxfun = int(sys.argv[2])\\n n_threads = int(sys.argv[3])\\n\\n # Validate input.\\n assert maxfun >= 0, \\\"Maximum number of function evaluations cannot be negative.\\\"\\n assert n_threads >= 1 or n_threads == -1, (\\n \\\"Use -1 to impose no restrictions on maximum number of threads or choose a \\\"\\n \\\"number higher than zero.\\\"\\n )\\n\\n # Set number of threads\\n os.environ[\\\"NUMBA_NUM_THREADS\\\"] = f\\\"{n_threads}\\\"\\n os.environ[\\\"MKL_NUM_THREADS\\\"] = f\\\"{n_threads}\\\"\\n os.environ[\\\"OMP_NUM_THREADS\\\"] = f\\\"{n_threads}\\\"\\n os.environ[\\\"NUMEXPR_NUM_THREADS\\\"] = f\\\"{n_threads}\\\"\\n\\n # Late import of respy to ensure that environment variables are read by Numpy, etc..\\n import respy as rp\\n\\n # Get model\\n params, options = rp.get_example_model(model, with_data=False)\\n\\n # Simulate the data\\n simulate = rp.get_simulate_func(params, options)\\n df = simulate(params)\\n\\n # Get the criterion function and the parameter vector.\\n crit_func = rp.get_log_like_func(params, options, df)\\n\\n # Run the estimation\\n start = dt.datetime.now()\\n\\n for _ in range(maxfun):\\n crit_func(params)\\n\\n end = dt.datetime.now()\\n\\n # Aggregate information\\n output = {\\n \\\"model\\\": model,\\n \\\"maxfun\\\": maxfun,\\n \\\"n_threads\\\": n_threads,\\n \\\"start\\\": str(start),\\n \\\"end\\\": str(end),\\n \\\"duration\\\": str(end - start),\\n }\\n\\n # Save time to file\\n with open(\\\"scalability_results.txt\\\", \\\"a+\\\") as file:\\n file.write(json.dumps(output))\\n file.write(\\\"\\\\n\\\")\",\n \"def do(self, argin):\\n device=self.target\\n # Code here\\n errs = [] # list of error messages\\n receptor_to_vcc = dict([*map(int, pair.split(\\\":\\\"))] for pair in\\n device._proxy_cbf_controller.receptorToVcc)\\n for receptorID in argin:\\n try:\\n vccID = receptor_to_vcc[receptorID]\\n vccProxy = device._proxies_vcc[vccID - 1]\\n\\n # Update the VCC receptorID attribute:\\n\\n self.logger.debug( (\\\"receptorID = {}, vccProxy.receptorID = {}\\\"\\n .format(receptorID, vccProxy.receptorID)))\\n\\n vccProxy.receptorID = receptorID # TODO - may not be needed?\\n\\n self.logger.debug( (\\\"receptorID = {}, vccProxy.receptorID = {}\\\"\\n .format(receptorID, vccProxy.receptorID)))\\n\\n subarrayID = vccProxy.subarrayMembership\\n\\n # only add receptor if it does not already belong to a different subarray\\n if subarrayID not in [0, device._subarray_id]:\\n errs.append(\\\"Receptor {} already in use by subarray {}.\\\".format(\\n str(receptorID), str(subarrayID)))\\n else:\\n if receptorID not in device._receptors:\\n # change subarray membership of vcc\\n vccProxy.subarrayMembership = device._subarray_id\\n\\n # TODO: is this note still relevant? \\n # Note:json does not recognize NumPy data types. \\n # Convert the number to a Python int \\n # before serializing the object.\\n # The list of receptors is serialized when the FSPs are \\n # configured for a scan.\\n\\n device._receptors.append(int(receptorID))\\n device._proxies_assigned_vcc.append(vccProxy)\\n device._group_vcc.add(device._fqdn_vcc[vccID - 1])\\n\\n # subscribe to VCC state and healthState changes\\n event_id_state = vccProxy.subscribe_event(\\n \\\"State\\\",\\n tango.EventType.CHANGE_EVENT,\\n device._state_change_event_callback\\n )\\n\\n event_id_health_state = vccProxy.subscribe_event(\\n \\\"healthState\\\",\\n tango.EventType.CHANGE_EVENT,\\n device._state_change_event_callback\\n )\\n\\n device._events_state_change_vcc[vccID] = [event_id_state,\\n event_id_health_state]\\n else:\\n log_msg = \\\"Receptor {} already assigned to current subarray.\\\".format(\\n str(receptorID))\\n self.logger.warn(log_msg)\\n\\n except KeyError: # invalid receptor ID\\n errs.append(\\\"Invalid receptor ID: {}\\\".format(receptorID))\\n\\n\\n if errs:\\n msg = \\\"\\\\n\\\".join(errs)\\n self.logger.error(msg)\\n # tango.Except.throw_exception(\\\"Command failed\\\", msg, \\\"AddReceptors execution\\\",\\n # tango.ErrSeverity.ERR)\\n \\n return (ResultCode.FAILED, msg)\\n\\n message = \\\"CBFSubarray AddReceptors command completed OK\\\"\\n self.logger.info(message)\\n return (ResultCode.OK, message)\",\n \"def _multiprocess_handler(month_year):\\n trmm_data = TRMM_data(month_year)\\n trmm_data.load_creds()\\n if args.type == 's3_push':\\n trmm_data.data_fetch_netcdf()\\n elif args.type == 's3_pull':\\n trmm_data.data_pull_s3()\",\n \"def simplify_functions_parallel(expressions):\\n manager = multiprocessing.Manager()\\n return_dict = manager.dict()\\n\\n processes = []\\n factorised_expressions = []\\n for index, item in enumerate(expressions):\\n # print(\\\"item \\\", item, \\\"index\\\", index)\\n processes.append(multiprocessing.Process(target=bar, args=(item, index, return_dict)))\\n for p in processes:\\n p.start()\\n\\n for p in processes:\\n p.join()\\n\\n ## Showing the difference in an example:\\n # print(return_dict)\\n for i in sorted(return_dict.keys()):\\n factorised_expressions.append(return_dict[i])\\n return factorised_expressions\",\n \"def precompute_options_values_multipool(adj, skills, g):\\n import os\\n import multiprocessing\\n processes=[]\\n pool = multiprocessing.Pool(processes=len(skills))\\n out = pool.map(multi_pov, [['fsdfa', [skill], g] for skill in skills])\\n print out\\n rewards = np.zeros((4604, len(skills)))\\n dests = np.zeros((4604, len(skills)))\\n discounts = np.zeros((4604, len(skills)))\\n skill_vals_2 = np.zeros((4604, len(skills)))\\n skill_Zs_2 = np.zeros((4604, len(skills)))\\n if not os.path.exists('./povs/' + str(len(skills)) + '/' + str(skills[0][1])):\\n os.makedirs('./povs/' + str(len(skills)) + '/' + str(skills[0][1]))\\n names = ['rewards', 'dests', 'discounts', 'skill_vals_2', 'skill_Zs_2']\\n for n in range(len(skills)):\\n for index, array in enumerate([rewards, dests, discounts, skill_vals_2, skill_Zs_2]):\\n array[:, n] = out[n][index][:, 0]\\n if index == 1:\\n dests = np.array(dests, dtype='int')\\n np.save('./povs/' + str(len(skills)) + '/' + str(skills[0][1]) + '/' + str(names[index]), array)\\n return [rewards, dests, discounts, skill_vals_2, skill_Zs_2]\",\n \"def __init__(self, feature_store=None, batch_size=100):\\n if feature_store:\\n if type(feature_store) is dict: # A silly way to avoid multiple reading\\n self.features = feature_store\\n self.image_w = 640\\n self.image_h = 480\\n self.vfov = 60\\n self.feature_size = next(iter(self.features.values())).shape[-1]\\n # print('The feature size is %d' % self.feature_size)\\n else:\\n print('Image features not provided')\\n self.features = None\\n self.image_w = 640\\n self.image_h = 480\\n self.vfov = 60\\n self.featurized_scans = set([key.split(\\\"_\\\")[0] for key in list(self.features.keys())])\\n self.sims = []\\n self.qin = []\\n self.qout = []\\n self.qtraj = []\\n self.feature_states = None\\n self.batch_size = batch_size\\n for i in range(batch_size):\\n sim = MatterSim.Simulator()\\n sim.setRenderingEnabled(False)\\n sim.setDiscretizedViewingAngles(True) # Set increment/decrement to 30 degree. (otherwise by radians)\\n sim.setCameraResolution(self.image_w, self.image_h)\\n sim.setCameraVFOV(math.radians(self.vfov))\\n sim.init()\\n self.sims.append(sim)\\n\\n self.qin.append(Queue())\\n self.qout.append(Queue())\\n self.qtraj.append(Queue())\\n \\n self.pool = []\\n\\n def function(i, sim, qin, qout, qtraj):\\n env_actions = {\\n 'left': (0,-1, 0), # left\\n 'right': (0, 1, 0), # right\\n 'up': (0, 0, 1), # up\\n 'down': (0, 0,-1), # down\\n 'forward': (1, 0, 0), # forward\\n '<end>': (0, 0, 0), # <end>\\n '<start>': (0, 0, 0), # <start>\\n '<ignore>': (0, 0, 0) # <ignore>\\n }\\n while True:\\n op, x = qin.get()\\n \\n # while not qout.empty():\\n # qout.get()\\n # while not qtraj.empty():\\n # qtraj.get()\\n\\n if op == 'act':\\n select_candidate, src_point, trg_point, src_level, trg_level = x\\n traj = []\\n def take_action(i, name):\\n if type(name) is int: # Go to the next view\\n sim.makeAction(name, 0, 0)\\n else: # Adjust\\n sim.makeAction(*env_actions[name])\\n state = sim.getState()\\n \\n traj.append((state.location.viewpointId, state.heading, state.elevation))\\n \\n\\n while src_level < trg_level: # Tune up\\n take_action(i, 'up')\\n src_level += 1\\n while src_level > trg_level: # Tune down\\n take_action(i, 'down')\\n src_level -= 1\\n while sim.getState().viewIndex != trg_point: # Turn right until the target\\n take_action(i, 'right')\\n assert select_candidate['viewpointId'] == \\\\\\n sim.getState().navigableLocations[select_candidate['idx']].viewpointId\\n take_action(i, select_candidate['idx'])\\n\\n state = sim.getState()\\n qout.put((state.scanId, state.location.viewpointId, state.heading, state.elevation))\\n # print(traj)\\n qtraj.put(traj)\\n\\n elif op == 'new':\\n scanId, viewpointId, heading, elevation = x\\n sim.newEpisode(scanId, viewpointId, heading, elevation)\\n\\n elif op == 'state':\\n state = sim.getState()\\n state = State(state)\\n # if name != 'env':\\n # setattr(env_copy,name,value)\\n \\n qout.put(state)\\n\\n for i in range(batch_size):\\n p = Process(target=function, args=(i, self.sims[i], self.qin[i], self.qout[i], self.qtraj[i]), daemon=True)\\n \\n p.start()\\n self.pool.append(p)\",\n \"def __init__(self, state_size, action_size, random_seed=0):\\n self.state_size = state_size\\n self.action_size = action_size\\n self.seed = random.seed(random_seed)\\n\\n self.epsilon = EPSILON\\n\\n # Actor Network (w/ Target Network)\\n self.actor_local = Actor(state_size, action_size, random_seed, leakiness=LEAKINESS, kaiming=USEKAIMING).to(device)\\n self.actor_target = Actor(state_size, action_size, random_seed, leakiness=LEAKINESS, kaiming=USEKAIMING).to(device)\\n if OPTIM == \\\"AdamW\\\" and hasattr(optim,'AdamW'):\\n self.actor_optimizer = optim.AdamW(self.actor_local.parameters(), lr=LR_ACTOR)\\n else: \\n self.actor_optimizer = optim.Adam(self.actor_local.parameters(), lr=LR_ACTOR)\\n\\n # Critic Network (w/ Target Network)\\n self.critic_local = Critic(state_size, action_size, random_seed, leakiness=LEAKINESS, kaiming=USEKAIMING).to(device)\\n self.critic_target = Critic(state_size, action_size, random_seed, leakiness=LEAKINESS, kaiming=USEKAIMING).to(device)\\n if OPTIM == \\\"AdamW\\\" and hasattr(optim,'AdamW'):\\n self.critic_optimizer = optim.AdamW(self.critic_local.parameters(), lr=LR_CRITIC, weight_decay=AWEIGHT_DECAY)\\n else: \\n self.critic_optimizer = optim.Adam(self.critic_local.parameters(), lr=LR_CRITIC, weight_decay=WEIGHT_DECAY)\\n\\n # Noise process\\n self.noise = OUNoise(action_size, random_seed)\\n\\n # Replay memory\\n if not PRIORITIZED:\\n self.memory = ReplayBuffer(BUFFER_SIZE, BATCH_SIZE, random_seed)\\n else:\\n self.memory = NaivePrioritizedBuffer(BUFFER_SIZE, BATCH_SIZE, random_seed)\",\n \"def execute_objective(arguments):\\n #later call define_tr_val from within this function for speedup.\\n #score, pred_ = self.define_tr_val() #just get the train and test...\\n \\n\\n cv_samples, parallel_arguments, parameters, windowsOS, id_ = arguments\\n device = parallel_arguments[\\\"device\\\"]\\n declaration_args = parallel_arguments[\\\"declaration_args\\\"]\\n backprop_args = parallel_arguments[\\\"backprop_args\\\"]\\n #del declaration_args['reservoir']\\n\\n cv_args = parallel_arguments[\\\"cv_args\\\"]\\n log_score, rounds, tr_score_prop = cv_args[\\\"log_score\\\"], cv_args[\\\"rounds\\\"], cv_args[\\\"tr_score_prop\\\"]\\n\\n # if windowsOS == True:\\n # #move specific arguments to the gpu.\\n # cv_samples_ = []\\n # for i, cv_sample in enumerate(cv_samples):\\n # if cv_sample[\\\"tr_y\\\"].device != device:\\n # #if cv_sample[\\\"tr_x\\\"]:\\n # train_x, validate_x = cv_sample[\\\"tr_x\\\"].to(device), cv_sample[\\\"val_x\\\"].to(device)\\n\\n # train_y, validate_y = cv_sample[\\\"tr_y\\\"].to(device), cv_sample[\\\"val_y\\\"].to(device)\\n # else:\\n # #consider not sending the cv_sample[\\\"x\\\"] if it's a pure prediction.\\n # train_x, train_y = cv_sample[\\\"tr_x\\\"], cv_sample[\\\"tr_y\\\"]\\n # validate_x, validate_y = cv_sample[\\\"val_x\\\"], cv_sample[\\\"val_y\\\"]\\n # cv_samples_.append((train_x, train_y, validate_x, validate_y))\\n\\n # #now move the input weights and the reservoir arguments to the gpu.\\n # #deepcopy()\\n # assert declaration_args[\\\"reservoir\\\"] != None\\n # if declaration_args[\\\"reservoir\\\"] != None:\\n # declaration_args[\\\"reservoir\\\"].in_weights = declaration_args[\\\"reservoir\\\"].in_weights.to(device)\\n # declaration_args[\\\"reservoir\\\"].accept = declaration_args[\\\"reservoir\\\"].accept.to(device)\\n # declaration_args[\\\"reservoir\\\"].reservoir_pre_weights = declaration_args[\\\"reservoir\\\"].reservoir_pre_weights.to(device)\\n\\n # RC = EchoStateNetwork(**declaration_args, **parameters, id_ = id_)\\n \\n RC = EchoStateNetwork(**declaration_args, **parameters, id_ = id_)\\n cv_samples_ = []\\n for i, cv_sample in enumerate(cv_samples):\\n cv_samples_.append((cv_sample[\\\"tr_x\\\"], cv_sample[\\\"tr_y\\\"], cv_sample[\\\"val_x\\\"], cv_sample[\\\"val_y\\\"]))\\n\\n ODE_order = parallel_arguments[\\\"train_args\\\"][\\\"ODE_order\\\"]\\n\\n train_args = parallel_arguments[\\\"train_args\\\"]\\n test_args = parallel_arguments[\\\"test_args\\\"]\\n\\n total_score = 0\\n\\n backprop_f = backprop_args[\\\"backprop_f\\\"]\\n\\n if type(train_args[\\\"init_conditions\\\"][0]) == list:\\n multiple_ICs = True if len(train_args[\\\"init_conditions\\\"][0]) > 1 else False\\n else:\\n multiple_ICs = False\\n\\n for i, cv_sample in enumerate(cv_samples_):\\n #print(i)\\n train_x, train_y, validate_x, validate_y = cv_sample\\n\\n cv_sample_score = 0\\n\\n #divis = rounds *2\\n if ODE_order:\\n if multiple_ICs:\\n # if train_score:\\n # return {\\\"scores\\\" : scores, \\n # \\\"weights\\\": gd_weights, \\n # \\\"biases\\\" : gd_biases,\\n # \\\"ys\\\" : ys,\\n # \\\"ydots\\\" : ydots,\\n # \\\"losses\\\" : Ls}\\n dictt = RC.fit(X = train_x, y = train_y, train_score = True, **train_args)\\n train_scores = dictt[\\\"scores\\\"]\\n val_scores, pred_, id_ = RC.test(X=validate_x, y= validate_y, **test_args)\\n\\n \\n for i, train_score in enumerate(train_scores):\\n \\n train_scores[i] = process_score(train_score, device = device)\\n\\n val_score = process_score(val_scores[i], device = device)# / divis\\n\\n round_score = combine_score(train_score, val_score, tr_score_prop, log_score) \\n cv_sample_score += round_score \\n total_score += cv_sample_score\\n\\n else:\\n #train_score = RC.fit(X = train_x, y = train_y, train_score = True, **parallel_arguments[\\\"train_args\\\"])\\n results = RC.fit(X = train_x, y = train_y, train_score = True, **train_args)\\n train_scores = results[\\\"scores\\\"]\\n train_score = train_scores[0]\\n\\n train_score = process_score(train_score, device = device)# / divis\\n\\n val_scores, pred_, id_ = RC.test(X=validate_x, y= validate_y, **test_args)\\n val_score = process_score(val_scores[0], device = device)# / divis\\n\\n cv_sample_score = combine_score(train_score, val_score, tr_score_prop, log_score) \\n\\n \\n else:\\n _ = RC.fit(X = train_x, y = train_y,**parallel_arguments[\\\"train_args\\\"])\\n #train_score = process_score(train_score)\\n \\n val_score, pred_, id_ = RC.test(X=validate_x, y= validate_y, **parallel_arguments[\\\"test_args\\\"])\\n val_score = process_score(val_score)\\n\\n cv_sample_score = val_score #combine_score(train_score, val_score)\\n\\n #del train_x; del train_y;\\n #del validate_x;\\n\\n if id_ != 0:\\n del validate_y; del pred_;\\n\\n total_score += cv_sample_score\\n #if device == torch.device('cuda'):\\n # torch.cuda.empty_cache()\\n\\n #del RC;\\n #score_mu = total_score/len(cv_samples)\\n #del cv_samples;\\n nn = len(cv_samples_) * len(train_scores)\\n\\n total_score = total_score / nn\\n if id_ == 0:\\n try:\\n validate_y = validate_y.to(\\\"cpu\\\")\\n except:\\n pass\\n return float(total_score), {\\\"pred\\\": pred_.to(\\\"cpu\\\"), \\\"val_y\\\" : validate_y}, id_\\n else:\\n return float(total_score), None, id_\",\n \"def makeLargeTracts(input_queue, output_queue, config, db_config):\\n\\n \\n # capture the process name\\n my_name = mp.current_process().name\\n my_ip_address = socket.gethostbyname(socket.gethostname())\\n\\n while True:\\n try:\\n # get the next element out of the queue\\n inputs = input_queue.get()\\n try:\\n if inputs[0] is None: break\\n\\n # extract the terms from the queue list\\n numprov_path = inputs[0] \\n blockm_df = inputs[1] \\n out_tract_path = inputs[2] \\n out_county_path = inputs[3] \\n out_tract_df = inputs[4]\\n out_county_df = inputs[5] \\n start_time = inputs[6] \\n worker_speed = inputs[7]\\n config = inputs[8]\\n geom = 'geoid%s' % config['census_vintage'][2:]\\n\\n continue_run, block_numprov = openNumprovFile(numprov_path, geom, \\n my_name, my_ip_address, worker_speed, \\n start_time, output_queue)\\n\\n if continue_run:\\n continue_run, block_numprov = mergeWithDataFrame(\\n block_numprov, blockm_df, geom, my_name, \\n my_ip_address, worker_speed, start_time, \\n output_queue) \\n\\n if continue_run:\\n for geo in ['tract', 'county']:\\n continue_run, out_df = findPerCapitaProviders(my_name, \\n my_ip_address, geo, block_numprov, \\n output_queue, start_time, config, \\n worker_speed, eval('out_%s_df' % geo))\\n \\n if continue_run:\\n continue_run = outputGeoData(out_df, \\n eval('out_%s_path' % geo), my_name, \\n my_ip_address, geo, worker_speed, \\n start_time, output_queue)\\n\\n except:\\n pass\\n\\n except:\\n # nothing in the queue, wait and check again\\n time.sleep(1)\\n\\n return True\",\n \"def ExecuteInstanceStochasticAdaptiveRefinementAux_Functionality(current_global_index,pickled_coarse_model,pickled_coarse_project_parameters,pickled_custom_metric_refinement_parameters,pickled_custom_remesh_refinement_parameters,random_variable,current_index,current_analysis_stage,previous_computational_time,open_mp_threads,mapping_flag,pickled_mapping_reference_model,print_to_file,filename):\\n\\n start_time = time.time()\\n # unpickle model and build Kratos Model object\\n serialized_model = pickle.loads(pickled_coarse_model)\\n current_model = KratosMultiphysics.Model()\\n serialized_model.Load(\\\"ModelSerialization\\\",current_model)\\n del(serialized_model)\\n # unpickle parameters and build Kratos Parameters object\\n serialized_project_parameters = pickle.loads(pickled_coarse_project_parameters)\\n current_project_parameters = KratosMultiphysics.Parameters()\\n serialized_project_parameters.Load(\\\"ParametersSerialization\\\",current_project_parameters)\\n del(serialized_project_parameters)\\n # refine if current current_global_index > 0, adaptive refinement based on the solution of previous index\\n if (current_index > 0):\\n # unpickle metric and remesh refinement parameters and build Kratos Parameters objects\\n serialized_custom_metric_refinement_parameters = pickle.loads(pickled_custom_metric_refinement_parameters)\\n serialized_custom_remesh_refinement_parameters = pickle.loads(pickled_custom_remesh_refinement_parameters)\\n current_custom_metric_refinement_parameters = KratosMultiphysics.Parameters()\\n current_custom_remesh_refinement_parameters = KratosMultiphysics.Parameters()\\n serialized_custom_metric_refinement_parameters.Load(\\\"MetricRefinementParametersSerialization\\\",current_custom_metric_refinement_parameters)\\n serialized_custom_remesh_refinement_parameters.Load(\\\"RemeshRefinementParametersSerialization\\\",current_custom_remesh_refinement_parameters)\\n del(serialized_custom_metric_refinement_parameters,serialized_custom_remesh_refinement_parameters)\\n # refine the model Kratos object\\n adaptive_refinement_manager = AdaptiveRefinement(current_index,current_model,current_project_parameters,current_custom_metric_refinement_parameters,current_custom_remesh_refinement_parameters)\\n refined_model,refined_project_parameters = adaptive_refinement_manager.ComputeAdaptiveRefinement()\\n current_model = refined_model\\n del(refined_model,refined_project_parameters)\\n # constructor analysis stage\\n simulation = current_analysis_stage(current_model,current_project_parameters,random_variable)\\n # add filename flag print_to_file is true\\n if (print_to_file):\\n simulation.filename = filename\\n # add flag if current index is maximum index\\n if (current_index == current_global_index):\\n simulation.is_current_index_maximum_index = True\\n else:\\n simulation.is_current_index_maximum_index = False\\n # mapping if in current finest level and mapping flag is true\\n # otherwise standard behavior\\n if (mapping_flag is True and current_index == current_global_index):\\n # unpickle mapping reference model and build Kratos Model object\\n serialized_mapping_reference_model = pickle.loads(pickled_mapping_reference_model)\\n mapping_reference_model = KratosMultiphysics.Model()\\n serialized_mapping_reference_model.Load(\\\"ModelSerialization\\\",mapping_reference_model)\\n del(serialized_mapping_reference_model)\\n # send reference model to analysis stage for mapping and set mapping flag to true\\n simulation.mapping_reference_model = mapping_reference_model\\n simulation.mapping = True\\n simulation.Run()\\n # mapping if in current finest level and mapping flag is true\\n # otherwise standard qoi evaluation\\n if (mapping_flag is True and current_index == current_global_index):\\n qoi = simulation.MappingAndEvaluateQuantityOfInterest()\\n else:\\n qoi = simulation.EvaluateQuantityOfInterest()\\n # save model and parameters as MpiSerializer Kratos objects\\n serialized_finer_model = KratosMultiphysics.MpiSerializer()\\n serialized_finer_model.Save(\\\"ModelSerialization\\\",simulation.model)\\n # pickle model and parameters\\n pickled_finer_model = pickle.dumps(serialized_finer_model, 2) # second argument is the protocol and is NECESSARY (according to pybind11 docs)\\n del(simulation)\\n end_time = time.time()\\n computational_time = previous_computational_time + open_mp_threads*(end_time-start_time) # multiply by open mp threads to consider real machine cost\\n return qoi,pickled_finer_model,computational_time\",\n \"def make_processing_functions(self):\\n return\",\n \"def run(self):\\n #parse requests\\n self.bqSession.update_mex('Calculating Features...')\\n log.debug('Forming Feature Requests...')\\n #get rectanle gobjects for roi\\n r_xml = self.bqSession.fetchxml(self.options.mexURL, view='deep')\\n\\n rectangles = r_xml.xpath('//tag[@name=\\\"inputs\\\"]/tag[@name=\\\"image_url\\\"]/gobject[@name=\\\"roi\\\"]/rectangle')\\n image_xml = self.bqSession.fetchxml(self.options.image_url)\\n image_url = self.bqSession.service_url('image_service',path=image_xml.attrib['resource_uniq'])\\n if rectangles: #On chooses the first rectangle\\n #construct operation node\\n x1 = int(float(rectangles[0][0].attrib['x']))\\n y1 = int(float(rectangles[0][0].attrib['y']))\\n x2 = int(float(rectangles[0][1].attrib['x']))\\n y2 = int(float(rectangles[0][1].attrib['y']))\\n log.debug('Adding Crop: roi=%s,%s,%s,%s' % (x1, y1, x2, y2))\\n image_url = self.bqSession.c.prepare_url(image_url, roi='%s,%s,%s,%s' % (x1, y1, x2, y2))\\n \\n try:\\n feature_vectors = extract_bush_feature(self.bqSession, image_url)\\n except FeatureCommError as e:\\n raise BotanicamError(str(e))\\n \\n #parse features\\n self.bqSession.update_mex('Classifying Results...')\\n log.debug('Classifying Results...')\\n results= []\\n pca = joblib.load(os.path.join(self.model_path,'pca_model'))\\n clf = joblib.load(os.path.join(self.model_path,'svm_model'))\\n \\n for f in feature_vectors:\\n f_norm = pca.transform(f)\\n results.append(int(clf.predict(f_norm)))\\n \\n\\n class_count = np.bincount(np.array(results))\\n self.class_number = np.argmax(class_count)\\n self.confidence = float(class_count[self.class_number])/np.sum(class_count)\\n log.debug('Found Class %s'%str(self.class_number))\",\n \"def RUN_PULSAR(numTrials, rateMap, numPhotons=48,numPulsars = 6, angularSize=10.0, outputSize=100, mcList='MCOut.pickle',flatLevel = 0.0,HESS=False, Sig = -1,numProcs = 10):\\r\\n import FermiPSF, ParseFermi\\r\\n \\r\\n print 'Beginning MC Series\\\\nProgress'\\r\\n\\r\\n mcOut = []\\r\\n map = pickle.load(open(rateMap, \\\"r\\\" )) # load rate-map\\r\\n PSFTableFront = FermiPSF.PSF_130(convType='front') # load PSF front converting\\r\\n PSFTableBack = FermiPSF.PSF_130(convType='back') # load PSF back converting\\r\\n start = time.time();\\r\\n \\r\\n ppa = outputSize/angularSize # pixel per degree\\r\\n\\r\\n # Import background template\\r\\n bgmap = 'BGRateMap.pickle'\\r\\n if (HESS == True):\\r\\n bgmap = 'BGRateMap_HESS_2_deg.pickle'\\r\\n \\r\\n bgTemplate = pickle.load(open(bgmap , \\\"r\\\" ))\\r\\n \\r\\n mcOut = np.zeros(numTrials)\\r\\n p = pool.Pool(numProcs)\\r\\n partial_MC_PULSAR_THREAD = partial( MC_PULSAR_THREAD, map = map,bgTemplate=bgTemplate,PSFTableFront=PSFTableFront, PSFTableBack=PSFTableBack, HESS=HESS, angularSize=angularSize, numPhotons=numPhotons, outputSize=outputSize, numPulsars = numPulsars,Sig=Sig)\\r\\n mcOut = p.map(partial_MC_PULSAR_THREAD, mcOut)\\r\\n \\r\\n# for i in range(numTrials):\\r\\n# np.random.seed()\\r\\n# # Compute number of background photons\\r\\n# numSignal = np.random.poisson(lam = .25*numPhotons)\\r\\n# if (HESS == True):\\r\\n# numSignal = np.random.poisson(lam = .05*numPhotons)\\r\\n# if Sig >= 0:\\r\\n# numSignal = np.random.poisson(lam = Sig*numPhotons)\\r\\n# \\r\\n# bg = numPhotons-numSignal # number of BG photons\\r\\n# \\r\\n# # Build the background \\r\\n## background = Build_Background_Sideband(bgMean, lowSideband, highSideband, PSFTable)\\r\\n# background = Build_Background_Template(bg, bgTemplate, PSFTableFront, PSFTableBack ,HESS=HESS, angularSize = angularSize )\\r\\n# \\r\\n# \\r\\n# # Run MC for source photons \\r\\n# data = MC_PULSAR(map,numSignal, numPulsars,angularSize,outputSize,PSFTableFront, PSFTableBack, HESS = HESS)\\r\\n# # Concatenate and append this run to the simulation output\\r\\n# mcOut.append((data[0]+background[0], data[1]+background[1]))\\r\\n# \\r\\n# # Compute Speed Statistics\\r\\n# sys.stdout.write('\\\\r' + str(i+1)+'/'+str(numTrials)) \\r\\n# sys.stdout.flush()\\r\\n elapsed = time.time()-start;\\r\\n if (elapsed != 0.0):\\r\\n print '\\\\nSimulations Completed in', elapsed, 's', '(',numTrials/elapsed, ' sims per second)'\\r\\n \\r\\n outFile = open(mcList, \\\"wb\\\" )\\r\\n pickle.dump(mcOut, outFile)\\r\\n print 'Results saved to ', mcList\\r\\n return mcOut\",\n \"def get_all_leak(df, cols=None, nlags=15):\\r\\n df = df.copy()\\r\\n# print(df.head())\\r\\n# with Pool(processes=CPU_CORES) as p:\\r\\n if True:\\r\\n begin_ind = 0\\r\\n end_ind = 0\\r\\n leak_target = pd.Series(0, index = df.index)\\r\\n while begin_ind < nlags:\\r\\n end_ind = min(begin_ind + CPU_CORES, nlags)\\r\\n search_ind = (leak_target == 0)\\r\\n # print(search_ind)\\r\\n print('begin_ind: ', begin_ind, 'end_ind: ', end_ind, \\\"search_ind_len: \\\", search_ind.sum())\\r\\n# res = [p.apply_async(_get_leak, args=(df, cols, search_ind, i)) for i in range(begin_ind, end_ind)]\\r\\n# for r in res:\\r\\n# target_vals, lag = r.get()\\r\\n# # print ('target_vale', target_vals.head())\\r\\n# # leak_target[target_vals.index] = target_vals\\r\\n# df['leak_target_' + str(lag)] = target_vals\\r\\n target_vals, lag = _get_leak(df, cols, search_ind, begin_ind)\\r\\n df['leak_target_' + str(lag)] = target_vals\\r\\n for i in range(begin_ind, end_ind):\\r\\n leak_target[leak_target == 0] = df.loc[leak_target == 0, 'leak_target_' + str(i)]\\r\\n leak_train = 0 #leak_target[train.index]\\r\\n leak_train_len = 0 #leak_train[leak_train != 0].shape[0]\\r\\n leak_test_len = 0 #leak_target[test.index][leak_target != 0].shape[0]\\r\\n leak_train_right_len = 0 #leak_train[leak_train.round(0) == train['target'].round(0)].shape[0]\\r\\n leak_train_right_ratio = 0 #leak_train_right_len / leak_train_len\\r\\n if IsTrain:\\r\\n leak_train = leak_target[train.index]\\r\\n# print (leak_train.head())\\r\\n leak_train_len = leak_train[leak_train != 0].shape[0]\\r\\n leak_train_right_len = leak_train[leak_train.round(0) == train['target'].round(0)].shape[0]\\r\\n leak_train_right_ratio = leak_train_right_len / leak_train_len\\r\\n else:\\r\\n leak_test_len = leak_target[test.index][leak_target != 0].shape[0]\\r\\n print('Find leak in train and test: ', leak_train_len, leak_test_len, \\\\\\r\\n \\\"leak train right: \\\", leak_train_right_len, leak_train_right_ratio)\\r\\n begin_ind = end_ind\\r\\n # for i in range(nlags):\\r\\n # df.loc[df['leak_target'] == 0, 'leak_target'] = df.loc[df['leak_target'] == 0, 'leak_target_' + str(i)]\\r\\n df['leak_target'] = leak_target\\r\\n return df\",\n \"def preprocess(self):\",\n \"def optimization_step(self):\\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\\n \\n var_list = [self.x_tilda, self.minibatch_set]\\n \\n if (self.num_samples > 0) and (not self.mixture):\\n \\n if ((self.mf_steps > 0) and self.alpha >0) or\\\\\\n self.gibbs_steps > 0: \\n \\n var_list.append(self.sampler_theta)\\n \\n elif \\\"CD\\\" in self.algorithm:\\n \\n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \\n \\n var_list = [self.minibatch_set]\\n \\n var_list.append(self.learning_rate)\\n \\n if self.use_momentum:\\n \\n var_list.append(self.momentum)\\n \\n output_vars = [self.pseudo_cost]\\n \\n if self.report_p_tilda:\\n \\n output_vars.append(self.p_tilda)\\n \\n else:\\n \\n output_vars.append(theano.shared(0))\\n \\n opt_step = theano.function(inputs = var_list,\\n outputs = output_vars,\\n updates = self.updates,\\n givens = input_dict,\\n on_unused_input='warn')\\n \\n return opt_step\",\n \"def run_demultiplex_and_trim(self, opts, **kwargs):\\n \\n import logging\\n self.logger = logging.getLogger('demultip')\\n \\n sample_primer_dict = {}\\n \\n if not opts:\\n sys.exit(\\\"command line options not getting to main method\\\")\\n \\n metafile = opts.m\\n \\n # extract .gz to temp file location\\n if 'gzipFilename' in kwargs:\\n self.logger.info(\\\"Incoming kwargs detected...gzip file?\\\")\\n #sequence_file = kwargs.get('gzipFilename')\\n else:\\n self.logger.info(\\\"No kwargs, normal Fastq file\\\")\\n #sequence_file = opts.f\\n self.logger.info(\\\"processing {0} total sequences\\\".format(str((self.r1_tot+self.r2_tot)/4)))\\n self.logger.info(\\\"using the first {0} bases of primer in search\\\".format(self.search_length))\\n\\n \\n #extract the relevant data from the metadata file, can maybe change this to non-qiime1\\n self.logger.info(\\\"Getting header and mapping data...\\\")\\n header, mapping_data, run_description, errors, warnings = process_id_map(metafile)\\n self.logger.debug(\\\"metadata headers {0}\\\".format(header))\\n self.logger.debug(\\\"csv mapping data from {0}...\\\\n{1}\\\".format(metafile, \\\"\\\\n\\\".join([str(x) for x in mapping_data])))\\n \\n # get the primer regex search patterns\\n self.logger.info(\\\"Generating regex search patterns...\\\")\\n forward_primers, forward_primers_rc, reverse_primers, reverse_primers_rc = self.create_primer_regex_patterns(header, mapping_data)\\n self.primer_pattern_dict_list = {'fp' : forward_primers, 'fprc' : forward_primers_rc, 'rp' : reverse_primers, 'rprc' : reverse_primers_rc}\\n \\n \\n self.logger.debug(\\\"forward_primer patterns\\\\n{0}\\\\n\\\".format(\\\"\\\\n\\\".join([str(x.pattern) for x in self.primer_pattern_dict_list.get('fp')])))\\n self.logger.debug(\\\"reverse_primers patterns\\\\n{0}\\\\n\\\".format(\\\"\\\\n\\\".join([str(x.pattern) for x in self.primer_pattern_dict_list.get('rp')])))\\n \\n # replace all extra characters in header with underscore\\n intab = '.-+|=:;,&$'\\n outtab = '__________'\\n trantab = maketrans(intab, outtab)\\n \\n for samples in mapping_data:\\n try:\\n sample_primer_dict[samples[header.index('SampleID')].translate(trantab)] = (samples[header.index('LinkerPrimerSequence')], samples[header.index('ReversePrimer')])\\n except Exception as e:\\n self.logger.error(\\\"Can not find {0} in header fields, please make sure metadata file has the required fields\\\".format(e))\\n \\n self.logger.debug(\\\"sample_primer_dict...{0}\\\".format(\\\"\\\\n\\\".join(x) for x in sample_primer_dict.items()))\\n self.logger.info(\\\"Starting demultiplex process...\\\")\\n \\n bar = progressbar.ProgressBar(max_value=(self.r1_tot+self.r2_tot)/4,redirect_stdout=True)\\n \\n for r1, r2 in itertools.izip(self.R1.itervalues(), self.R2.itervalues()):\\n #self.logger.debug(\\\"r1 {0}\\\".format(r1))\\n #self.logger.debug(\\\"r2 {0}\\\".format(r1))\\n\\n pair_seq_dict = {'r1' : r1, 'r2' : r2}\\n self.logger.debug(\\\"new read pair\\\\n\\\")\\n self.logger.debug(\\\"processing new read pair {0}\\\".format(pair_seq_dict.keys()))\\n \\n self.logger.debug(\\\"processing seq ID - R1 {0}... R2 {1}\\\".format(r1.id, r2.id))\\n self.logger.debug(\\\"R1 sequence - {0}...\\\".format(r1.seq[0:50]))\\n self.logger.debug(\\\"R2 sequence - {0}...\\\".format(r2.seq[0:50]))\\n\\n self.sample_id = \\\"\\\"\\n # because we process two sequences at a time (R1 and R2)\\n self.processed_seqs += 2\\n\\n self.f_primer_found = []\\n self.r_primer_found = []\\n \\n self.logger.debug(\\\"Looking in pair read for patterns...\\\")\\n \\n search_result = self.regex_search_through_sequence(pair_seq_dict, self.primer_pattern_dict_list)\\n #self.logger.debug(\\\"pre read correction search_result - {0}\\\".format(search_result))\\n #search_result = self.correct_orientation_of_reads(search_result)\\n #self.logger.debug(\\\"post read correction search_result - {0}\\\".format(search_result))\\n \\n try:\\n if type(search_result) == list and len(search_result) > 1:\\n self.logger.debug(\\\"search result - {0}\\\".format(search_result[0]))\\n self.logger.debug(\\\"search result - {0}\\\".format(search_result[1]))\\n except IndexError as e:\\n self.logger.debug(\\\"search result - {0}\\\".format(search_result))\\n self.logger.debug(\\\"error in list index {0}\\\".format(e))\\n \\n \\n read_pair_proceed = self.screen_read_pair_suitability(search_result)\\n \\n self.logger.debug(\\\"proceed with read pair ? {0}\\\".format(read_pair_proceed))\\n \\n if read_pair_proceed != 'failed':\\n try:\\n sample_id = self.get_sample_id_from_primer_sequence(sample_primer_dict, \\n search_result[0].get('pattern'), \\n search_result[1].get('pattern'))\\n self.logger.debug(\\\"- R1 ID -> {0} & R2 ID -> {1} from sample {2}\\\".format(r1.id, r2.id, sample_id))\\n except IndexError as e:\\n # sample is missing one or both the patterns keys\\n self.logger.debug(\\\"Sample seq is missing a pattern, {0}- discarding read\\\".format(e))\\n output = self.record_buffer_and_writer({'discarded' : pair_seq_dict})\\n self.unmapped_count += 2\\n continue\\n try:\\n new_seq = self.clip_primers_from_seq(search_result, self.primer_pattern_dict_list, pair_seq_dict, sample_primer_dict, sample_id)\\n self.logger.debug(\\\"clipped read returned...{0} seqs\\\".format(len(new_seq)))\\n output = self.record_buffer_and_writer(new_seq)\\n self.both_primers_count += 2\\n except Exception as e:\\n output = self.record_buffer_and_writer({'discarded' : pair_seq_dict})\\n self.logger.debug(\\\"attempt to clip sequence failed - errmsg - {0} - discarding read {1}\\\".format(e, output))\\n self.unmapped_count += 2\\n continue\\n \\n bar.update(self.processed_seqs) \\n \\n if output == \\\"cleared\\\":\\n self.record_buffer = {}\\n self.logger.debug(\\\"buffer check {0}\\\".format(self.record_buffer))\\n\\n elif read_pair_proceed == 'failed':\\n self.unmapped_count += 2\\n output = self.record_buffer_and_writer({'discarded' : pair_seq_dict})\\n bar.update(self.processed_seqs) \\n \\n self.logger.info(\\\"__________________________\\\")\\n self.logger.info(\\\"Samples successfully mapped (F+R found): {0}\\\".format(self.both_primers_count))\\n self.logger.info(\\\"Read pairs in alternate orientation - {0}\\\".format(str(len(self.alternate_orientation))))\\n self.logger.info(\\\"Sequences not mapped: {0}\\\".format(self.unmapped_count))\\n self.logger.info(\\\"Total sequences checked: {0}\\\".format(self.processed_seqs))\\n \\n self.logger.info(\\\"writing alternate record IDs...\\\")\\n with open(\\\"alternate_orientation_records.txt\\\", 'w') as f:\\n for sequence_id in self.alternate_orientation:\\n output_id = ''.join(sequence_id)\\n f.write(output_id) \\n \\n self.logger.info(\\\"Run finished\\\")\",\n \"def _optimise_acquisition(acq_fn, acq_optimiser, anc_data):\\n return acq_optimiser(acq_fn, anc_data.max_evals)\",\n \"def max_pool_forward_naive(x, pool_param):\\n out = None\\n #############################################################################\\n # TODO: Implement the max pooling forward pass #\\n #############################################################################\\n pass\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n cache = (x, pool_param)\\n return out, cache\",\n \"def jit(func):\\n return func\",\n \"def REDS(mode):\\n #### configurations\\n read_all_imgs = False # whether real all images to memory with multiprocessing\\n # Set False for use limited memory\\n BATCH = 5000 # After BATCH images, lmdb commits, if read_all_imgs = False\\n if mode == 'train_sharp':\\n img_folder = '../../datasets/REDS/train_sharp'\\n lmdb_save_path = '../../datasets/REDS/train_sharp_wval.lmdb'\\n H_dst, W_dst = 720, 1280\\n elif mode == 'train_sharp_bicubic':\\n img_folder = '../../datasets/REDS/train_sharp_bicubic'\\n lmdb_save_path = '../../datasets/REDS/train_sharp_bicubic_wval.lmdb'\\n H_dst, W_dst = 180, 320\\n elif mode == 'train_blur_bicubic':\\n img_folder = '../../datasets/REDS/train_blur_bicubic'\\n lmdb_save_path = '../../datasets/REDS/train_blur_bicubic_wval.lmdb'\\n H_dst, W_dst = 180, 320\\n elif mode == 'train_blur':\\n img_folder = '../../datasets/REDS/train_blur'\\n lmdb_save_path = '../../datasets/REDS/train_blur_wval.lmdb'\\n H_dst, W_dst = 720, 1280\\n elif mode == 'train_blur_comp':\\n img_folder = '../../datasets/REDS/train_blur_comp'\\n lmdb_save_path = '../../datasets/REDS/train_blur_comp_wval.lmdb'\\n H_dst, W_dst = 720, 1280\\n elif mode == 'train_sharp_flowx4':\\n img_folder = '../../datasets/REDS/train_sharp_flowx4'\\n lmdb_save_path = '../../datasets/REDS/train_sharp_flowx4.lmdb'\\n H_dst, W_dst = 360, 320\\n n_thread = 40\\n ########################################################\\n if not lmdb_save_path.endswith('.lmdb'):\\n raise ValueError(\\\"lmdb_save_path must end with \\\\'lmdb\\\\'.\\\")\\n if osp.exists(lmdb_save_path):\\n print('Folder [{:s}] already exists. Exit...'.format(lmdb_save_path))\\n sys.exit(1)\\n\\n #### read all the image paths to a list\\n print('Reading image path list ...')\\n all_img_list = data_util._get_paths_from_images(img_folder)\\n keys = []\\n for img_path in all_img_list:\\n split_rlt = img_path.split('/')\\n folder = split_rlt[-2]\\n img_name = split_rlt[-1].split('.png')[0]\\n keys.append(folder + '_' + img_name)\\n\\n if read_all_imgs:\\n #### read all images to memory (multiprocessing)\\n dataset = {} # store all image data. list cannot keep the order, use dict\\n print('Read images with multiprocessing, #thread: {} ...'.format(n_thread))\\n pbar = util.ProgressBar(len(all_img_list))\\n\\n def mycallback(arg):\\n '''get the image data and update pbar'''\\n key = arg[0]\\n dataset[key] = arg[1]\\n pbar.update('Reading {}'.format(key))\\n\\n pool = Pool(n_thread)\\n for path, key in zip(all_img_list, keys):\\n pool.apply_async(read_image_worker, args=(path, key), callback=mycallback)\\n pool.close()\\n pool.join()\\n print('Finish reading {} images.\\\\nWrite lmdb...'.format(len(all_img_list)))\\n\\n #### create lmdb environment\\n data_size_per_img = cv2.imread(all_img_list[0], cv2.IMREAD_UNCHANGED).nbytes\\n print('data size per image is: ', data_size_per_img)\\n data_size = data_size_per_img * len(all_img_list)\\n env = lmdb.open(lmdb_save_path, map_size=data_size * 10)\\n\\n #### write data to lmdb\\n pbar = util.ProgressBar(len(all_img_list))\\n txn = env.begin(write=True)\\n for idx, (path, key) in enumerate(zip(all_img_list, keys)):\\n pbar.update('Write {}'.format(key))\\n key_byte = key.encode('ascii')\\n data = dataset[key] if read_all_imgs else cv2.imread(path, cv2.IMREAD_UNCHANGED)\\n if 'flow' in mode:\\n H, W = data.shape\\n assert H == H_dst and W == W_dst, 'different shape.'\\n else:\\n H, W, C = data.shape\\n assert H == H_dst and W == W_dst and C == 3, 'different shape.'\\n txn.put(key_byte, data)\\n if not read_all_imgs and idx % BATCH == 0:\\n txn.commit()\\n txn = env.begin(write=True)\\n txn.commit()\\n env.close()\\n print('Finish writing lmdb.')\\n\\n #### create meta information\\n meta_info = {}\\n meta_info['name'] = 'REDS_{}_wval'.format(mode)\\n channel = 1 if 'flow' in mode else 3\\n meta_info['resolution'] = '{}_{}_{}'.format(channel, H_dst, W_dst)\\n meta_info['keys'] = keys\\n pickle.dump(meta_info, open(osp.join(lmdb_save_path, 'meta_info.pkl'), \\\"wb\\\"))\\n print('Finish creating lmdb meta info.')\",\n \"def PPO(parclass):\\n class PPO(parclass):\\n \\\"\\\"\\\"\\n Proximal Policy Optimization algorithm (PPO).\\n Requires parent class inherited from A2C.\\n Based on: https://arxiv.org/abs/1707.06347\\n \\n Args:\\n ppo_clip - clipping rate of pi_new / pi_old fraction\\n epochs - number of epochs to run through rollout on each update\\n batch_size - size of mini-batch to select without replacement on each gradient ascent step\\n \\\"\\\"\\\"\\n __doc__ += parclass.__doc__\\n PARAMS = parclass.PARAMS | {\\\"ppo_clip\\\", \\\"epochs\\\", \\\"batch_size\\\"} \\n \\n def __init__(self, config):\\n super().__init__(config)\\n \\n self.config.setdefault(\\\"ppo_clip\\\", 0.2)\\n self.config.setdefault(\\\"epochs\\\", 3)\\n self.config.setdefault(\\\"batch_size\\\", 32)\\n \\n assert self.env.num_envs * self.config.rollout >= self.config.batch_size, \\\"batch_size is bigger than rollout * number of threads!\\\"\\n \\n def optimized_function(self):\\n # advantage is estimated using advantage function for previous policy\\n # so we take advantage from original rollout\\n advantages = (self.returns_b - self.old_values_b).detach() #self.advantages_b.detach() - КОСТЫЛЬ\\n \\n # importance sampling for making an update of current policy using samples from old policy\\n # the gradients to policy will flow through the numerator.\\n ratio = torch.exp(self.action_log_probs_b - self.old_action_log_probs_b.detach())\\n \\n # PPO clipping! Prevents from \\\"too high updates\\\".\\n surr1 = ratio * advantages\\n surr2 = torch.clamp(ratio, 1.0 - self.config.ppo_clip, 1.0 + self.config.ppo_clip) * advantages\\n return -torch.min(surr1, surr2)\\n \\n def update(self):\\n \\\"\\\"\\\"One step of optimization based on rollout memory\\\"\\\"\\\"\\n with torch.no_grad():\\n self.preprocess_rollout()\\n \\n # DEEP-RL TUTORIALS: КОСТЫЛЬ\\n #self.advantages = self.returns[:-1] - self.values[:-1]\\n #self.advantages = (self.advantages - self.advantages.mean()) / (self.advantages.std() + 1e-5)\\n \\n # going through rollout several (config.epochs) times:\\n for epoch in range(self.config.epochs):\\n # TODO: drop last = False? What if there is 1 sample?\\n sampler = BatchSampler(SubsetRandomSampler(range(self.env.num_envs * self.config.rollout)), self.config.batch_size, drop_last=False)\\n \\n for indices in sampler:\\n # retrieving new batch as part of rollout\\n self.returns_b = self.returns.view(-1, *self.config.value_repr_shape)[indices]\\n self.old_values_b = self.values.view(-1, *self.config.value_repr_shape)[indices]\\n self.old_action_log_probs_b = self.action_log_probs.view(-1)[indices]\\n #self.advantages_b = self.advantages.view(-1)[indices] # КОСТЫЛЬ\\n \\n # calculating current value, action_log_prob, entropy\\n dist, self.values_b = self.policy(self.observations.view(-1, *self.config.observation_shape)[indices])\\n self.values_b = self.values_b.squeeze() # IMPORTANT ([32] - [32, 1] problem)\\n self.action_log_probs_b = dist.log_prob(self.actions.view(-1, *self.config.actions_shape)[indices])#.sum(dim=-1) \\n self.entropy_b = dist.entropy()#.sum(dim=-1)\\n \\n # performing step\\n self.gradient_ascent_step()\\n return PPO\",\n \"def local_mediation(task):\\n\\tatlas = 'power'\\n\\tproject='hcp'\\n\\tknown_membership,network_names,num_nodes,name_int_dict = network_labels(atlas)\\n\\tsubjects = np.load('%s/dynamic_mod/results/%s_%s_%s_subs_fz.npy' %(homedir,'hcp',task,atlas))\\n\\tstatic_results = graph_metrics(subjects,task,atlas,run_version='fz')\\n\\tmatrices = static_results['matrices']\\n\\tsubject_pcs = static_results['subject_pcs']\\n\\tsubject_wmds = static_results['subject_wmds']\\n\\tsubject_mods = static_results['subject_mods']\\n\\tmod_wmd_corr = np.zeros(subject_wmds.shape[1])\\n\\tfor i in range(subject_pcs.shape[1]):\\n\\t\\tmod_wmd_corr[i] = nan_pearsonr(subject_mods,subject_wmds[:,i])[0]\\n\\tmean_conn = np.nanmean(matrices,axis=0)\\n\\te_tresh = np.percentile(mean_conn,85)\\n\\tsubject_wmds[np.isnan(subject_pcs)] = 0.0\\n\\tm = np.zeros((264,264,264))\\n\\tpool = Pool(40)\\n\\tfor n in range(264):\\n\\t\\tprint n\\n\\t\\tsys.stdout.flush()\\n\\t\\tvariables = []\\n\\t\\tfor i,j in combinations(range(264),2):\\n\\t\\t\\tvariables.append(pd.DataFrame(data={'pc':subject_wmds[:,n],'weight':matrices[:,i,j],'q':subject_mods},index=range(len(subject_pcs))))\\n\\t\\tresults = pool.map(multi_med,variables)\\n\\t\\tfor r,i in zip(results,combinations(range(264),2)):\\n\\t\\t\\tm[n,i[0],i[1]] = r\\n\\t\\t\\tm[n,i[1],i[0]] = r\\n\\t\\tnp.save('/home/despoB/mb3152/dynamic_mod/results/full_med_matrix_new_%s_wmds.npy'%(task),m)\",\n \"def MR1():\\n global CO1_OUTPUT, MR1_OUTPUT\\n\\n for b in range(MR1_OB):\\n for f in range(MR1_OF):\\n # Maxpool begins here\\n for r in range(MR1_OR):\\n for c in range(MR1_OC):\\n frame = np.zeros(4)\\n frame[0] = CO1_OUTPUT[b][f][r*2 ][c*2 ]\\n frame[1] = CO1_OUTPUT[b][f][r*2+1][c*2 ]\\n frame[2] = CO1_OUTPUT[b][f][r*2 ][c*2+1]\\n frame[3] = CO1_OUTPUT[b][f][r*2+1][c*2+1]\\n\\n # ReLU begins here\\n maximum = 0\\n for i in range(4):\\n if frame[i] > maximum:\\n maximum = frame[i]\\n\\n MR1_OUTPUT[b][f][r][c] = maximum\",\n \"def miniAOD_customizeMETFiltersFastSim(process):\\n for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter':\\n process.globalReplace(X, cms.EDFilter(\\\"HLTBool\\\", result=cms.bool(True))) \\n for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters':\\n process.globalReplace(X, cms.EDFilter(\\\"HLTBool\\\", result=cms.bool(False)))\\n return process\",\n \"def _process(self):\\n while True:\\n with Timer() as data_timer:\\n frame = self._frames_q.get()\\n\\n with Timer() as agent_timer:\\n s, frame_metadata = self._unwrap_frame(frame)\\n s = np.expand_dims(s, 0) # batch\\n act = self.pred(s)[0][0].argmax()\\n put_overwrite(self._actions_q, self._wrap_action(act, frame_metadata))\\n\\n print('.', end='', flush=True)\\n if self.verbose:\\n print('Avg data wait time: %.3f' % data_timer.time())\\n print('Avg agent neural net eval time: %.3f' % agent_timer.time())\",\n \"def handle_predictions(predict_fn, request_queue, response_queue):\\n loop_times = []\\n queue_get_times = []\\n handle_times = []\\n handle_start_times = []\\n # trial_start = datetime.now()\\n pred_count = 0\\n loop_count = 0\\n\\n # last_loop_start = datetime.now()\\n # loop_dur_file = \\\"/logs/loop_duration.log\\\"\\n # handle_dur_file = \\\"/logs/handle_duration.log\\\"\\n # handle_dur_file = \\\"/logs/handle_duration.log\\\"\\n\\n # Field order: clock_time, user time, sys time\\n # kernel_measures = False\\n # if not os.path.exists(\\\"/logs\\\"):\\n # os.makedirs(\\\"/logs\\\")\\n #\\n # kernel_instr_file = \\\"/logs/kernel_measures.csv\\\"\\n\\n # with open(loop_dur_file, \\\"w\\\") as ld, open(handle_dur_file, \\\"w\\\") as hd:\\n\\n # with open(kernel_instr_file, \\\"w\\\") as kd:\\n # kd.write(\\\"wall_clock_secs, user_clock_ticks, kernel_clock_ticks\\\\n\\\")\\n while True:\\n # cur_loop_start = datetime.now()\\n # loop_duration = (cur_loop_start - last_loop_start).microseconds\\n # loop_times.append(loop_duration)\\n # ld.write(\\\"{}\\\\n\\\".format(loop_duration))\\n # last_loop_start = cur_loop_start\\n\\n # t1 = datetime.now()\\n prediction_request, recv_time = request_queue.get(block=True)\\n # t2 = datetime.now()\\n # queue_get_times.append((t2 - t1).microseconds)\\n\\n # handle_start_times.append(time.time()*1000)\\n before_predict_lineage_point = datetime.now()\\n # proc_stat_before = check_output([\\\"cat\\\", \\\"/proc/1/stat\\\"]).strip().split()\\n # user_before = int(proc_stat_before[13])\\n # sys_before = int(proc_stat_before[14])\\n\\n\\n outputs = predict_fn(prediction_request.inputs)\\n # proc_stat_after = check_output([\\\"cat\\\", \\\"/proc/1/stat\\\"]).strip().split()\\n # user_after = int(proc_stat_after[13])\\n # sys_after = int(proc_stat_after[14])\\n\\n after_predict_lineage_point = datetime.now()\\n # clock_time = (after_predict_lineage_point - before_predict_lineage_point).total_seconds()\\n # user_time = user_after - user_before\\n # sys_time = sys_after - sys_before\\n # user_time = 0\\n # sys_time = 0\\n # kd.write(\\\"{clock},{user},{kernel}\\\\n\\\".format(clock=clock_time, user=user_time, kernel=sys_time))\\n\\n if loop_count <= 50 and loop_count % 10 == 0:\\n print((after_predict_lineage_point - before_predict_lineage_point).total_seconds())\\n\\n pred_count += len(prediction_request.inputs)\\n # t3 = datetime.now()\\n # handle_times.append((t3 - t2).microseconds)\\n # hd.write(\\\"{}\\\\n\\\".format((t3 - t2).microseconds))\\n # Type check the outputs:\\n if not type(outputs) == list:\\n raise PredictionError(\\\"Model did not return a list\\\")\\n if len(outputs) != len(prediction_request.inputs):\\n raise PredictionError(\\n \\\"Expected model to return %d outputs, found %d outputs\\\" %\\n (len(prediction_request.inputs), len(outputs)))\\n\\n outputs_type = type(outputs[0])\\n if outputs_type == np.ndarray:\\n outputs_type = outputs[0].dtype\\n if outputs_type not in SUPPORTED_OUTPUT_TYPES_MAPPING.keys():\\n raise PredictionError(\\n \\\"Model outputs list contains outputs of invalid type: {}!\\\".\\n format(outputs_type))\\n\\n if outputs_type == str:\\n for i in range(0, len(outputs)):\\n outputs[i] = unicode(outputs[i], \\\"utf-8\\\").encode(\\\"utf-8\\\")\\n else:\\n for i in range(0, len(outputs)):\\n outputs[i] = outputs[i].tobytes()\\n\\n total_length_elements = sum(len(o) for o in outputs)\\n\\n response = PredictionResponse(prediction_request.msg_id,\\n len(outputs), total_length_elements,\\n outputs_type)\\n for output in outputs:\\n response.add_output(output)\\n\\n response_queue.put((response, recv_time,\\n before_predict_lineage_point,\\n after_predict_lineage_point))\\n # response_queue.put((response, recv_time,\\n # None,\\n # None))\\n\\n # if len(loop_times) > 1000:\\n # print(\\\"\\\\nLoop duration: {} +- {}\\\".format(np.mean(loop_times), np.std(loop_times)))\\n # print(\\\"Request dequeue duration: {} +- {}\\\".format(np.mean(queue_get_times), np.std(queue_get_times)))\\n # print(\\\"Handle duration: {} +- {}\\\".format(np.mean(handle_times), np.std(handle_times)))\\n # # throughput = float(pred_count) / (datetime.now() - trial_start).total_seconds()\\n # # print(\\\"Throughput: {}\\\".format(throughput))\\n # # ld.flush()\\n # # hd.flush()\\n # # kd.flush()\\n #\\n # loop_times = []\\n # queue_get_times = []\\n # handle_times = []\\n # pred_count = 0\\n # trial_start = datetime.now()\\n\\n # if len(handle_start_times) % 200 == 0:\\n # print(json.dumps(handle_start_times))\\n loop_count += 1\\n sys.stdout.flush()\\n sys.stderr.flush()\",\n \"def preprocess(generator):\\n\\n def preprocess_decorator(method):\\n\\n @wrapper(method)\\n def preprocess_wrapper(self, *args, **kwargs):\\n self.increment_pc()\\n pc = tuple(self.program_counter)\\n try:\\n return self._pool.pop(pc), True\\n except KeyError:\\n key = (generator, args)\\n pcs = self._needed_data.setdefault(key, [])\\n pcs.append(pc)\\n self.fork_pc()\\n try:\\n return method(self, *args, **kwargs), False\\n finally:\\n self.unfork_pc()\\n\\n return preprocess_wrapper\\n return preprocess_decorator\",\n \"def with_cpu(ops, model):\\n ...\",\n \"def minimize(self):\\n pass\",\n \"def compute(self,n_speed,s_speed,msize,thershold):\\n X=self.image\\n for layer in self.CNN:\\n #layer dictonary {type,kernel,bias,hparams}\\n #offloading decisions\\n kernel=layer[\\\"kernel\\\"]\\n hparam=layer[\\\"hparams\\\"]\\n if layer[l_type]==\\\"conv\\\":\\n off_dec=offload(n_speed,s_speed,msize,X,kernel,hparam)\\n if(off_dec.checkOffload(thershold)):\\n #get the result form the server\\n conv_dict={ \\\"data\\\":X,\\\"l_type\\\":layer[l_type],\\\"hpara\\\":hparam,\\\"pos\\\":0}\\n c=client(conv_dict,self.edge[\\\"ip\\\"],self.edge[\\\"port\\\"])\\n c.send()\\n X=c.receive_array()\\n \\n else:\\n X=self.thread_Compute(X,layer)\\n\\n else:\\n X=self.thread_Compute(X,layer)\",\n \"def __init__(self, envs0, envs1, acmodel0, acmodel1, num_frames_per_proc, discount, lr, gae_lambda, entropy_coef,\\n value_loss_coef, max_grad_norm, recurrence, preprocess_obss, reshape_reward, aux_info):\\n # Store parameters\\n\\n self.env0 = ParallelEnv(envs0)\\n self.acmodel0 = acmodel0\\n self.acmodel0.train()\\n \\n self.env1 = ParallelEnv(envs1)\\n self.acmodel1 = acmodel1\\n self.acmodel1.train()\\n \\n self.num_frames_per_proc = num_frames_per_proc\\n self.discount = discount\\n self.lr = lr\\n self.gae_lambda = gae_lambda\\n self.entropy_coef = entropy_coef\\n self.value_loss_coef = value_loss_coef\\n self.max_grad_norm = max_grad_norm\\n self.recurrence = recurrence\\n self.preprocess_obss = preprocess_obss or default_preprocess_obss\\n self.reshape_reward = reshape_reward\\n self.aux_info = aux_info\\n\\n # Store helpers values\\n\\n self.device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n self.num_procs = len(envs0)\\n self.num_frames = self.num_frames_per_proc * self.num_procs\\n\\n\\n assert self.num_frames_per_proc % self.recurrence == 0\\n\\n # Initialize experience values\\n\\n shape = (self.num_frames_per_proc, self.num_procs)\\n\\n self.obs0 = self.env0.reset()\\n self.obss0 = [None]*(shape[0])\\n \\n self.obs1 = self.env1.reset()\\n self.obss1 = [None]*(shape[0])\\n\\n self.memory0 = torch.zeros(shape[1], self.acmodel0.memory_size, device=self.device)\\n self.memories0 = torch.zeros(*shape, self.acmodel0.memory_size, device=self.device)\\n \\n self.memory1 = torch.zeros(shape[1], self.acmodel1.memory_size, device=self.device)\\n self.memories1 = torch.zeros(*shape, self.acmodel1.memory_size, device=self.device)\\n \\n self.msg0 = torch.zeros( self.acmodel0.max_len_msg, shape[1], self.acmodel0.num_symbols, device=self.device)\\n self.msgs0 = torch.zeros(shape[0], self.acmodel0.max_len_msg, shape[1], self.acmodel0.num_symbols, device=self.device)\\n \\n self.msg1 = torch.zeros( self.acmodel1.max_len_msg, shape[1], self.acmodel1.num_symbols, device=self.device)\\n self.msgs1 = torch.zeros(shape[0], self.acmodel1.max_len_msg, shape[1], self.acmodel1.num_symbols, device=self.device)\\n \\n self.msgs_out0 = torch.zeros(shape[0], self.acmodel0.max_len_msg, shape[1], self.acmodel0.num_symbols, device=self.device)\\n \\n self.msgs_out1 = torch.zeros(shape[0], self.acmodel1.max_len_msg, shape[1], self.acmodel1.num_symbols, device=self.device)\\n\\n #self.rng_states0 = torch.zeros(*shape, *torch.get_rng_state().shape, dtype=torch.uint8)\\n #if torch.cuda.is_available():\\n # self.cuda_rng_states0 = torch.zeros(*shape, *torch.cuda.get_rng_state().shape, dtype=torch.uint8)\\n \\n #self.rng_states1 = torch.zeros(*shape, *torch.get_rng_state().shape, dtype=torch.uint8)\\n #if torch.cuda.is_available():\\n # self.cuda_rng_states1 = torch.zeros(*shape, *torch.cuda.get_rng_state().shape, dtype=torch.uint8)\\n \\n self.mask0 = torch.ones(shape[1], device=self.device)\\n self.masks0 = torch.zeros(*shape, device=self.device)\\n self.actions0 = torch.zeros(*shape, device=self.device, dtype=torch.int)\\n self.values0 = torch.zeros(*shape, device=self.device)\\n self.rewards0 = torch.zeros(*shape, device=self.device)\\n self.advantages0 = torch.zeros(*shape, device=self.device)\\n self.log_probs0 = torch.zeros(*shape, device=self.device)\\n self.speaker_log_probs0 = torch.zeros(*shape, device=self.device)\\n \\n self.mask1 = torch.ones(shape[1], device=self.device)\\n self.masks1 = torch.zeros(*shape, device=self.device)\\n self.actions1 = torch.zeros(*shape, device=self.device, dtype=torch.int)\\n self.values1 = torch.zeros(*shape, device=self.device)\\n self.rewards1 = torch.zeros(*shape, device=self.device)\\n self.advantages1 = torch.zeros(*shape, device=self.device)\\n self.log_probs1 = torch.zeros(*shape, device=self.device)\\n self.speaker_log_probs1 = torch.zeros(*shape, device=self.device)\\n\\n if self.aux_info:\\n self.aux_info_collector0 = ExtraInfoCollector(self.aux_info, shape, self.device)\\n self.aux_info_collector1 = ExtraInfoCollector(self.aux_info, shape, self.device)\\n\\n # Initialize log values\\n\\n self.log_episode_return0 = torch.zeros(self.num_procs, device=self.device)\\n self.log_episode_reshaped_return0 = torch.zeros(self.num_procs, device=self.device)\\n \\n self.log_episode_return1 = torch.zeros(self.num_procs, device=self.device)\\n self.log_episode_reshaped_return1 = torch.zeros(self.num_procs, device=self.device)\\n \\n self.log_episode_num_frames0 = torch.zeros(self.num_procs, device=self.device)\\n self.log_episode_num_frames1 = torch.zeros(self.num_procs, device=self.device)\\n\\n self.log_done_counter0 = 0\\n self.log_return0 = [0] * self.num_procs\\n self.log_reshaped_return0 = [0] * self.num_procs\\n self.log_num_frames0 = [0] * self.num_procs\\n \\n self.log_done_counter1 = 0\\n self.log_return1 = [0] * self.num_procs\\n self.log_reshaped_return1 = [0] * self.num_procs\\n self.log_num_frames1 = [0] * self.num_procs\\n \\n self.been_done0 = torch.zeros(self.num_procs, device=self.device)\\n self.been_done1 = torch.zeros(self.num_procs, device=self.device)\",\n \"def optimizermt(self,server_,port_): # 3\\n res,resargs = self.__obj.optimizermt(server_,port_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n _trmcode_return_value = resargs\\n _trmcode_return_value = rescode(_trmcode_return_value)\\n return _trmcode_return_value\",\n \"def opt_wrapper(m, **kwargs):\\r\\n m.optimize(**kwargs)\\r\\n return m.optimization_runs[-1]\",\n \"def task_process(args):\\n if args.mode == 'change model':\\n for i in range(config.center_len):\\n h, w = config.center_list[i][0], config.center_list[i][1]\\n os.system('rm -rf ctpn_change_{}x{}.onnx'.format(h, w))\\n for i in range(config.center_len):\\n h, w = config.center_list[i][0], config.center_list[i][1]\\n os.system('{} change_model.py --input_path={}/ctpn_{}x{}.onnx --output_path={}/ctpn_change_{}x{}.onnx' \\\\\\n .format(args.interpreter, args.src_dir, h, w,args.res_dir, h, w)) \\n if args.mode == 'preprocess':\\n for i in range(config.center_len):\\n os.system('mkdir -p {}_{}x{}'.format(args.res_dir, config.center_list[i][0], config.center_list[i][1]))\\n os.system('{} ctpn_preprocess.py --src_dir={} --save_path={}' \\\\\\n .format(args.interpreter, args.src_dir, args.res_dir))\\n if args.mode == 'ais_infer':\\n fps_all = 0\\n os.system('mkdir -p {}/inf_output'.format(args.res_dir))\\n for i in range(config.center_len):\\n h, w = config.center_list[i][0], config.center_list[i][1]\\n\\n os.system('{} --model={} --input={}_{}x{} --dymHW {},{} --device {} --batchsize={} --output={}/inf_output' \\\\\\n .format(args.interpreter, args.om_path, args.src_dir ,h , w, h, w,args.device, args.batch_size, args.res_dir))\\n\\n sumary_path = glob.glob('{}/inf_output/*ary.json'.format(args.res_dir))[0]\\n with open(sumary_path, 'r') as f:\\n output = json.load(f)\\n throughput = output['throughput'] \\n fps_all = fps_all + throughput * config.center_count[i]\\n os.system('rm -f {}'.format(sumary_path))\\n os.system('mv {}/inf_output/*/*.bin {}'.format(args.res_dir, args.res_dir))\\n os.system('rm {}/inf_output -rf'.format(args.res_dir))\\n fps_all = fps_all / config.imgs_len\\n print(\\\"====performance data====\\\")\\n print('CTPN bs{} models fps:{}'.format(args.batch_size, fps_all))\",\n \"def multi_run_wrapper(args):\\n\\treturn img_preprocessing(*args)\",\n \"def _remove_receptors_helper(self, argin):\\n receptor_to_vcc = dict([*map(int, pair.split(\\\":\\\"))] for pair in\\n self._proxy_cbf_controller.receptorToVcc)\\n for receptorID in argin:\\n if receptorID in self._receptors:\\n vccID = receptor_to_vcc[receptorID]\\n vccProxy = self._proxies_vcc[vccID - 1]\\n\\n # unsubscribe from events\\n vccProxy.unsubscribe_event(self._events_state_change_vcc[vccID][0]) # state\\n vccProxy.unsubscribe_event(self._events_state_change_vcc[vccID][1]) # healthState\\n del self._events_state_change_vcc[vccID]\\n del self._vcc_state[self._fqdn_vcc[vccID - 1]]\\n del self._vcc_health_state[self._fqdn_vcc[vccID - 1]]\\n\\n # reset receptorID and subarrayMembership Vcc attribute:\\n vccProxy.receptorID = 0\\n vccProxy.subarrayMembership = 0\\n\\n self._receptors.remove(receptorID)\\n self._proxies_assigned_vcc.remove(vccProxy)\\n self._group_vcc.remove(self._fqdn_vcc[vccID - 1])\\n else:\\n log_msg = \\\"Receptor {} not assigned to subarray. Skipping.\\\".format(str(receptorID))\\n self.logger.warn(log_msg)\\n\\n # transitions to EMPTY if not assigned any receptors\\n if not self._receptors:\\n self._update_obs_state(ObsState.EMPTY)\",\n \"def replay(i):\\n\\n i['module_uoa']=cfg['module_deps']['program.optimization']\\n i['module_ref_uoa']=work['self_module_uid']\\n i['module_cfg']=copy.deepcopy(cfg)\\n i['module_work']=copy.deepcopy(work)\\n return ck.access(i)\",\n \"def __init__process(self, n_cpu):\\n global shared_slices\\n global shared_data\\n\\n shared_slices_base = sharedctypes.RawArray(ctypes.c_double,\\n self._projection.shape[0])\\n shared_slices = np.frombuffer(shared_slices_base)\\n shared_slices = shared_slices.reshape((len(self._q.R), -1))\\n\\n shared_grad_base = sharedctypes.RawArray(ctypes.c_double,\\n self._projection.shape[0])\\n shared_grad = np.frombuffer(shared_grad_base)\\n shared_grad = shared_grad.reshape((len(self._q.R), -1))\\n\\n shared_data_base = mp.Array(ctypes.c_double,\\n self._data.size,\\n lock=False)\\n shared_data = np.ctypeslib.as_array(shared_data_base)\\n shared_data = shared_data.reshape(self._data.shape)\\n shared_data[:] = self._data\\n\\n self._pool = mp.Pool(n_cpu)\",\n \"def opt_wrapper(m, **kwargs):\\n m.optimize(**kwargs)\\n return m.optimization_runs[-1]\",\n \"def _apply_individual_nbody1_accumulate_python(\\n coeff: 'Nparray', ocoeff: 'Nparray', icoeff: 'Nparray',\\n amap: 'Nparray', btarget: 'Nparray', bsource: 'Nparray',\\n bparity: 'Nparray') -> None:\\n for sourcea, targeta, paritya in amap:\\n ocoeff[targeta, btarget] += coeff * paritya * numpy.multiply(\\n icoeff[sourcea, bsource], bparity)\",\n \"def vectorize(func, processes=1, on_complete=None):\\n if processes > 1:\\n return __multiprocess_wrapper(func, processes, on_complete)\\n else:\\n return single_process_wrapper(func, on_complete)\",\n \"def run(self, C, p0 = None):\\n global algorithm \\n algorithm = AdaptiveMM(self.g, C, p0 = p0, lambda0 = 2000)\\n solve()\",\n \"def processor2(readq, baseq, bamrcPath, ref_fasta, tumor_bam, bedfile, bedHeader, varList, annoList, ncpu):\\n\\n #create the region file for the first set of filtered variants\\n # use annovar's list because it already provides adjusted first and last positions of indels\\n \\n tfile = open('bamrc.region', 'w')\\n tvc_maf = []; tvc_depth = []\\n for el in annoList:\\n tfile.write('\\\\t'.join(el.split('\\\\t')[:5])+'\\\\n')\\n \\n \\n # store the TVC-reported MAF and depth for the variant in the T\\n # this will be used for those TVC variants that don't match with bam-readcount\\n for el in varList:\\n tvc_maf.append(float(el.split('\\\\t')[9])) \\n tvc_depth.append(int(el.split('\\\\t')[10]))\\n \\n tfile.close()\\n\\n\\n # get the expected length of reads supporting the variant\\n old_exprlenFile = '_tmp_/expected_readlen.txt'\\n if not os.path.exists(old_exprlenFile):\\n print \\\" Calculating estimated read length around the variant positions...\\\"\\n exp_readlen = expected_readlen(bedfile, bedHeader, annoList)\\n else:\\n print \\\" Expected read lengths already have been calculated, delete the old file _tmp_/expected_readlen.txt to recompute\\\"\\n with open(old_exprlenFile,'r') as rf:\\n exp_readlen = [float(line.strip()) for line in rf] \\n\\n\\n # run bam-readcount on the tumor bam file using the region file\\n oldbamrc_outfile = '_tmp_/bamrc.out'\\n \\n if not os.path.exists(oldbamrc_outfile):\\n execute_multiprocess(bamrcPath,'bamrc.region',tumor_bam,ref_fasta,ncpu)\\n \\n #command = '%s -q %s -b %s -d 2000 -l bamrc.region -f %s %s\\\\\\n # > bamrc.out 2>/dev/null' %(bamreadcount, readq, baseq, ref_fasta, tumor_bam)\\n #os.system(command)\\n \\n bamrc_outfile = 'bamrc.out'\\n else:\\n print \\\" bamrc has already been run, delete the bamrc.out file to rerun\\\"\\n bamrc_outfile = oldbamrc_outfile\\n\\n\\n ref = []; alt = []; fields = []; diff_q = []; diff_mmqs = []; diff_readlen = []; diffpos = []; altpos = []; dist3p = []; \\n alt_readlen_ = []; diff_expec_readlen = []; alt_depth = []; depth = []; alt_maf = []\\n\\n bases = ['A', 'C', 'G', 'T']\\n\\n with open('bamrc.region', 'r') as region:\\n ref = [line.split('\\\\t')[3] for line in region]\\n with open('bamrc.region', 'r') as region:\\n alt = [line.split('\\\\t')[4].strip('\\\\n')for line in region]\\n with open('bamrc.region', 'r') as region:\\n start = [line.split('\\\\t')[1] for line in region]\\n\\n # get the info from bam-readcount output % store as list\\n with open(bamrc_outfile, 'r') as bamread:\\n for line in bamread:\\n fields.append(line)\\n\\n #store the positions for all lines in bamrc out\\n bamrcpos = [int(line.split('\\\\t')[1]) for line in fields]\\n\\n\\n # if a variant position is very close to the amplicon edge, bam-readcount\\n # will not return any values, identify these variants; these should be potential\\n # FPs anyways\\n\\n missidx= []\\n with open('bamrc.region', 'r') as region:\\n idlist1 = ['_'.join(line.split('\\\\t')[:2]) for line in region]\\n with open(bamrc_outfile, 'r') as bamread:\\n idlist2 = ['_'.join(line.split('\\\\t')[:2]) for line in bamread]\\n\\n missingvars = list(set(idlist1) - set(idlist2))\\n missidx = [idlist1.index(var) for var in missingvars]\\n\\n #------------ the main loop -----------\\n\\n # extract the relevant metrics from bam-readcount file and\\n # append those into the existing info for the stage-1 filtered variants \\n\\n #------------ the main loop -----------\\n\\n linecount = 0 # counter for keeping track of variant's start position in bam-readcount output\\n\\n for idx in range(len(ref)):\\n #print idx,linecount \\n #--------- if amplicon-edge variants------------ \\n # set the metrics values to ridiculously high/low values so these \\n # will be filtered out later\\n\\n if idx in missidx:\\n diff_q.append('1000')\\n diff_mmqs.append('1000')\\n diff_readlen.append('1000')\\n altpos.append('0')\\n diffpos.append('1')\\n dist3p.append('1')\\n alt_readlen_.append('0')\\n alt_depth.append('0')\\n depth.append('1')\\n alt_maf.append('0')\\n diff_expec_readlen.append('100') \\n\\n \\n #-------------------------------------------------------\\n #------------------first deal with snps-----------------\\n #-------------------------------------------------------\\n\\n elif len(ref[idx]) == 1 and len(alt[idx]) == 1 and\\\\\\n ref[idx] != '-' and alt[idx] != '-':\\n depth.append(int(fields[linecount].split('\\\\t')[3]))\\n\\n for ib, base in enumerate(bases):\\n if ref[idx] == base:\\n stats = fields[linecount].split('\\\\t')[ib+5] # 6-9 columns are for A,C,G,T\\n ref_q = float(stats.split(':')[2])\\n ref_mmqs = float(stats.split(':')[9])\\n ref_readlen = float(stats.split(':')[-2])\\n refpos = float(stats.split(':')[7])\\n if alt[idx] == base:\\n stats = fields[linecount].split('\\\\t')[ib+5]\\n alt_q = float(stats.split(':')[2])\\n altpos.append(float(stats.split(':')[7]))\\n alt_mmqs = float(stats.split(':')[9])\\n alt_readlen = float(stats.split(':')[-2])\\n dist3p.append(float(stats.split(':')[-1]))\\n alt_depth.append(int(stats.split(':')[1]))\\n \\n diff_q.append(ref_q - alt_q)\\n diff_mmqs.append(alt_mmqs - ref_mmqs)\\n diff_readlen.append(ref_readlen - alt_readlen)\\n diffpos.append(refpos - altpos[idx])\\n alt_readlen_.append(alt_readlen)\\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-alt_readlen))\\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-ref_readlen))\\n \\n if int(depth[idx])>0:\\n alt_maf.append('%5.4f' %(alt_depth[idx]/depth[idx]))\\n else:\\n alt_maf.append('0.0')\\n\\n\\n #update the line no. to match the start of next variant in the bam-readcount output \\n linecount += 1\\n \\n\\n #-------------------------------------------------------\\n #--------------Multi Nucleotide Substitutions-----------\\n #-------------------------------------------------------\\n \\n elif len(ref[idx]) > 1 and (len(ref[idx]) == len(alt[idx])):\\n refb = list(ref[idx]) # ref. bases spanning\\n altb = list(alt[idx]) # alt. bases spanning\\n runlen = len(ref[idx]) # length of MNPs\\n\\n tot = len(fields[linecount].split('\\\\t')) #total tab-seprated fields\\n \\n depth_i = []; ref_q_i = []; ref_mmqs_i = []; ref_readlen_i = []; refpos_i = []\\n alt_q_i = []; alt_mmqs_i = []; alt_readlen_i = []; altpos_i = []; dist3p_i = []; alt_depth_i = []\\n npos = 0\\n\\n for jj in range(linecount,linecount+runlen):\\n npos += 1\\n #only get the stats for positions that are mismatches\\n if refb[npos-1] != altb[npos-1]:\\n depth_i.append(int(fields[jj].split('\\\\t')[3]))\\n for ib, base in enumerate(bases):\\n if refb[npos-1] == base:\\n stats = fields[jj].split('\\\\t')[ib+5]\\n ref_q_i.append(float(stats.split(':')[2]))\\n ref_mmqs_i.append(float(stats.split(':')[9]))\\n ref_readlen_i.append(float(stats.split(':')[-2]))\\n refpos_i.append(float(stats.split(':')[7]))\\n if altb[npos-1] == base: \\n stats = fields[jj].split('\\\\t')[ib+5]\\n alt_q_i.append(float(stats.split(':')[2]))\\n altpos_i.append(float(stats.split(':')[7]))\\n alt_mmqs_i.append(float(stats.split(':')[9]))\\n alt_readlen_i.append(float(stats.split(':')[-2]))\\n dist3p_i.append(float(stats.split(':')[-1]))\\n alt_depth_i.append(int(stats.split(':')[1]))\\n \\n depth.append(int(np.mean(depth_i)))\\n diff_q.append('%6.2f' %(np.mean(ref_q_i)-np.mean(alt_q_i)))\\n diff_mmqs.append('%6.2f' %(np.mean(alt_mmqs_i)-np.mean(ref_mmqs_i)))\\n diff_readlen.append('%6.2f' %(np.mean(ref_readlen_i) - np.mean(alt_readlen_i)))\\n altpos.append('%3.2f' %np.mean(altpos_i))\\n dist3p.append('%3.2f' %np.mean(dist3p_i))\\n diffpos.append('%3.2f' %(np.mean(refpos_i) - np.mean(altpos_i)))\\n alt_readlen_.append(np.mean(alt_readlen_i))\\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-np.mean(alt_readlen_i)))\\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\\n alt_depth.append(int(np.mean(alt_depth_i)))\\n\\n if int(depth[idx])>0:\\n alt_maf.append('%5.4f' %(alt_depth[idx]/depth[idx]))\\n else:\\n alt_maf.append('0.0')\\n\\n linecount += runlen \\n \\n\\n\\n #-------------------------------------------------------\\n #--------------- Insertions and substitution------------\\n #-------------------------------------------------------\\n \\n elif ref[idx] == '-' or \\\\\\n (len(alt[idx])-len(ref[idx])>0 and ref[idx] != '-'):\\n\\n runlen = len(ref[idx]) # length of the actual region \\n \\n # get the reference base/bases spanning these positions\\n if ref[idx] != '-':\\n refb = list(ref[idx]) \\n else:\\n refb = [fields[linecount].split('\\\\t')[2]]\\n \\n ref_q_i = []; ref_mmqs_i = []; ref_readlen_i = []; refpos_i = []\\n npos = 0\\n\\n for jj in range(linecount,linecount+runlen):\\n npos += 1\\n \\n for ib, base in enumerate(bases):\\n if refb[npos-1] == base:\\n stats = fields[jj].split('\\\\t')[ib+5].strip('\\\\n')\\n ref_q_i.append(float(stats.split(':')[2]))\\n ref_mmqs_i.append(float(stats.split(':')[9]))\\n ref_readlen_i.append(float(stats.split(':')[-2]))\\n refpos_i.append(float(stats.split(':')[7]))\\n \\n # stats for insertion reads\\n depth.append(int(fields[linecount].split('\\\\t')[3]))\\n tot = len(fields[linecount].split('\\\\t')) #total tab-seprated fields\\n\\n # get readcounts for all insertions at this position\\n # the insertions will be 11th & subsequent fields\\n counts = [int(fields[linecount].split('\\\\t')[j].split(':')[1]) for j in range(10,tot)]\\n \\n if len(counts) > 0:\\n # index of the most abundant insertion\\n ib = counts.index(max(counts)) + 10\\n \\n isnstats = fields[linecount].split('\\\\t')[ib].strip('\\\\n')\\n alt_q = float(isnstats.split(':')[2])\\n altpos.append(float(isnstats.split(':')[7]))\\n alt_mmqs = float(isnstats.split(':')[9])\\n alt_readlen = float(isnstats.split(':')[-2])\\n dist3p.append(float(isnstats.split(':')[-1]))\\n alt_depth.append(int(isnstats.split(':')[1]))\\n \\n diff_q.append('%6.2f' %(np.mean(ref_q_i) - alt_q))\\n diff_mmqs.append('%6.2f' %(alt_mmqs - np.mean(ref_mmqs_i)))\\n diffpos.append('%3.2f' %(np.mean(refpos_i) - altpos[idx]))\\n diff_readlen.append('%6.2f' %(np.mean(ref_readlen_i) - alt_readlen))\\n alt_readlen_.append(alt_readlen)\\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx]) - alt_readlen))\\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\\n\\n #for insertion total depth will be total depth + insertion depth\\n depth[idx] = depth[idx] + alt_depth[idx]\\n if int(depth[idx])>0:\\n alt_maf.append('%5.4f' %(alt_depth[idx]/depth[idx]))\\n else:\\n alt_maf.append('0.0')\\n\\n else:\\n ###determine the most abundant variant allele when no insertion is detected by bamrc\\n allelefields = fields[linecount].strip().split('\\\\t')[5:]\\n #index of the reference base at the 1st insertion position\\n refidx = [el.split(':')[0] for el in allelefields].index(refb[0])\\n\\n ref_q = float(allelefields[refidx].split(':')[2])\\n ref_mmqs = float(allelefields[refidx].split(':')[9])\\n ref_readlen = float(allelefields[refidx].split(':')[-2])\\n ref_pos = float(allelefields[refidx].split(':')[7])\\n\\n #remove ref. fields\\n allelefields.pop(refidx)\\n #max depth of non-reference alleles\\n maxdepth = max([int(el.split(':')[1]) for el in allelefields])\\n if int(maxdepth) > 0:\\n #variant allele (SNP) detected at this position\\n maxalleleidx = [int(el.split(':')[1]) for el in allelefields].index(maxdepth)\\n\\n alt_depth.append(int(allelefields[maxalleleidx].split(':')[1]))\\n alt_q = float(allelefields[maxalleleidx].split(':')[2])\\n alt_mmqs = float(allelefields[maxalleleidx].split(':')[9])\\n alt_readlen = float(allelefields[maxalleleidx].split(':')[-2])\\n altpos.append(float(allelefields[maxalleleidx].split(':')[7]))\\n dist3p.append(float(allelefields[maxalleleidx].split(':')[-1]))\\n\\n #alt_q_all.append(alt_q)\\n diff_q.append('%6.2f' %(ref_q - alt_q))\\n diff_mmqs.append('%6.2f' %(alt_mmqs - ref_mmqs))\\n diffpos.append('%3.2f' %(ref_pos - altpos[idx]))\\n diff_readlen.append('%6.2f' %(ref_readlen - alt_readlen))\\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-alt_readlen))\\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-ref_readlen))\\n else:\\n #no variant allele (SNP) detected at this position; set the metrics to '.'\\n altpos.append('.')\\n alt_depth.append('0')\\n diff_q.append('.')\\n diff_mmqs.append('.')\\n diff_readlen.append('.')\\n diffpos.append('.')\\n dist3p.append('.')\\n diff_expec_readlen.append('.')\\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\\n \\n if int(depth[idx])>0:\\n alt_maf.append('%5.4f' %(int(alt_depth[idx])/depth[idx]))\\n else: \\n alt_maf.append('0.0')\\n \\n linecount += runlen\\n \\n \\n #-------------------------------------------------------\\n #-----------------------Deletions------------------------\\n #--------------------------------------------------------\\n elif (alt[idx] == '-') or \\\\\\n (len(ref[idx]) > len(alt[idx]) and alt[idx] != '-'):\\n\\n runlen = len(ref[idx]) # length of the actual region\\n\\n #check if bamrc outputs QC for all positions, if not, correct for that\\n # this happens for really long positions where TVC reports deletion\\n templen = []\\n for k, g in groupby(enumerate(bamrcpos[linecount:linecount+runlen]), lambda (i,x):i-x):\\n group = map(itemgetter(1), g)\\n templen.append(len(group))\\n\\n #length of bps where bamrc computes metrics\\n bamrc_runlen = templen[0]\\n\\n if runlen == bamrc_runlen:\\n refb = list(ref[idx]) # reference bases spanning these positions\\n elif runlen > bamrc_runlen:\\n refb = list(ref[idx])[:bamrc_runlen] # reference bases spanning these positions\\n\\n runlen = bamrc_runlen\\n\\n ref_q_i = []; ref_mmqs_i = []; ref_readlen_i = []; refpos_i = []\\n npos = 0\\n\\n for jj in range(linecount,linecount+runlen):\\n npos += 1\\n \\n for ib, base in enumerate(bases):\\n if refb[npos-1] == base:\\n stats = fields[jj].split('\\\\t')[ib+5].strip('\\\\n')\\n ref_q_i.append(float(stats.split(':')[2]))\\n ref_mmqs_i.append(float(stats.split(':')[9]))\\n ref_readlen_i.append(float(stats.split(':')[-2]))\\n refpos_i.append(float(stats.split(':')[7]))\\n \\n # stats for deletion reads\\n depth.append(int(fields[linecount].split('\\\\t')[3]))\\n tot = len(fields[linecount].split('\\\\t')) #total tab-seprated fields\\n \\n # get readcounts for all deletions at the first position\\n counts = [int(fields[linecount].split('\\\\t')[j].split(':')[1]) for j in range(10,tot)]\\n \\n if len(counts) >0:\\n # index of the most abundant deletion\\n ib = counts.index(max(counts)) + 10\\n \\n delstats = fields[linecount].split('\\\\t')[ib].strip('\\\\n')\\n alt_q = float(delstats.split(':')[2])\\n altpos.append(float(delstats.split(':')[7]))\\n alt_mmqs = float(delstats.split(':')[9])\\n alt_readlen = float(delstats.split(':')[-2])\\n dist3p.append(float(delstats.split(':')[-1]))\\n alt_depth.append(int(delstats.split(':')[1]))\\n\\n diff_q.append('%6.2f' %(np.mean(ref_q_i) - alt_q))\\n diff_mmqs.append('%6.2f' %(alt_mmqs - np.mean(ref_mmqs_i)))\\n diffpos.append('%3.2f' %(np.mean(refpos_i) - altpos[idx]))\\n diff_readlen.append('%6.2f' %(np.mean(ref_readlen_i) - alt_readlen))\\n alt_readlen_.append(alt_readlen)\\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-alt_readlen))\\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\\n \\n if int(depth[idx])>0:\\n alt_maf.append('%5.4f' %(alt_depth[idx]/depth[idx]))\\n else:\\n alt_maf.append('0.0')\\n\\n else:\\n ###determine the most abundant variant allele when no deletion is detected by bamrc\\n allelefields = fields[linecount].strip().split('\\\\t')[5:]\\n #index of the reference base at the 1st deletion position\\n refidx = [el.split(':')[0] for el in allelefields].index(refb[0])\\n\\n ref_q = float(allelefields[refidx].split(':')[2])\\n ref_mmqs = float(allelefields[refidx].split(':')[9])\\n ref_readlen = float(allelefields[refidx].split(':')[-2])\\n ref_pos = float(allelefields[refidx].split(':')[7])\\n\\n #remove ref. fields\\n allelefields.pop(refidx)\\n #max depth of non-reference alleles\\n maxdepth = max([int(el.split(':')[1]) for el in allelefields])\\n if int(maxdepth) > 0:\\n #variant allele (SNP) detected at this position\\n maxalleleidx = [int(el.split(':')[1]) for el in allelefields].index(maxdepth)\\n\\n alt_depth.append(int(allelefields[maxalleleidx].split(':')[1]))\\n alt_q = float(allelefields[maxalleleidx].split(':')[2])\\n alt_mmqs = float(allelefields[maxalleleidx].split(':')[9])\\n alt_readlen = float(allelefields[maxalleleidx].split(':')[-2])\\n altpos.append(float(allelefields[maxalleleidx].split(':')[7]))\\n dist3p.append(float(allelefields[maxalleleidx].split(':')[-1]))\\n\\n #alt_q_all.append(alt_q)\\n diff_q.append('%6.2f' %(ref_q - alt_q))\\n diff_mmqs.append('%6.2f' %(alt_mmqs - ref_mmqs))\\n diffpos.append('%3.2f' %(ref_pos - altpos[idx]))\\n diff_readlen.append('%6.2f' %(ref_readlen - alt_readlen))\\n diff_expec_readlen.append('%6.2f' %(float(exp_readlen[idx])-alt_readlen))\\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-ref_readlen))\\n\\n else:\\n #no variant allele (SNP) detected at this position; set the metrics to '.'\\n altpos.append('.')\\n alt_depth.append('0')\\n diff_q.append('.')\\n diff_mmqs.append('.')\\n diff_readlen.append('.')\\n diffpos.append('.')\\n dist3p.append('.')\\n diff_expec_readlen.append('.')\\n #diff_expec_readlen.append('%3.2f' %(float(exp_readlen[idx])-np.mean(ref_readlen_i)))\\n \\n if int(depth[idx])>0:\\n alt_maf.append('%5.4f' %(int(alt_depth[idx])/depth[idx]))\\n else: \\n alt_maf.append('0.0')\\n \\n linecount += runlen\\n \\n #clean up temp files\\n #os.remove('temp.out')\\n #os.remove('temp.region')\\n \\n return diff_q, diff_mmqs, diff_readlen, altpos, diffpos, dist3p, alt_readlen_, diff_expec_readlen ,alt_maf, alt_depth,depth\",\n \"def optimize_parameters(self):\\n pass\",\n \"def optimize_parameters(self):\\n pass\",\n \"def optimize_parameters(self):\\n pass\",\n \"def main(self):\\n lines=open(self.expttxt,'r').readlines()\\n if self.parall:\\n pool=Pool(self.prod)\\n pool.map(self.mutatraj,lines)\\n pool.close()\\n pool.join()\\n else:\\n for line in lines:\\n self.mutatraj(line)\",\n \"def _pre_process_for_reg_model(\\n self, context: np.ndarray, action: np.ndarray, action_context: np.ndarray,\\n ) -> np.ndarray:\\n return np.c_[context, action_context[action]]\",\n \"def _pre_process_for_reg_model(\\n self, context: np.ndarray, action: np.ndarray, action_context: np.ndarray,\\n ) -> np.ndarray:\\n return np.c_[context, action_context[action]]\",\n \"def compute_batch(self, duplicate_manager=None,context_manager=None):\\n x = self.acquisition.optimize(duplicate_manager=duplicate_manager)[0]\\n return x\",\n \"def __init__(self, optimizer):\\n super(ShardedOptimizer, self).__init__(optimizer, name=\\\"ShardedOptimizer\\\")\",\n \"def optimize(self):\\n self.vbe_step()\\n self.compute_responsibilities()\\n self.compute_sufficient_stats()\\n self.vbmstep()\",\n \"def run_local_optimizer(self, local_optimizer_method,\\n use_input_initial_poses=False, respawn_when_counterex=True):\\n \\n mug_initial_poses = []\\n\\n if use_input_initial_poses:\\n mug_initial_poses = self.mug_initial_poses\\n else:\\n for i in range(self.num_mugs):\\n mug_initial_poses += \\\\\\n RollPitchYaw(np.random.uniform(0.0, 2.0*np.pi, size=3)).ToQuaternion().wxyz().tolist() + \\\\\\n [np.random.uniform(-0.1, 0.1), np.random.uniform(-0.1, 0.1), np.random.uniform(0.1, 0.2)]\\n\\n start_time = time.time()\\n\\n manager = Manager()\\n self.all_probabilities = manager.list()\\n self.total_iterations = manager.Value('d', 0)\\n num_counterexamples = manager.Value('d', 0)\\n model_number = manager.Value('d', 0)\\n model_number_lock = manager.Lock()\\n counter_lock = manager.Lock()\\n all_probabilities_lock = manager.Lock()\\n\\n file_q = manager.Queue()\\n folder_name = ''\\n\\n if local_optimizer_method == OptimizerType.NELDER_MEAD:\\n folder_name = os.path.join(self.package_directory, \\\"../data/optimization_comparisons/nelder_mead\\\")\\n elif local_optimizer_method == OptimizerType.SLSQP:\\n folder_name = os.path.join(self.package_directory, \\\"../data/optimization_comparisons/slsqp\\\")\\n\\n self.mug_pipeline.set_folder_names(folder_name)\\n self.mug_pipeline.set_optimizer_type(local_optimizer_method)\\n\\n pool = Pool(self.num_processes + 1, maxtasksperchild=30)\\n\\n filename = '{}/results.csv'.format(folder_name)\\n watcher = Process(target=self.listener, args=(file_q, filename))\\n watcher.start()\\n\\n try:\\n result = func_timeout(self.max_time, pool.starmap,\\n args=(self.run_local_optimizer_helper,\\n zip(repeat(local_optimizer_method),\\n range(self.num_processes), repeat(self.mug_pipeline), repeat(self.num_mugs),\\n repeat(self.all_probabilities), repeat(self.total_iterations),\\n repeat(num_counterexamples),\\n repeat(model_number), repeat(model_number_lock),\\n repeat(counter_lock), repeat(all_probabilities_lock),\\n repeat(file_q), repeat(use_input_initial_poses), repeat(mug_initial_poses),\\n repeat(respawn_when_counterex))))\\n except FunctionTimedOut:\\n elapsed_time = time.time() - start_time\\n print('ran for {} minutes! total number of iterations is {}, with {} sec/image'.format(\\n elapsed_time/60.0, self.total_iterations.value,\\n elapsed_time/self.total_iterations.value), flush=True)\\n\\n file_q.put('kill')\\n pool.terminate()\\n pool.join()\\n\\n end_time = time.time()\\n\\n print('probabilities:', self.all_probabilities, flush=True)\\n\\n sys.stdout.flush()\",\n \"def _worker_fn(example, transform):\\n feature = transform(example)\\n return feature\",\n \"def forward(self, x):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\\n x = F.relu(self.batch3a(self.conv3a(x)))\\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\\n x = F.relu(self.batch4a(self.conv4a(x)))\\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\\n x = F.relu(self.batch5a(self.conv5a(x)))\\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\\n x = self.avgpool(x)\\n x = x.reshape(x.shape[0], -1)\\n out = self.fc1(x)\\n\\n# raise NotImplementedError\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return out\",\n \"def __init__(self, model_source = None, train_log_dir = None, name = \\\"DNN2\\\", auto_reload = False, only_final=False, denorm_out=True): \\n super().__init__(name = name)\\n self.model_source = model_source\\n self.train_log_dir = train_log_dir\\n \\n self.feat_in_pipe_out, self.feat_in_pipe_in = multiprocessing.Pipe(False)\\n self.mapping_process = None\\n self.run_map = multiprocessing.Value('b', False)\\n self.auto_reload = auto_reload\\n self.observer = None\\n self.only_final = only_final\\n self.denorm_out = denorm_out\",\n \"def run(self):\\n\\t\\t## findMinError\\n\\t\\tself.count = 0\\n\\t\\tprint 'Starting Process type', self.ftype\\n\\t\\tself.min_error = 1\\n\\t\\t# it = 0\\n\\t\\t#self.threadnum = min(500, len(self.pool))\\n\\t\\trows = 3\\n\\t\\tself.threadnum = (len(self.pool)+2)/3\\n\\t\\trows = len(self.pool)/self.threadnum\\n\\t\\tlist_rowlists = [self.pool[x:x+rows] for x in xrange(0, len(self.pool), rows)]\\n\\t\\tmapper = SimpleMapReduce(self.MapFind, self.Reduce, num_workers=self.threadnum)\\n\\t\\tprint 'before mapper'\\n\\t\\tresult = mapper(list_rowlists)\\n\\t\\tprint result\\n\\t\\t#self.min_row, error_infor\\n\\n\\t\\tself.min_threshold = error_infor[0]\\n\\t\\tself.min_error = error_infor[1]\\n\\t\\tself.min_flag = error_infor[2]\\n\\t\\t# it += 1\\n\\t\\t# if it%10==0:\\n\\t\\t# \\tprint 'type'+str(self.ftype),\\\"{0:.1%}\\\".format(float(it)/len(self.pool)), ' search completed'\\n\\t\\treturn\",\n \"def __init__(self,\\n num_actions,\\n\\n tau,\\n alpha=1,\\n clip_value_min=-10,\\n\\n net_conf = None,\\n env = \\\"CartPole\\\", \\n normalize_obs = True,\\n hidden_layer=2, \\n neurons=512,\\n replay_scheme='prioritized',\\n noisy = False,\\n dueling = False,\\n initzer = 'xavier_uniform',\\n target_opt=0,\\n mse_inf=False,\\n network=networks.NatureDQNNetwork,\\n optimizer='adam',\\n epsilon_fn=dqn_agent.linearly_decaying_epsilon,\\n seed=None):\\n # We need this because some tools convert round floats into ints.\\n seed = int(time.time() * 1e6) if seed is None else seed\\n self._net_conf = net_conf\\n self._env = env \\n self._normalize_obs = normalize_obs\\n self._hidden_layer = hidden_layer\\n self._neurons=neurons \\n self._noisy = noisy\\n self._dueling = dueling\\n self._initzer = initzer\\n self._target_opt = target_opt\\n self._mse_inf = mse_inf\\n self._tau = tau\\n self._alpha = alpha\\n self._clip_value_min = clip_value_min\\n self._rng = jax.random.PRNGKey(seed)\\n\\n super(JaxDQNAgentNew, self).__init__(\\n num_actions= num_actions,\\n network= functools.partial(network, \\n num_actions=num_actions,\\n net_conf=self._net_conf,\\n env=self._env,\\n normalize_obs=self._normalize_obs,\\n hidden_layer=self._hidden_layer, \\n neurons=self._neurons,\\n noisy=self._noisy,\\n dueling=self._dueling,\\n initzer=self._initzer),\\n optimizer=optimizer,\\n epsilon_fn=dqn_agent.identity_epsilon if self._noisy == True else epsilon_fn)\\n\\n \\n self._replay_scheme = replay_scheme\",\n \"def prepare_so_condor_job(self, pool_type, pool_address, subtask_index=1, rank='0', extraArgs=''):\\n #New: only prepares a single job which allows multiple jobs to be queued\\n #We must change the ownership of each of the copasi files to the user running this script\\n #\\n #We assume that we have write privileges on each of the files through our group, but don't have permission to actually change ownership (must be superuser to do this)\\n #Thus, we workaround this by copying the original file, deleting the original, and moving the copy back to the original filename\\n \\n# import shutil\\n# for i in range(len(self.get_optimization_parameters())):\\n# for max in (0, 1):\\n# copasi_file = os.path.join(self.path, 'auto_copasi_%d.cps' % (2*i + max))\\n# temp_file = os.path.join(self.path, 'temp.cps')\\n# shutil.copy2(copasi_file, temp_file)\\n# os.remove(copasi_file)\\n# os.rename(temp_file, copasi_file)\\n# os.chmod(copasi_file, 0664) #Set as group readable and writable\\n \\n ############\\n #Build the appropriate .job files for the sensitivity optimization task, write them to disk, and make a note of their locations\\n condor_jobs = []\\n \\n copasi_file = 'auto_copasi_%d.$(Process).cps' % subtask_index\\n output_file = 'output_%d.$(Process).txt' % subtask_index\\n \\n n = len(self.get_optimization_parameters()) * 2\\n \\n if pool_type == 'ec2':\\n binary_dir = '/usr/local/bin'\\n transfer_executable = 'NO'\\n else:\\n binary_dir, binary = os.path.split(settings.COPASI_LOCAL_BINARY)\\n transfer_executable = 'YES'\\n \\n \\n condor_job_string = Template(condor_spec.raw_condor_job_string).substitute(copasiFile=copasi_file, \\n otherFiles='',\\n rank=rank,\\n binary_dir = binary_dir,\\n transfer_executable = transfer_executable,\\n pool_type = pool_type,\\n pool_address = pool_address,\\n subtask=str(subtask_index),\\n n = n,\\n outputFile = output_file,\\n extraArgs='',\\n )\\n \\n condor_job_filename = 'auto_condor_%d.job'%subtask_index\\n condor_job_full_filename = os.path.join(self.path, condor_job_filename)\\n condor_file = open(condor_job_full_filename, 'w')\\n condor_file.write(condor_job_string)\\n condor_file.close()\\n\\n return condor_job_filename\",\n \"def parallel(mech, predicate, nProcs, nTemps):\\n P = ct.one_atm\\n X = 'CH4:1.0, O2:1.0, N2:3.76'\\n pool = multiprocessing.Pool(processes=nProcs, \\n initializer=init_process, \\n initargs=(mech,))\\n\\n y = pool.map(predicate, \\n zip(itertools.repeat(mech),\\n np.linspace(300, 900, nTemps),\\n itertools.repeat(P),\\n itertools.repeat(X)))\\n return y\",\n \"def _fast_reduction(self, x_ori, best_position, q_times, auxiliary_inputs, gt_boxes, gt_labels, model):\\n LOGGER.info(TAG, 'Reduction begins...')\\n model = check_model('model', model, BlackModel)\\n x_ori = check_numpy_param('x_ori', x_ori)\\n _, gt_num = self._detection_scores((x_ori,) + auxiliary_inputs, gt_boxes, gt_labels, model)\\n best_position = check_numpy_param('best_position', best_position)\\n x_ori, best_position = check_equal_shape('x_ori', x_ori, 'best_position', best_position)\\n _, original_num = self._detection_scores((best_position,) + auxiliary_inputs, gt_boxes, gt_labels, model)\\n reduction_iters = 6 # recover 10% difference each time and recover 60% totally.\\n for _ in range(reduction_iters):\\n block_num = 30 # divide the image into 30 segments\\n block_width = best_position.shape[0] // block_num\\n if block_width > 0:\\n for i in range(block_num):\\n diff = x_ori[i*block_width: (i+1)*block_width, :, :]\\\\\\n - best_position[i*block_width:(i+1)*block_width, :, :]\\n if np.max(np.abs(diff)) >= 0.1*(self._bounds[1] - self._bounds[0]):\\n res = diff*0.1\\n best_position[i*block_width: (i+1)*block_width, :, :] += res\\n _, correct_num = self._detection_scores((best_position,) + auxiliary_inputs, gt_boxes,\\n gt_labels, model)\\n q_times += 1\\n if correct_num[0] > max(original_num[0], gt_num[0]*self._reserve_ratio):\\n best_position[i*block_width:(i+1)*block_width, :, :] -= res\\n return best_position, q_times\",\n \"def run_random(self):\\n manager = Manager()\\n self.all_probabilities = manager.list()\\n self.total_iterations = manager.Value('d', 0)\\n num_counterexamples = manager.Value('d', 0)\\n counter_lock = manager.Lock()\\n all_probabilities_lock = manager.Lock()\\n\\n file_q = manager.Queue()\\n\\n self.mug_pipeline.set_folder_names(self.folder_name)\\n self.mug_pipeline.set_optimizer_type(OptimizerType.RANDOM)\\n pool = Pool(self.num_processes + 1, maxtasksperchild=60)\\n\\n filename = '{}/logs/results_{}.csv'.format(self.folder_name, self.trial_folder)\\n watcher = Process(target=self.listener, args=(file_q, filename))\\n watcher.start()\\n\\n iter_num = 0\\n start_time = time.time()\\n max_time_per_map = 60*60\\n\\n try:\\n # TODO: change this from while true to terminate by timeout (try/except)\\n while ((self.retrain_with_random and self.total_iterations.value < self.max_added_to_training) or\\n (self.retrain_with_counterexamples and num_counterexamples.value < self.max_added_to_training)):\\n result = None\\n\\n while result is None:\\n try:\\n result = func_timeout(max_time_per_map, pool.starmap,\\n args=(self.mug_pipeline.run_inference,\\n zip(self.generate_all_mug_initial_poses(), \\n range(iter_num, iter_num + self.num_processes),\\n repeat(self.all_probabilities), repeat(all_probabilities_lock), \\n repeat(self.total_iterations), repeat(num_counterexamples),\\n repeat(counter_lock), repeat(file_q), repeat(False), repeat(False))))\\n except FunctionTimedOut:\\n print('FUNCTION TIMED OUT, MORE THAN {} SECONDS!!!!'.format(max_time_per_map))\\n\\n # all_mug_initial_poses = []\\n # for j in range(self.num_processes):\\n # mug_initial_poses = []\\n # for i in range(self.num_mugs):\\n # mug_initial_poses += \\\\\\n # RollPitchYaw(np.random.uniform(0.0, 2.0*np.pi, size=3)).ToQuaternion().wxyz().tolist() + \\\\\\n # [np.random.uniform(-0.1, 0.1), np.random.uniform(-0.1, 0.1), np.random.uniform(0.1, 0.2)]\\n # all_mug_initial_poses.append(mug_initial_poses)\\n\\n # result = pool.starmap(self.mug_pipeline.run_inference,\\n # zip(all_mug_initial_poses, \\n # range(iter_num, iter_num + self.num_processes),\\n # repeat(self.all_probabilities), repeat(all_probabilities_lock), \\n # repeat(self.total_iterations), repeat(num_counterexamples),\\n # repeat(counter_lock), repeat(file_q), repeat(False), repeat(False)))\\n\\n iter_num += self.num_processes\\n print('new iter_num: {}'.format(iter_num), flush=True)\\n total_min = (time.time() - start_time)/60.0\\n print('avg min/image: {}, total minutes: {}'.format(total_min/(iter_num + 1), total_min))\\n print('------------------------------------------------', flush=True)\\n sys.stdout.flush()\\n except Exception as e:\\n raise e\\n\\n pool.close()\\n pool.join()\\n\\n sys.stdout.flush()\",\n \"def post_processor(self):\",\n \"def main():\\n\\n # cProfile capitulation\\n # https://stackoverflow.com/questions/53890693/cprofile-causes-pickling-error-when-running-multiprocessing-python-code\\n import cProfile\\n if sys.modules['__main__'].__file__ == cProfile.__file__:\\n import qbic # re-import main (does *not* use cache or execute as __main__)\\n globals().update(vars(qbic)) # Replaces current contents with newly imported stuff\\n sys.modules['__main__'] = qbic # Ensures pickle lookups on __main__ find matching version\\n\\n\\n parser = argparse.ArgumentParser(description = 'TF Mutation Predictions')\\n parser.add_argument('-i', '--inputfile', action=\\\"store\\\", dest=\\\"inputfile\\\", type=str,\\n help='Input mutation file in .vcf, .tsv, .csv, or .txt format.')\\n parser.add_argument('-g', '--genefile', action=\\\"store\\\", dest=\\\"genefile\\\", type=str,\\n help='A file that contains all TF genes that are desired.')\\n parser.add_argument('-t', '--filetype', action=\\\"store\\\", dest=\\\"filetype\\\", type=str,\\n default=\\\"\\\", help='File type can specify: vcf, icgc, customseq, or mut')\\n parser.add_argument('-o', '--outpath', action=\\\"store\\\", dest=\\\"outpath\\\", type=str,\\n default=\\\"out.tsv\\\", help='name of the .tsv file that is made')\\n parser.add_argument('-f', '--filteropt', action=\\\"store\\\", dest=\\\"filteropt\\\", type=str,\\n default=\\\"p-value\\\", help='p-value or z-score')\\n parser.add_argument('-v', '--filterval', action=\\\"store\\\", dest=\\\"filterval\\\", type=float,\\n default=0.0001, help='# TFs for opt z-score and p-val cutoff for p-value')\\n parser.add_argument('-c', '--chrver', action=\\\"store\\\", dest=\\\"chrver\\\", type=str,\\n default=\\\"hg19\\\", help='Chromosome version, can be hg19 or hg38')\\n parser.add_argument('-E', '--escorespec', action=\\\"store\\\", dest=\\\"escorespec\\\", type=float,\\n default=0.4, help='PBM E-score specific cutoff.')\\n parser.add_argument('-e', '--escorenonspec', action=\\\"store\\\", dest=\\\"escorenonspec\\\", type=float,\\n default=0.35, help='PBM E-score non-specific cutoff.')\\n parser.add_argument('-n', '--numthreads', action=\\\"store\\\", dest=\\\"numthreads\\\", type=int,\\n default=None, help='Number of concurrent file I/O threads to use (per core)')\\n args = parser.parse_args()\\n\\n #python3 qbic.py -i testing_resources/single_mutations_sample.tsv -g testing_resources/gene_input.txt -c hg19\\n # input_mutation_test.vcf\\n # -t mut\\n #TfX E2F\\n\\n if not args.inputfile or not args.genefile:\\n raise Exception('-i (--inputfile) and -g (--genefile) are required')\\n\\n tbl = inittbl(args.inputfile, args.chrver, filetype = args.filetype)\\n\\n input_genes = parse_tfgenes(args.genesfile)\\n res = do_prediction(tbl, input_genes[\\\"pbms\\\"], input_genes[\\\"genes\\\"], args.filteropt, args.filterval,\\n args.escorespec, args.escorenonspec, args.numthreads)\\n\\n print(\\\"Writing output to %s\\\" % args.outpath)\\n res.to_csv(args.outpath, index = False, sep=\\\"\\\\t\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63033754","0.59346247","0.5667658","0.5634969","0.5632718","0.5520529","0.5416026","0.5395593","0.5282536","0.5226786","0.52209985","0.5219927","0.52054894","0.5177828","0.51697385","0.51571566","0.51315176","0.51257294","0.51191217","0.5107856","0.51049393","0.5102105","0.50983566","0.5094698","0.50909054","0.50909054","0.50909054","0.5079796","0.5077932","0.5067637","0.50626963","0.5051841","0.5023515","0.50001514","0.49744937","0.49622965","0.4953836","0.49491146","0.49471536","0.49419105","0.493869","0.49365184","0.49284938","0.49257004","0.4925544","0.4923745","0.4922614","0.49198174","0.49133673","0.49084145","0.4905098","0.49000373","0.48982358","0.48977882","0.48922065","0.48765782","0.48734087","0.48712662","0.4870746","0.48655936","0.48648226","0.48646313","0.48542115","0.4847419","0.48385355","0.4837862","0.4834218","0.48334265","0.48298863","0.4829696","0.48199773","0.48149008","0.48067173","0.48040915","0.4803892","0.48014942","0.4800477","0.4794471","0.47868812","0.47786865","0.4772208","0.4772208","0.4772208","0.47708586","0.47582695","0.47582695","0.47581178","0.47540894","0.47519428","0.47511658","0.4750551","0.47459197","0.474385","0.4741428","0.47388837","0.47344685","0.47342467","0.4734001","0.4727721","0.47187337","0.4716643"],"string":"[\n \"0.63033754\",\n \"0.59346247\",\n \"0.5667658\",\n \"0.5634969\",\n \"0.5632718\",\n \"0.5520529\",\n \"0.5416026\",\n \"0.5395593\",\n \"0.5282536\",\n \"0.5226786\",\n \"0.52209985\",\n \"0.5219927\",\n \"0.52054894\",\n \"0.5177828\",\n \"0.51697385\",\n \"0.51571566\",\n \"0.51315176\",\n \"0.51257294\",\n \"0.51191217\",\n \"0.5107856\",\n \"0.51049393\",\n \"0.5102105\",\n \"0.50983566\",\n \"0.5094698\",\n \"0.50909054\",\n \"0.50909054\",\n \"0.50909054\",\n \"0.5079796\",\n \"0.5077932\",\n \"0.5067637\",\n \"0.50626963\",\n \"0.5051841\",\n \"0.5023515\",\n \"0.50001514\",\n \"0.49744937\",\n \"0.49622965\",\n \"0.4953836\",\n \"0.49491146\",\n \"0.49471536\",\n \"0.49419105\",\n \"0.493869\",\n \"0.49365184\",\n \"0.49284938\",\n \"0.49257004\",\n \"0.4925544\",\n \"0.4923745\",\n \"0.4922614\",\n \"0.49198174\",\n \"0.49133673\",\n \"0.49084145\",\n \"0.4905098\",\n \"0.49000373\",\n \"0.48982358\",\n \"0.48977882\",\n \"0.48922065\",\n \"0.48765782\",\n \"0.48734087\",\n \"0.48712662\",\n \"0.4870746\",\n \"0.48655936\",\n \"0.48648226\",\n \"0.48646313\",\n \"0.48542115\",\n \"0.4847419\",\n \"0.48385355\",\n \"0.4837862\",\n \"0.4834218\",\n \"0.48334265\",\n \"0.48298863\",\n \"0.4829696\",\n \"0.48199773\",\n \"0.48149008\",\n \"0.48067173\",\n \"0.48040915\",\n \"0.4803892\",\n \"0.48014942\",\n \"0.4800477\",\n \"0.4794471\",\n \"0.47868812\",\n \"0.47786865\",\n \"0.4772208\",\n \"0.4772208\",\n \"0.4772208\",\n \"0.47708586\",\n \"0.47582695\",\n \"0.47582695\",\n \"0.47581178\",\n \"0.47540894\",\n \"0.47519428\",\n \"0.47511658\",\n \"0.4750551\",\n \"0.47459197\",\n \"0.474385\",\n \"0.4741428\",\n \"0.47388837\",\n \"0.47344685\",\n \"0.47342467\",\n \"0.4734001\",\n \"0.4727721\",\n \"0.47187337\",\n \"0.4716643\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":10492,"cells":{"query":{"kind":"string","value":"test the performance of the brute force and the Monte Carlo method"},"document":{"kind":"string","value":"def performance_test(Ns=15, Nr=3):\n num = 2**Ns\n hs = np.random.random(Ns)\n model = LibraryBinaryNumeric(Ns, Nr, hs)\n \n start = time.time()\n model.mutual_information_brute_force()\n time_brute_force = time.time() - start\n print('Brute force: %g sec' % time_brute_force)\n \n start = time.time()\n model.mutual_information_monte_carlo(num)\n time_monte_carlo = time.time() - start\n print('Monte carlo: %g sec' % time_monte_carlo)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def main():\n hash_str = '5411ba21c470e12d49f351a2d240e43618032950'\n salt = '0d71906d0f735e6196c80d0a7cb1748e'\n encrypted_code = 'Ul5SR0ISYFxUXl8OOxITFBFWVlIRQVtRXV4bHQs4ExQREhMUERJDRlhcRxwWZltdQhJaRxFTE0BUQUcUXF1XQV1XFB07EhMUE' \\\n 'RITFBFCQV1fRhsTZVdAQBFhRldSV0BHV0dfGhYbOQ=='\n bruter = CodeBrute(hash_str, salt)\n start = timer()\n _key, iterations = bruter.brute()\n print('Found', _key)\n print('Attempts:', iterations)\n elapsed = timer() - start\n print('Time:', elapsed)\n bruter.decrypt_and_execute(encrypted_code, str(_key))","def bruteForceTime():\n start_time = time.time()\n subjects = loadSubjects(SUBJECT_FILENAME)\n maxWork = 8\n answer = bruteForceAdvisor(subjects, maxWork)\n end_time = time.time()\n printSubjects(answer)\n print 'Time taken: ', end_time - start_time\n return None","def main():\r\n _evaluative_test(5)\r\n _fuzz_test(1)\r\n _fuzz_test(1, 512)\r\n _fuzz_test(1, 1512)\r\n _fuzz_test(1000)\r\n _fuzz_test(1000, 512)\r\n _fuzz_test(1000, 4077)","def test_run_sim():\n rnd = rand.Arrivals(31, 40)\n sim.run_sim(2, 1, 3, 4, 24, rnd)","def mbruteforce(func, alphabet, length, method = 'upto', start = None, threads = None):\n\n def bruteforcewrap(func, alphabet, length, method, start, databag):\n oldloglevel = context.log_level\n context.log_level = 'critical'\n res = bruteforce(func, alphabet, length, method=method, start=start, databag=databag)\n context.log_level = oldloglevel\n databag[\"result\"] = res\n\n if start == None:\n start = (1, 1)\n\n if threads == None:\n try:\n threads = multiprocessing.cpu_count()\n except NotImplementedError:\n threads = 1\n\n h = log.waitfor('MBruteforcing')\n processes = [None] * threads\n shareddata = [None] * threads\n\n (i2, N2) = start\n totalchunks = threads * N2\n\n for i in range(threads):\n shareddata[i] = multiprocessing.Manager().dict()\n shareddata[i]['result'] = None\n shareddata[i]['current_item'] = \"\"\n shareddata[i]['items_done'] = 0\n shareddata[i]['items_total'] = 0\n\n chunkid = (i2-1) + (i * N2) + 1\n\n processes[i] = multiprocessing.Process(target=bruteforcewrap,\n args=(func, alphabet, length, method, (chunkid, totalchunks),\n shareddata[i]))\n processes[i].start()\n\n done = False\n\n while not done:\n # log status\n current_item_list = \",\".join([\"\\\"%s\\\"\" % x[\"current_item\"]\n for x in shareddata if x != None])\n items_done = sum([x[\"items_done\"] for x in shareddata if x != None])\n items_total = sum([x[\"items_total\"] for x in shareddata if x != None])\n\n progress = 100.0 * items_done / items_total if items_total != 0 else 0.0\n\n h.status('Trying %s -- %0.3f%%' % (current_item_list, progress))\n\n # handle finished threads\n for i in range(threads):\n if processes[i] and processes[i].exitcode != None:\n # thread has terminated\n res = shareddata[i][\"result\"]\n processes[i].join()\n processes[i] = None\n\n # if successful, kill all other threads and return success\n if res != None:\n for i in range(threads):\n if processes[i] != None:\n processes[i].terminate()\n processes[i].join()\n processes[i] = None\n h.success('Found key: \"%s\"' % res)\n return res\n\n if all([x == None for x in processes]):\n done = True\n time.sleep(0.3)\n h.failure('No matches found')","def _brute_force(self):\n if self.N > 9:\n #print(\"Input set is too big for brute force estimation.\")\n self.best_path = None\n else:\n #print(\"Number of permutations to check: {}\".format(math.factorial(self.N)))\n #init = \n A = self._P + np.finfo(np.float).eps\n A = (A + (1-A).T)/2\n for i in range(A.shape[0]):\n A[i,i] = np.finfo(np.float).eps\n init = (A>0.5).sum(axis=1).argsort()[::-1]\n #--- use log(p(Y=1\\mid s',s)) to shift multiplication to sum\n lP = np.log(A)\n for i in range(lP.shape[0]):\n lP[i,i] = 0\n #init_cost = 0\n ##--- lP[x:x+1] está MAL hay que sumar respecto a i+1 en z, no en lP.\n #for i in range(len(init)-1):\n # init_cost += lP[init[i],init[i+1]:].sum()\n z_star = []\n z_cost = -np.inf\n for z in permutations(range(self.N)):\n cost = 0\n for i in range(len(z)-1):\n cost += lP[z[i],z[i+1:]].sum()\n if cost > z_cost:\n z_cost = cost\n z_star = z\n self.best_path = np.array(z_star)","def test_run_sim_1():\n rnd = rand.Arrivals(36, 41)\n sim.run_sim(3, 2, 5, 6, 22, rnd)","def brute_force(city_list):\n start = time.time()*1000\n shortest = exhaustive_search(city_list,6)\n stop = time.time()*1000\n print(\"Shortest tour for 6 first cities:\", tour_distance(shortest))\n print (\"Time spent on 6 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\"-\")\n \n start = time.time()*1000\n shortest = exhaustive_search(city_list,7)\n stop = time.time()*1000\n print(\"Shortest tour for 7 first cities:\", tour_distance(shortest))\n print (\"Time spent on 7 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\"-\")\n \n start = time.time()*1000\n shortest = exhaustive_search(city_list,8)\n stop = time.time()*1000\n print(\"Shortest tour for 8 first cities:\", tour_distance(shortest))\n print (\"Time spent on 8 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\"-\")\n \n start = time.time()*1000\n shortest = exhaustive_search(city_list,9)\n stop = time.time()*1000\n print(\"Shortest tour for 9 first cities:\", tour_distance(shortest))\n print (\"Time spent on 9 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\"-\")\n \n start = time.time()*1000\n shortest = exhaustive_search(city_list,10)\n stop = time.time()*1000\n print(\"Shortest tour for 10 first cities:\", tour_distance(shortest))\n print (\"Time spent on 10 first cities:\", \"%.2f\" % (stop-start), \"ms\")\n print(\" \")","def evaluate_all_points():\n start_time = timeit.default_timer()\n mua, vra = pgen.get_pdf()\n slack = ptsl.D\n\n all_alloc = list(itertools.product(range(1,ptsl.M+1),repeat=ptsl.NPH))\n riska = []\n f2 = open(\"risk-file-D216-NPH5.csv\",\"w\")\n f2.write(\"alloc1,alloc2,alloc3,alloc4,alloc5,risk,util\\n\")\n count = 0\n for a in all_alloc :\n a1, a2, a3, a4, a5 = a\n r = compute_risk(mua, vra, a, slack)\n \n if r > 0.00001 and r < 1 - 0.00001 :\n riska.append(r)\n util = a1 * mua[a1-1] + a2 * mua[a2-1] + a3 * mua[a3-1] + a4 * mua[a4-1] + a5 * mua[a5-1]\n f2.write(\"%d,%d,%d,%d,%d,%f,%f\\n\"%(a1,a2,a3,a4,a5,r,util))\n count = count + 1\n f2.close()\n np.save(\"stored_risk\",riska)\n elapsed = timeit.default_timer() - start_time\n print(\"Brute Force Evaluation Time for %d points : %fs\"%(count,elapsed))","def test_bottleneck(self):\n # import the experiment variable from the example\n exp = bottleneck_example(20, 5, render=False)\n\n # run the experiment for a few time steps to ensure it doesn't fail\n exp.run(1, 5)","def bruteforce(func, alphabet, length, method = 'upto', start = None, databag = None):\n\n if method == 'upto' and length > 1:\n iterator = product(alphabet, repeat = 1)\n for i in xrange(2, length + 1):\n iterator = chain(iterator, product(alphabet, repeat = i))\n\n elif method == 'downfrom' and length > 1:\n iterator = product(alphabet, repeat = length)\n for i in xrange(length - 1, 1, -1):\n iterator = chain(iterator, product(alphabet, repeat = i))\n\n elif method == 'fixed':\n iterator = product(alphabet, repeat = length)\n\n else:\n raise TypeError('bruteforce(): unknown method')\n\n if method == 'fixed':\n total_iterations = len(alphabet) ** length\n else:\n total_iterations = (len(alphabet) ** (length + 1) / (len(alphabet) - 1)) - 1\n\n if start is not None:\n i, N = start\n if i > N:\n raise ValueError('bruteforce(): invalid starting point')\n\n i -= 1\n chunk_size = total_iterations / N\n rest = total_iterations % N\n starting_point = 0\n\n for chunk in range(N):\n if chunk >= i:\n break\n if chunk <= rest:\n starting_point += chunk_size + 1\n else:\n starting_point += chunk_size\n\n if rest >= i:\n chunk_size += 1\n\n total_iterations = chunk_size\n\n h = log.waitfor('Bruteforcing')\n cur_iteration = 0\n if start != None:\n consume(i, iterator)\n for e in iterator:\n cur = ''.join(e)\n cur_iteration += 1\n if cur_iteration % 2000 == 0:\n progress = 100.0 * cur_iteration / total_iterations\n h.status('Trying \"%s\", %0.3f%%' % (cur, progress))\n if databag:\n databag[\"current_item\"] = cur\n databag[\"items_done\"] = cur_iteration\n databag[\"items_total\"] = total_iterations\n res = func(cur)\n if res:\n h.success('Found key: \"%s\"' % cur)\n return cur\n if start != None:\n consume(N - 1, iterator)\n\n h.failure('No matches found')","def test_stress(self):\n primorial100 = 4711930799906184953162487834760260422020574773409675520188634839616415335845034221205289256705544681972439104097777157991804380284218315038719444943990492579030720635990538452312528339864352999310398481791730017201031090\n for i in range(10000):\n self.assertEqual(primorial(100), primorial100)","def speed():\r\n\r\n algo = ['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp',\r\n 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']\r\n to_exec = [True] * len(algo)\r\n# to_exec = [False] * len(algo)\r\n# to_exec[-1] = True\r\n do_float64 = True\r\n do_float32 = True\r\n do_gpu = True\r\n\r\n algo_executed = [s for idx, s in enumerate(algo) if to_exec[idx]]\r\n #Timming expected are from the buildbot that have an i7-920 @\r\n # 2.67GHz with hyperthread enabled for the cpu, 12G of ram. An GeForce GTX\r\n # 285 for the GPU. OS=Fedora 14, gcc=4.5.1, python/BLAS from EPD\r\n # 7.1-2 (python 2.7.2, mkl unknow). BLAS with only 1 thread.\r\n\r\n expected_times_64 = numpy.asarray([10.0, 22.5, 76.1, 73.7, 116.4,\r\n 346.9, 381.9, 558.1, 186.3])\r\n expected_times_32 = numpy.asarray([11.6, 29.6, 42.5, 66.5, 71,\r\n 191.2, 226.8, 432.8, 176.2])\r\n\r\n # Number with just 1 decimal are new value that are faster with\r\n # the Theano version 0.5rc2 Other number are older. They are not\r\n # updated, as we where faster in the past!\r\n # TODO: find why and fix this!\r\n\r\n# Here is the value for the buildbot on February 3th 2012.\r\n# sgd, cg mlp conv da\r\n# sda dbn rbm\r\n# gpu times[3.72957802, 9.94316864, 29.1772666, 9.13857198, 25.91144657,\r\n# 18.30802011, 53.38651466, 285.41386175]\r\n# expected [3.076634879, 7.555234910, 18.99226785, 9.58915591, 24.130070450,\r\n# 24.77524018, 92.66246653, 322.340329170]\r\n# sgd, cg mlp conv da\r\n# sda dbn rbm\r\n#expected/get [0.82492841, 0.75984178, 0.65092691, 1.04930573, 0.93125138\r\n# 1.35324519 1.7356905 1.12937868]\r\n expected_times_gpu = numpy.asarray([3.07663488, 7.55523491, 18.99226785,\r\n 9.6, 24.13007045,\r\n 20.4, 56, 302.6, 315.4])\r\n expected_times_64 = [s for idx, s in enumerate(expected_times_64)\r\n if to_exec[idx]]\r\n expected_times_32 = [s for idx, s in enumerate(expected_times_32)\r\n if to_exec[idx]]\r\n expected_times_gpu = [s for idx, s in enumerate(expected_times_gpu)\r\n if to_exec[idx]]\r\n\r\n def time_test(m, l, idx, f, **kwargs):\r\n if not to_exec[idx]:\r\n return\r\n print algo[idx]\r\n ts = m.call_time\r\n try:\r\n f(**kwargs)\r\n except Exception, e:\r\n print >> sys.stderr, 'test', algo[idx], 'FAILED', e\r\n l.append(numpy.nan)\r\n return\r\n te = m.call_time\r\n l.append(te - ts)\r\n\r\n def do_tests():\r\n m = theano.compile.mode.get_default_mode()\r\n l = []\r\n time_test(m, l, 0, logistic_sgd.sgd_optimization_mnist, n_epochs=30)\r\n time_test(m, l, 1, logistic_cg.cg_optimization_mnist, n_epochs=30)\r\n time_test(m, l, 2, mlp.test_mlp, n_epochs=5)\r\n time_test(m, l, 3, convolutional_mlp.evaluate_lenet5, n_epochs=5,\r\n nkerns=[5, 5])\r\n time_test(m, l, 4, dA.test_dA, training_epochs=2,\r\n output_folder='tmp_dA_plots')\r\n time_test(m, l, 5, SdA.test_SdA, pretraining_epochs=1,\r\n training_epochs=2, batch_size=300)\r\n time_test(m, l, 6, DBN.test_DBN, pretraining_epochs=1,\r\n training_epochs=2, batch_size=300)\r\n time_test(m, l, 7, rbm.test_rbm, training_epochs=1, batch_size=300,\r\n n_chains=1, n_samples=1, output_folder='tmp_rbm_plots')\r\n time_test(m, l, 8, rnnrbm.test_rnnrbm, num_epochs=1)\r\n return numpy.asarray(l)\r\n\r\n #test in float64 in FAST_RUN mode on the cpu\r\n import theano\r\n if do_float64:\r\n theano.config.floatX = 'float64'\r\n theano.config.mode = 'FAST_RUN'\r\n float64_times = do_tests()\r\n print >> sys.stderr, algo_executed\r\n print >> sys.stderr, 'float64 times', float64_times\r\n print >> sys.stderr, 'float64 expected', expected_times_64\r\n print >> sys.stderr, 'float64 % expected/get', (\r\n expected_times_64 / float64_times)\r\n\r\n #test in float32 in FAST_RUN mode on the cpu\r\n theano.config.floatX = 'float32'\r\n if do_float32:\r\n float32_times = do_tests()\r\n print >> sys.stderr, algo_executed\r\n print >> sys.stderr, 'float32 times', float32_times\r\n print >> sys.stderr, 'float32 expected', expected_times_32\r\n print >> sys.stderr, 'float32 % expected/get', (\r\n expected_times_32 / float32_times)\r\n\r\n if do_float64:\r\n print >> sys.stderr, 'float64/float32', (\r\n float64_times / float32_times)\r\n print >> sys.stderr\r\n print >> sys.stderr, 'Duplicate the timing to have everything in one place'\r\n print >> sys.stderr, algo_executed\r\n print >> sys.stderr, 'float64 times', float64_times\r\n print >> sys.stderr, 'float64 expected', expected_times_64\r\n print >> sys.stderr, 'float64 % expected/get', (\r\n expected_times_64 / float64_times)\r\n print >> sys.stderr, 'float32 times', float32_times\r\n print >> sys.stderr, 'float32 expected', expected_times_32\r\n print >> sys.stderr, 'float32 % expected/get', (\r\n expected_times_32 / float32_times)\r\n\r\n print >> sys.stderr, 'float64/float32', (\r\n float64_times / float32_times)\r\n print >> sys.stderr, 'expected float64/float32', (\r\n expected_times_64 / float32_times)\r\n\r\n #test in float32 in FAST_RUN mode on the gpu\r\n import theano.sandbox.cuda\r\n if do_gpu:\r\n theano.sandbox.cuda.use('gpu')\r\n gpu_times = do_tests()\r\n print >> sys.stderr, algo_executed\r\n print >> sys.stderr, 'gpu times', gpu_times\r\n print >> sys.stderr, 'gpu expected', expected_times_gpu\r\n print >> sys.stderr, 'gpu % expected/get', (\r\n expected_times_gpu / gpu_times)\r\n\r\n if do_float64:\r\n print >> sys.stderr, 'float64/gpu', float64_times / gpu_times\r\n\r\n if (do_float64 + do_float32 + do_gpu) > 1:\r\n print >> sys.stderr\r\n print >> sys.stderr, 'Duplicate the timing to have everything in one place'\r\n print >> sys.stderr, algo_executed\r\n if do_float64:\r\n print >> sys.stderr, 'float64 times', float64_times\r\n print >> sys.stderr, 'float64 expected', expected_times_64\r\n print >> sys.stderr, 'float64 % expected/get', (\r\n expected_times_64 / float64_times)\r\n if do_float32:\r\n print >> sys.stderr, 'float32 times', float32_times\r\n print >> sys.stderr, 'float32 expected', expected_times_32\r\n print >> sys.stderr, 'float32 % expected/get', (\r\n expected_times_32 / float32_times)\r\n if do_gpu:\r\n print >> sys.stderr, 'gpu times', gpu_times\r\n print >> sys.stderr, 'gpu expected', expected_times_gpu\r\n print >> sys.stderr, 'gpu % expected/get', (\r\n expected_times_gpu / gpu_times)\r\n\r\n if do_float64 and do_float32:\r\n print >> sys.stderr, 'float64/float32', (\r\n float64_times / float32_times)\r\n print >> sys.stderr, 'expected float64/float32', (\r\n expected_times_64 / float32_times)\r\n if do_float64 and do_gpu:\r\n print >> sys.stderr, 'float64/gpu', float64_times / gpu_times\r\n print >> sys.stderr, 'expected float64/gpu', (\r\n expected_times_64 / gpu_times)\r\n if do_float32 and do_gpu:\r\n print >> sys.stderr, 'float32/gpu', float32_times / gpu_times\r\n print >> sys.stderr, 'expected float32/gpu', (\r\n expected_times_32 / gpu_times)\r\n\r\n def compare(x, y):\r\n ratio = x / y\r\n # If there is more then 5% difference between the expected\r\n # time and the real time, we consider this an error.\r\n return sum((ratio < 0.95) + (ratio > 1.05))\r\n\r\n if do_float64:\r\n err = compare(expected_times_64, float64_times)\r\n print >> sys.stderr, 'speed_failure_float64=' + str(err)\r\n if do_float32:\r\n err = compare(expected_times_32, float32_times)\r\n print >> sys.stderr, 'speed_failure_float32=' + str(err)\r\n if do_gpu:\r\n err = compare(expected_times_gpu, gpu_times)\r\n print >> sys.stderr, 'speed_failure_gpu=' + str(err)\r\n\r\n assert not numpy.isnan(gpu_times).any()","def printAlgorithmResults (test_case, key_size, plaintext, ciphertext, e, n, d):\r\n brute_force_time = -1\r\n\r\n if test_case < 7:\r\n start = time.time()\r\n d_actual_bf = crackRsaBruteForce(e, n)\r\n end = time.time()\r\n brute_force_time = '%.3f'%(end-start)\r\n\r\n start = time.time()\r\n d_actual = crackRsaPrivateKey(e, n)\r\n end = time.time()\r\n cracking_time = '%.3f'%(end-start)\r\n\r\n print (\" **************** Test Case \"+str(test_case+1)+\" - \"+str(key_size)+\" bits **************** \\n\")\r\n print (\"d expected: \"+str(d))\r\n print (\"d actual: \"+str(d_actual))\r\n print (\"plaintext (expected): \"+str(plaintext))\r\n print (\"plaintext (actual): \"+str(decryptRSA(d_actual,n,ciphertext)))\r\n print (\"ciphertext (expected): \"+str(ciphertext))\r\n print (\"ciphertext (actual): \"+str(encryptRSA(e,n,plaintext)))\r\n print (\"cracking took \"+str(cracking_time)+\" seconds\")\r\n\r\n if brute_force_time == -1:\r\n print (\"could not crack the key using brute force\\n\")\r\n else:\r\n print (\"brute force took \"+str(brute_force_time)+\" seconds\\n\")","def test_handcrafted_examples(self):\n for i in range(1000):\n self.assertEqual(perfectd(0), True)\n self.assertEqual(prime(0), False)\n self.assertEqual(prime(2), True)\n self.assertEqual(prime(7), True)\n self.assertEqual(prime(15), False)\n self.assertEqual(perfectd(6), True)\n self.assertEqual(perfectd(15), False)","def basic_experiments(k, p, num_iter, transforms, train_path, test_path):\n start_time = time.time()\n print(\"Generating advice\")\n with open(train_path, \"r\") as f:\n train_data = f.readlines()\n advice = generate_advice(train_data, transforms)\n print(\"Done: \" + str(time.time() - start_time) + \"\\n\")\n\n print(\"Generating real count for test data\")\n with open(test_path, \"r\") as f:\n test_data = f.readlines()\n real_count = generate_advice(test_data, transforms)\n print(\"Done: \" + str(time.time() - start_time))\n actual = [x.moment(p) for x in real_count]\n print(\"Actual moments:\")\n print(actual)\n\n print(\"Estimating using noisy advice:\")\n est_with_advice = []\n for i in range(num_iter):\n seed = str(random.randint(1, 2**64 + 1)) + str(random.randint(1, 2**64 + 1))\n this_hash_exp = lambda x: hash_exp(x, seed)\n est_with_advice.append(\n estimate_using_advice(test_data, transforms, k, p, this_hash_exp,\n advice))\n print(\"Done: \" + str(time.time() - start_time))\n print(est_with_advice)\n\n print(\"Estimating using perfect advice:\")\n est_perfect_advice = []\n for i in range(num_iter):\n seed = str(random.randint(1, 2**64 + 1)) + str(random.randint(1, 2**64 + 1))\n this_hash_exp = lambda x: hash_exp(x, seed)\n est_perfect_advice.append(\n estimate_using_advice(test_data, transforms, k, p, this_hash_exp,\n real_count))\n print(\"Done: \" + str(time.time() - start_time))\n print(est_perfect_advice)\n\n print(\"Estimating using PPSWOR:\")\n est_ppswor = []\n for i in range(num_iter):\n cur = []\n for x in real_count:\n cur.append(ppswor_estimate_moment(x.counts.items(), k, p))\n est_ppswor.append(cur)\n print(\"Done: \" + str(time.time() - start_time))\n print(est_ppswor)\n\n print(\"Estimating using ell_2 PPSWOR:\")\n est_ppswor_l2 = []\n for i in range(num_iter):\n cur = []\n for x in real_count:\n cur.append(ppswor_estimate_moment(x.counts.items(), k, p, 2))\n est_ppswor_l2.append(cur)\n print(\"Done: \" + str(time.time() - start_time))\n print(est_ppswor_l2)","def find():\n b = 0\n q = 0\n while b == q:\n seq = [randint(-10, 10) for _ in range(randint(15, 30))]\n b, b_at = brute_force(seq)\n q = solution(seq)\n print(seq, b, q, b_at)","def random_test(self, source):\r\n ret = 1\r\n for seed in range(1, 40):\r\n if source.run(temp_params={\"fitness_function\": (lambda x: -np.sum(x)**2+10),\r\n \"population_size\": 10,\r\n \"time_constraint\": 2,\r\n \"axes\": [(0, 5)],\r\n \"seed\": seed}) != \\\r\n source.run(temp_params={\"fitness_function\": (lambda x: -np.sum(x) ** 2 + 10),\r\n \"population_size\": 10,\r\n \"time_constraint\": 2,\r\n \"axes\": [(0, 5)],\r\n \"seed\": seed}):\r\n ret = 0\r\n if ret == 0:\r\n if self.verbosity > 0:\r\n print(\"ERROR: Random seed non functional, results cannot be replicated.\")\r\n return 0\r\n else:\r\n if self.verbosity > 1:\r\n print(\"Random seed functional, results replicable if a seed is used.\")\r\n return 1","def brute_tree(XTRAIN,istopTRAIN,XTEST,istopTEST):\n \n ntrain=XTRAIN.shape[0]\n ntest=XTEST.shape[0]\n \n if np.sum(istopTRAIN)==0:\n return 0,[]\n\n cost0=np.zeros(Ngammas*Nreps)\n cost1=np.zeros(Ngammas*Nreps)\n cost0test=np.zeros(Ngammas*Nreps)\n cost1test=np.zeros(Ngammas*Nreps)\n \n precisionTRAIN=np.zeros(Ngammas*Nreps)\n precisionTEST=np.zeros(Ngammas*Nreps)\n recallTEST=np.zeros(Ngammas*Nreps)\n rate=np.zeros(Ngammas*Nreps)\n \n for iii in range(Ngammas):\n \n gamma=GAMMA[iii]\n \n for jjj in range(Nreps):\n \n \"\"\" train a tree using training data with random splitting \"\"\"\n \n tree_hyperparameters['class_weight']={0:1,1:gamma}\n clf=tree.DecisionTreeClassifier(**tree_hyperparameters)\n clf.fit(XTRAIN,istopTRAIN)\n \n \"\"\"\" record costs and precision on validation data \"\"\"\n \n pTRAIN=clf.predict(XTRAIN)\n precisionTRAIN[iii*Nreps+jjj]=np.divide(sum(1 for i in range(ntrain) if pTRAIN[i] == 1 and istopTRAIN[i]==1),sum(pTRAIN))\n cost0[iii*Nreps+jjj]=sum(1 for i in range(ntrain) if pTRAIN[i] == 1 and istopTRAIN[i]==0)\n cost1[iii*Nreps+jjj]=sum(1 for i in range(ntrain) if pTRAIN[i] == 0 and istopTRAIN[i]==1)\n \n \"\"\" record precision on test data \"\"\"\n \n pTEST=clf.predict(XTEST)\n precisionTEST[iii*Nreps+jjj]=np.divide(sum(1 for i in range(ntest) if pTEST[i] == 1 and istopTEST[i]==1),sum(pTEST))\n recallTEST[iii*Nreps+jjj]=sum(1 for i in range(ntest) if pTEST[i] == 1 and istopTEST[i]==1)/sum(istopTEST)\n cost0test[iii*Nreps+jjj]=sum(1 for i in range(ntest) if pTEST[i] == 1 and istopTEST[i]==0)\n cost1test[iii*Nreps+jjj]=sum(1 for i in range(ntest) if pTEST[i] == 0 and istopTEST[i]==1)\n \n \"\"\" record positive rate on full data \"\"\"\n \n rate[iii*Nreps+jjj]=(sum(pTRAIN)+sum(pTEST))/(ntrain+ntest)\n \n \"\"\" Compute Pareto front for validation data \"\"\"\n \n Pareto = Lower_Convex_Hull(np.concatenate((cost0.reshape(-1,1),cost1.reshape(-1,1)),1))\n \n \"\"\" make some nice plots for whoever is watching \"\"\"\n \n plt.figure(figsize=(10,5))\n plt.subplot(121)\n plt.plot(cost0,cost1,'.')\n plt.plot(cost0[Pareto],cost1[Pareto],'d')\n plt.xlabel('errors on class zero training data')\n plt.ylabel('errors on class one training data')\n\n plt.subplot(122)\n plt.plot(cost0test,cost1test,'.')\n plt.plot(cost0test[Pareto],cost1test[Pareto],'d')\n plt.xlabel('errors on class zero test data')\n plt.ylabel('errors on class one test data')\n plt.show()\n \n plt.figure(figsize=(15,5))\n plt.subplot(131)\n plt.semilogy(precisionTRAIN,rate,'.')\n plt.semilogy(precisionTRAIN[Pareto],rate[Pareto],'d')\n plt.xlabel('precision on training data')\n plt.ylabel('positive rate')\n\n plt.subplot(132) \n plt.semilogy(precisionTEST,rate,'.')\n plt.semilogy(precisionTEST[Pareto],rate[Pareto],'d')\n plt.xlabel('precision on test data')\n plt.ylabel('positive rate')\n\n plt.subplot(133) \n plt.plot(precisionTEST,recallTEST,'.')\n plt.plot(precisionTEST[Pareto],recallTEST[Pareto],'d')\n plt.xlabel('precision on test data')\n plt.ylabel('recall on test data')\n plt.show() \n \n return {'cost0':cost0,'cost1':cost1,'cost0test':cost0test,'cost1test':cost1test,'precisionTRAIN':precisionTRAIN,'precisionTEST':precisionTEST,'recallTEST':recallTEST,'rate':rate,'Pareto':Pareto}","def test_rand_func2(self):\n for i in range(0, 100000):\n num = random.randint(0, 32535143990)\n func2_comp(num)","def run_and_evaluate():\n tsp_problems = read_all_problems()\n # Empty list of metrics\n results = []\n for problem in tqdm.tqdm(tsp_problems):\n # As random factors are involved repeat experiments a couple of times\n best_routes_base = []\n best_routes_af = []\n best_routes_ms = []\n base_times = []\n af_times = []\n ms_times = []\n for i in range(10):\n # Base solution\n start_time = timeit.default_timer()\n best_route_base = solve_tsp_basic(problem)\n base_time = timeit.default_timer() - start_time\n best_routes_base.append(Fitness(route=best_route_base).route_distance())\n base_times.append(base_time)\n\n # AF clustering solution\n start_time = timeit.default_timer()\n best_route_af = solve_tsp_affinity_propagation(problem)\n af_time = timeit.default_timer() - start_time\n best_routes_af.append(Fitness(route=best_route_af).route_distance())\n af_times.append(af_time)\n\n # MS solution\n start_time = timeit.default_timer()\n best_route_ms = solve_mean_shift(problem)\n ms_time = timeit.default_timer() - start_time\n best_routes_ms.append(Fitness(route=best_route_ms).route_distance())\n ms_times.append(ms_time)\n\n results.append(\n {\n \"problem name\": problem.name,\n \"optimal solution\": find_route_optimal_route_length(problem),\n \"baseline tour length\": mean(best_routes_base),\n \"af clustering tour length\": mean(best_routes_af),\n \"ms clustering tour length\": mean(best_routes_ms),\n \"baseline algorithm time\": mean(base_times),\n \"af clustering algorithm time\": mean(af_times),\n \"ms clustering algorithm time\": mean(ms_times),\n }\n )\n # Create dataframe and safe results\n df = pd.DataFrame(results)\n df.to_csv(\"results.csv\", index=False)\n return df","def challenge2(self):\n # Create emulator, with 6 registers. Set register 0 to 1\n emulator = Emulator(6)\n emulator.registers[0] = 1\n\n # Running this program seems to take forever... let's see if there's a pattern.\n # OK, so after dumping out lots of instructions, this pattern is repeated a lot:\n # [ 3] mulr 1 5 3\n # [ 4] eqrr 3 2 3\n # [ 5] addr 3 4 4\n # [ 6] addi 4 1 4\n # [ 8] addi 5 1 5\n # [ 9] gtrr 5 2 3\n # [10] addr 4 3 4\n # [11] seti 2 2 4\n # In this program, register 4 is the IP register. (IP is shown in [] above)\n # So instruction 6 is just jumping to instruction 8, we can optimize that out\n # And seti 2 2 4 will act as a jump back to instruction 3 (= 2 + 1)\n # Registers look like this after instruction 3:\n # IP: 4 Reg: [0, 1, 10551376, 145834, 3, 145834]\n # So effectively we have, per loop iteration:\n # reg[3] = reg[1] * reg[5]\n # reg[3] = 1 if reg[3] == reg[2] else 0\n # reg[4] = reg[3] + reg[4] => If the above was false, we go to instruction 6.\n # Otherwise we go to instruction 7 (outside the normal loop flow) and do:\n # addr 1 0 0 => reg[0] = reg[0] + reg[1], then proceed as below.\n # If we stay in the loop, or just fallen through now, we are at instruction 8:\n # reg[5] = reg[5] + reg[1]\n # reg[3] = 1 if reg[5] > reg[2] else 0\n # reg[4] = reg[3] + reg[4] => If the above was false, we go to instruction 11 => back to the start.\n # Otherwise, we jump outside the loop to instruction 12.\n # So to write the above in Python code, with registers named R0 etc:\n # while R5 <= R2:\n # R3 = R1 * R5\n # if R3 == R2:\n # R0 += R1\n # R5 += R1\n #\n # This appears to be a brute force way of checking if R1 is a factor of R2 - and if it is, adding it to R0\n # After this loop, if we go to instruction 12:\n # addi 1 1 1 => R1 += 1\n # gtrr 1 2 3 => R3 = 1 if R1 > R2 else 0\n # addr 3 4 4\n # seti 1 4 4\n # mulr 4 4 4\n # These last three mean \"jump to instruction 2 if R1 <= R2 else terminate (by squaring the IP)\"\n # So putting this together, along with instructions 2 and 3 of:\n # seti 1 8 1 => R1 = 1\n # seti 1 3 5 => R5 = 1\n # We are brute-force finding all the factors of R2 and adding all of them together into R0\n # As R2 contains 10551376, we can do this in a cleverer, non brute force way to find the final value of R0!\n number_to_factorize = 10551376\n \n def factors(n): \n return set(reduce(list.__add__, \n ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))\n\n sum_factors = sum(factors(number_to_factorize))\n print(f\"Final value of register 0: {sum_factors}\")","def test_compare(self):\n config = {\n 'num_components': 512,\n 'num_features': 128,\n 'covariance': 'spherical'\n }\n\n samples = self.generate_samples(config, 100_000)\n sklearn_time = np.mean([self.train_sklearn(config, samples) for _ in range(3)])\n ours_cpu_time = np.mean([self.train_ours(config, samples) for _ in range(3)])\n ours_gpu_time = np.mean([\n self.train_ours(config, samples.cuda(), gpu=True) for _ in range(3)\n ])\n\n print(f\"-------------------------------------\")\n print(f\"Speedup of CPU implementation: {sklearn_time / ours_cpu_time:.2f}\")\n print(f\"Speedup of GPU implementation: {sklearn_time / ours_gpu_time:.2f}\")\n print(f\"-------------------------------------\")","def test_strategy_evaluate(self, MetricClass, seed):\n m = MetricClass()\n strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))\n result0 = np.array(m.result(strategy)) # from metric method\n result1 = np.array(strategy.evaluate(m)) # from strategy method\n assert np.equal(result0, result1).all()","def run_tests(test_count=1000, buyer_count=10):\n\n found_error = False\n\n for i in range(test_count):\n\n bp, sp, bw = get_preferences(buyer_count)\n matches = get_matches(bp, sp, bw)\n\n if not check_stability(bp, sp, matches):\n print('ERROR!!!')\n found_error = True\n\n if not found_error:\n print('Executed {} tests without errors'.format(test_count))","def test_custom_works_fine(self):\n\n ba_custom = BatAlgorithm(NP=20, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, seed=self.seed)\n ba_customc = BatAlgorithm(NP=20, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, seed=self.seed)\n AlgorithmTestCase.algorithm_run_test(self, ba_custom, ba_customc, MyBenchmark())","def test_run_jackknifed_beta_diversity_parallel(self):\r\n\r\n run_jackknifed_beta_diversity(\r\n self.test_data['biom'][0],\r\n self.test_data['tree'][0],\r\n 20,\r\n self.test_out,\r\n call_commands_serially,\r\n self.params,\r\n self.qiime_config,\r\n self.test_data['map'][0],\r\n parallel=True,\r\n status_update_callback=no_status_updates)\r\n\r\n weighted_unifrac_upgma_tree_fp = join(self.test_out,\r\n 'weighted_unifrac',\r\n 'upgma_cmp', 'jackknife_named_nodes.tre')\r\n unweighted_unifrac_upgma_tree_fp = join(\r\n self.test_out, 'unweighted_unifrac', 'upgma_cmp',\r\n 'jackknife_named_nodes.tre')\r\n weighted_unifrac_emperor_index_fp = join(\r\n self.test_out, 'weighted_unifrac', 'emperor_pcoa_plots',\r\n 'index.html')\r\n unweighted_unifrac_emperor_index_fp = join(\r\n self.test_out, 'unweighted_unifrac', 'emperor_pcoa_plots',\r\n 'index.html')\r\n\r\n input_file_basename = splitext(split(self.test_data['biom'][0])[1])[0]\r\n unweighted_unifrac_dm_fp = join(self.test_out,\r\n 'unweighted_unifrac_%s.txt' % input_file_basename)\r\n weighted_unifrac_dm_fp = join(self.test_out,\r\n 'weighted_unifrac_%s.txt' % input_file_basename)\r\n\r\n # check for expected relations between values in the unweighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n # check for expected relations between values in the weighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n\r\n # check that final output files have non-zero size\r\n self.assertTrue(getsize(weighted_unifrac_upgma_tree_fp) > 0)\r\n self.assertTrue(getsize(unweighted_unifrac_upgma_tree_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_emperor_index_fp) > 0)\r\n self.assertTrue(getsize(unweighted_unifrac_emperor_index_fp) > 0)\r\n\r\n # Check that the log file is created and has size > 0\r\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\r\n self.assertTrue(getsize(log_fp) > 0)","def test_v2_runtime(self):\r\n\r\n start_time = time.time()\r\n\r\n for n in range(1, 30000):\r\n prime_numbers_v2(n)\r\n\r\n elapsed_time = round(time.time() - start_time, 3)\r\n\r\n print(f\"v2, time required: {elapsed_time}\")","def brute_force_search_solution():\n return len(coin_search(TOTAL, COINS))","def test_huge_answers(self):\n self.init_player(\n '0', 'Welcome to Oppia!', 'do you know where the name \\'Oppia\\'')\n self.submit_and_compare(\n '0', '', 'In fact, the word Oppia means \\'learn\\'.')\n # This could potentially cause errors in stats_models when the answer\n # is persisted to the backend.\n self.submit_and_compare(\n 'a' * 1000500, 'Sorry, nope, we didn\\'t get it', '')","def performBMItests():\r\n feet = 5\r\n inches = 60\r\n\r\n expectedBMIa = 18.4\r\n poundsA = 92\r\n expectedBMIb = 18.5\r\n poundsB = 92.5\r\n expectedBMIc = 24.9\r\n poundsC = 124.5\r\n expectedBMId = 25.0\r\n poundsD = 125.0\r\n expectedBMIe = 29.9\r\n poundsE = 149.5\r\n expectedBMIf = 30.0\r\n poundsF = 150.0\r\n\r\n expectedResulta = \"Underweight\"\r\n expectedResultb = \"Normal\"\r\n expectedResultc = \"Normal\"\r\n expectedResultd = \"Overweight\"\r\n expectedResulte = \"Overweight\"\r\n expectedResultf = \"Obese\"\r\n\r\n BMIa, resultA = calculateBMI(feet, inches, poundsA)\r\n BMIb, resultB = calculateBMI(feet, inches, poundsB)\r\n BMIc, resultC = calculateBMI(feet, inches, poundsC)\r\n BMId, resultD = calculateBMI(feet, inches, poundsD)\r\n BMIe, resultE = calculateBMI(feet, inches, poundsE)\r\n BMIf, resultF = calculateBMI(feet, inches, poundsF)\r\n\r\n print(\"\")\r\n print(\"\")\r\n bmi_test(expectedBMIa, BMIa, expectedResulta, resultA)\r\n bmi_test(expectedBMIb, BMIb, expectedResultb, resultB)\r\n bmi_test(expectedBMIc, BMIc, expectedResultc, resultC)\r\n bmi_test(expectedBMId, BMId, expectedResultd, resultD)\r\n bmi_test(expectedBMIe, BMIe, expectedResulte, resultE)\r\n bmi_test(expectedBMIf, BMIf, expectedResultf, resultF)\r\n print(\"\")\r\n print(\"\")","def test_v1_runtime(self):\r\n\r\n start_time = time.time()\r\n\r\n for n in range(1, 30000):\r\n prime_numbers_v1(n)\r\n\r\n elapsed_time = round(time.time() - start_time, 3)\r\n\r\n print(f\"v1, time required: {elapsed_time}\")","def run_experiment():\n return [random.random() < 0.5 for _ in range(1000)]","def run_experiment():\n return [random.random() < 0.5 for _ in range(1000)]","def run_experiment():\n return [random.random() < 0.5 for _ in range(1000)]","def run_experiment():\n return [random.random() < 0.5 for _ in range(1000)]","def test_calculate_class_2_individuals_best_response_simulation_all_inds_in_one():\n all_individuals_to_first = calculate_class_2_individuals_best_response(\n lambda_2=0.3,\n lambda_1_1=0.1,\n lambda_1_2=3,\n mu_1=10,\n mu_2=2,\n num_of_servers_1=8,\n num_of_servers_2=4,\n threshold_1=6,\n threshold_2=3,\n system_capacity_1=float(\"inf\"),\n system_capacity_2=float(\"inf\"),\n buffer_capacity_1=float(\"inf\"),\n buffer_capacity_2=float(\"inf\"),\n use_simulation=True,\n runtime=500,\n num_of_trials=5,\n warm_up_time=100,\n seed_num_1=10,\n seed_num_2=10,\n )\n assert all_individuals_to_first == 1\n\n all_individuals_to_second = calculate_class_2_individuals_best_response(\n lambda_2=0.3,\n lambda_1_1=3,\n lambda_1_2=0.1,\n mu_1=2,\n mu_2=10,\n num_of_servers_1=4,\n num_of_servers_2=8,\n threshold_1=3,\n threshold_2=6,\n system_capacity_1=float(\"inf\"),\n system_capacity_2=float(\"inf\"),\n buffer_capacity_1=float(\"inf\"),\n buffer_capacity_2=float(\"inf\"),\n use_simulation=True,\n runtime=500,\n num_of_trials=5,\n warm_up_time=100,\n seed_num_1=10,\n seed_num_2=10,\n )\n assert all_individuals_to_second == 0","def speed_test(self):\n self.lg.debug('Performing speed test no. {}'.format(self.runs))\n self.st.get_best_server()\n self.st.upload()\n self.st.download()\n up = self.st.results.upload // 1e6\n down = self.st.results.download // 1e6\n timestamp = time.localtime(time.time())\n self.lg.debug('Timestamp: {}'.format(\n time.strftime('%H:%M:%S', timestamp)))\n self.lg.debug(\n 'Upload is {} Mbps'.format(up))\n self.lg.debug(\n 'Download is {} Mbps'.format(down))\n self.results_up.append(up)\n self.results_down.append(down)\n self.results_timestamp.append(timestamp)","def main():\n\n tests = [500, 1000, 10000]\n results = {\n 'Insertion Sort': 0.0,\n 'Shell Sort': 0.0,\n 'Python Sort': 0.0\n }\n\n for test in tests:\n i = 0\n\n while i < 100:\n test_list = gen_random_list(test)\n results['Insertion Sort'] += insertion_sort(test_list)[0]\n results['Shell Sort'] += shell_sort(test_list)[0]\n results['Python Sort'] += python_sort(test_list)[0]\n i += 1\n\n print(\"Sort results for list of size %s items:\" % test)\n for key, value in results.items():\n print(\"%s took %10.7f seconds to run, on average.\" % (key, (value/100)))\n print(\"\\n\")","def run(method, n):\n \n m1,m2 = generate(n)\n \n start = time.time()\n method(m1,m2)\n end = time.time()\n \n exe = end - start\n \n return exe","def test_custom_works_fine(self):\n\t\thsaba_custom = self.algo(NP=10, Limit=2, seed=self.seed)\n\t\thsaba_customc = self.algo(NP=10, Limit=2, seed=self.seed)\n\t\tAlgorithmTestCase.test_algorithm_run(self, hsaba_custom, hsaba_customc, MyBenchmark())","def simulation(self, n = 42):\n\n self.initialisation()\n i = 0\n while i < n and self.agent.vivant :\n self.step()\n i+= 1\n return self.perfGlobale","async def test_random_caching(players, strats, _):\n game = gamegen.samplegame(players, strats)\n rest1, rest2 = game.random_restrictions(2)\n sched = gamesched.samplegamesched(game)\n sgame = schedgame.schedgame(sched)\n assert str(sgame) == str(sched)\n\n rgame11 = await sgame.get_restricted_game(rest1)\n rgame21 = await sgame.get_restricted_game(rest2)\n devs11 = await sgame.get_deviation_game(rest1)\n devs21 = await sgame.get_deviation_game(rest2)\n\n rgame12 = await sgame.get_restricted_game(rest1)\n rgame22 = await sgame.get_restricted_game(rest2)\n assert rgame11 == rgame12\n assert rgame21 == rgame22\n\n devs12 = await sgame.get_deviation_game(rest1)\n devs22 = await sgame.get_deviation_game(rest2)\n assert devs11 == devs12\n assert devs21 == devs22","def bruteforce(vierhidden, totalecombinatie):\r\n for x in range(0, 1296):\r\n code = totalecombinatie[x]\r\n if validatecombination(vierhidden, code)[0] == 4:\r\n return 'Gevonden na ' + str(x + 1) + ' zetten.'","def compare_cow_transport_algorithms():\r\n cows_test = load_cows(\"ps1_cow_data.txt\")\r\n time0 = time.time()\r\n greedy = greedy_cow_transport(cows_test)\r\n time1 = time.time()\r\n brute = brute_force_cow_transport(cows_test)\r\n time2 = time.time()\r\n print (\"# of Trips by Greedy Algorithm:\", len(greedy))\r\n print (\"# of Trips by Brute Force Algo:\", len(brute))\r\n \r\n print (\"Greedy Algo took time:\", time1-time0)\r\n print (\"Brute Force Algo took time:\", time2-time1)\r\n pass","def test_check_cost():","def brute_force_solution():\n def is_pythagorean_triplet(a, b, c):\n return c**2 == a**2 + b**2\n\n return next(\n a * b * (TRIPLET_SUM - a - b)\n for a in range(1, TRIPLET_SUM)\n for b in range(a + 1, TRIPLET_SUM - a)\n if is_pythagorean_triplet(a, b, TRIPLET_SUM - a - b)\n )","def test(numTrials):\n # Your Code Here\n hits = 0.0\n for i in range(numTrials):\n result = trial()\n #print result\n hits += result\n return hits / numTrials","def test_statistic(self):\n for seed in range(5):\n\n random_state = np.random.RandomState(seed)\n\n for i in range(4, self.test_max_size + 1):\n arr1 = random_state.rand(i, 1)\n arr2 = random_state.rand(i, 1)\n\n stat = dcor_internals._distance_correlation_sqr_naive(\n arr1, arr2)\n stat_fast = dcor_internals._distance_correlation_sqr_fast(\n arr1, arr2)\n\n self.assertAlmostEqual(stat, stat_fast)","def run_grid_search():\n\n best_score = 0\n best_learning_rate = 0\n best_discount_rate = 0\n best_initial_q_hat = 0\n trial_results = []\n number_of_trials = 30\n # TODO These ought to be done with numpy.arange but I don't have that package installed at the moment\n for learning_rate_raw in range(5, 50, 5):\n for discount_rate_raw in range(5, 20, 5):\n for initial_q_hat in range(0, 10, 1):\n learning_rate = learning_rate_raw * 0.01\n discount_rate = discount_rate_raw * 0.05\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent, learning_rate, discount_rate, initial_q_hat) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0, display=False) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=number_of_trials) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\n score = a.get_score()\n if score > best_score:\n best_score = score\n best_learning_rate = learning_rate\n best_discount_rate = discount_rate\n best_initial_q_hat = initial_q_hat\n trial_results.append((learning_rate, discount_rate, initial_q_hat, score, a.get_proportion_of_states_visited(), len(a.get_failed_trials())/ float(number_of_trials)))\n print \"Gridsearch finished, best learning rate: %.2f, best discount rate: %.2f, best initial q hat %i\" % (best_learning_rate, best_discount_rate, best_initial_q_hat)\n\n with open('gridsearch_results.csv', 'wb') as csvfile:\n spamwriter = csv.writer(csvfile, delimiter=';', quotechar='|', quoting=csv.QUOTE_MINIMAL)\n spamwriter.writerow(('learning rate', 'discount factor', 'initial q-hat value', 'score', 'states visited', 'failed trials'))\n for result in trial_results:\n spamwriter.writerow(result)","def faster_brute_force_solution():\n def calc_b(a, sum):\n return ((sum**2/2) - (sum * a)) / (sum - a)\n\n a, b = next(\n (a, calc_b(a, TRIPLET_SUM))\n for a in range(1, TRIPLET_SUM)\n if calc_b(a, TRIPLET_SUM).is_integer()\n )\n\n return a * b * (TRIPLET_SUM - a - b)","def performance_test(n):\n \n def analyze_result(test_results, start_index, end_index, range_):\n \"\"\"Helper method - analyzes test results of one range (short, mid, or long).\n \n Args:\n test_results: list of test results containing tuples of (euclidean_distance, time_dijkstra, time_idastar)\n start_index: start index of this range in test results list\n end_index: end index of this range in test results list\n range_: Short, Mid, or Long range\n \n Returns:\n String describing analysis of test results in this range\n \"\"\"\n time_dij = 0\n time_ida = 0\n ida_not_finished = 0\n for i in range(start_index, end_index):\n result = test_results[i]\n time_dij += result[1]\n if result[2] == \"no_time\":\n ida_not_finished += 1\n else: # ida finished\n time_ida += result[2]\n result_dij = \"Algorithm: Dijkstra - Average time: \" + str(round(time_dij/(end_index-start_index)*1000, 3)) + \" ms\\n\"\n result_ida = \"Algorithm: IDA* - Average time: \" + str(round(time_ida/(end_index-start_index-ida_not_finished)*1000, 3)) + \" ms [\" + str(ida_not_finished) + \" attempts not finished]\\n\"\n header = range_ + \"-range results [\" + str(end_index-start_index) + \" tests]:\\n\"\n return header + result_dij + result_ida\n \n \n print(\"\\nCalculating...\\n\")\n \n test_results = []\n \n for _ in range(n):\n # random start and end cities\n start = cities[randint(0, len(cities)-1)]\n end = cities[randint(0, len(cities)-1)]\n while start == end:\n end = cities[randint(0, len(cities)-1)]\n # calculate euclidean distance\n x_diff = coordinates[start][0] - coordinates[end][0]\n y_diff = coordinates[start][1] - coordinates[end][1]\n eucl_dist = sqrt(x_diff**2 + y_diff**2)\n \n # Dijkstra\n dist_dij, path_dij, time_dij = dijkstra(start, end, adjlist)\n # IDA*\n dist_ida, path_ida, time_ida = idastar(start, end, adjlist, coordinates)\n \n test_results.append( (eucl_dist, time_dij, time_ida) )\n \n # Analysis of results\n test_results.sort()\n short_index = 0\n mid_index = n//3\n long_index = n//3*2\n \n # Short-range\n print(analyze_result(test_results, short_index, mid_index, \"Short\"))\n # Mid-range\n print(analyze_result(test_results, mid_index, long_index, \"Mid\"))\n # Long-range\n print(analyze_result(test_results, long_index, len(test_results), \"Long\"))","def test_random_smoke(fastonly):\n word_length = 5\n while word_length < 65:\n run_random_test(word_length, 3, 1000 if fastonly else 100000, word_length)\n word_length += 1","def simulatie(n=20, m=10):\n\twith Stopwatch(message=\"v0: Python\"):\n\t\tcoordinatenLaagsteE = 0\n\t\tnummerRunLaagsteE = 0\n\t\tLaagsteE = math.inf\n\t\ttotalePot = 0\n\t\tgemiddelde = 0\n\t\tpotentialenlijst = list()\n\t\tfor i in range(m):\n\t\t\t#print(\"Bezig met het simuleren van run\", i+1, \"van\", m)\n\t\t\trun = atomen.Atomen(n)\n\t\t\tpot = run.berekenLJPot()\n\t\t\ttotalePot = totalePot + pot\n\t\t\tgemiddelde = totalePot / (i + 1)\n\t\t\tpotentialenlijst.append(pot)\n\t\t\tif pot < LaagsteE:\n\t\t\t\tcoordinatenLaagsteE = run.getCoordinaten()\n\t\t\t\tnummerRunLaagsteE = i\n\t\t\t\tLaagsteE = pot\n\tprint(\" \")\n\tprint(\"----------RESULTATEN----------\")\n\tprint(\"Run\", nummerRunLaagsteE + 1,\"van\", m, \"had de laagste totale Lennard Jones Potentiaal, namelijk:\", LaagsteE)\n\t#print(\"De Coordinaten van de atomen van deze run zijn:\", coordinatenLaagsteE)\n\tprint(\"De gemiddelde potentiaal:\", gemiddelde)\n\tprint(\"De standaardafwijking is:\", stdev(potentialenlijst))\n\t\n\t\"\"\"montecarlo_v1.simulatie(n, m)\n\tmontecarlo_v2.simulatie(n, m)\n\tmontecarlo_v3.simulatie(n, m)\"\"\"","def countbrute(m):\n nfound=0\n\n for i in range(1,m+1):\n for j in range(1,i+1):\n for k in range(1,j+1):\n d1=i*i+(j+k)*(j+k) \n if(checkpsq(d1)):\n nfound=nfound+1\n\n return nfound","def q2test():\n \n correct = True\n time0 = time.time()\n result = count_ephemeral(1, 10, 2)\n time1 = time.time()\n if result != 2:\n correct = False\n print(\"test failed for n1=1, n2=10, k=2; correct result is 2, result obtained was\", result)\n else:\n print(\"test passed for for n1=1, n2=10, k=2 in\", time1 - time0, \"seconds.\")\n\n time0 = time.time()\n result = count_ephemeral(1000, 10000, 3)\n time1 = time.time()\n if result != 91:\n correct = False\n print(\"test failed for n1=1000, n2=10000, k=3; correct result is 91, result obtained was\", result)\n else:\n print(\"test passed for for n1=1000, n2=10000, k=3 in\", time1 - time0, \"seconds.\")\n\n time0 = time.time()\n result = count_ephemeral(123456, 654321, 4)\n time1 = time.time()\n if result != 376:\n correct = False\n print(\"test failed for n1=123456, n2=654321, k=4; correct result is 376, result obtained was\", result)\n else:\n print(\"test passed for for n1=123456, n2=654321, k=4 in\", time1 - time0, \"seconds.\")\n if correct:\n print(\"all tests passed\")\n \n time0 = time.time()\n result = count_ephemeral(1, 10000000, 2)\n time1 = time.time()\n print(result, time1 - time0)\n \n time0 = time.time()\n result = count_ephemeral(1, 10000000, 3)\n time1 = time.time()\n print(result, time1 - time0)\n \n time0 = time.time()\n result = count_ephemeral(1, 10000000, 4)\n time1 = time.time()\n print(result, time1 - time0)","def brute_force(savedPnts, unitRadius, point):\n for pnt in savedPnts:\n d = distance(pnt, point)\n if d < unitRadius: return False\n return True","def compare_cow_transport_algorithms():\n cow_set = load_cows(\"ps1_cow_data.txt\")\n \n def get_run_time(func):\n start = time.time()\n print(func(cow_set))\n end = time.time()\n return end-start\n \n greedy_time = get_run_time(greedy_cow_transport)\n brute_force_time = get_run_time(brute_force_cow_transport)\n \n print(\"---\"*20)\n print(\"greedy runtime: \",greedy_time)\n print(\"brute force runtime: \", brute_force_time)","def test_machine_learning():","def mc_simul_all_hands():\r\n\tglobal hands, H, G, B, P, rnd, equity_arr, equity_all, equity_win, equity_tie, df, equity_mc_cvg\r\n\r\n\thands = np.array(map(hand_str_to_no, all_preflop_hands), dtype=np.int32)\r\n\tH = hands.shape[0]\r\n\tG = int(2e5)\t\t\t# 1e6\t\t2e5\r\n\tB = int(500)\t\t\t# 300\t\t500\r\n\tnb_opp = 9\r\n\tequity_arr = np.zeros([B, H, nb_opp, 2], dtype=np.float32)\r\n\r\n\tprint '\\n---------------- Monte Carlo simulation start'\r\n\tprint 'nb of hands = {}'.format(H)\r\n\tprint 'nb of random games per block = {}'.format(G)\r\n\tprint 'nb of blocks = {}\\n'.format(B)\r\n\r\n\r\n\tt_init = timer()\r\n\tfor b in xrange(B):\r\n\t\tprint 'block #{}'.format(b)\r\n\t\tt0 = timer()\r\n\r\n\t\t# random games generation\r\n\t\tC = 50-2\r\n\t\tP = 2*nb_opp+5\r\n\t\tN = int(2*P*G)\r\n\t\tseed = 0\t# None\r\n\t\trnd = rnd_games(G, P, C, N, seed)\r\n\t\t# rnd = rnd_games_slow(G, P, C)\r\n\r\n\t\tt1 = timer()\r\n\t\tprint '\\tRNG time = \\t{:.6f} s'.format(t1-t0)\r\n\r\n\t\t# hand ranking\r\n\t\tequity_arr[b, :, :, :] = mc_block_all_fast(hands, nb_opp, rnd, keys.CARD_FLUSH_KEY,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\tkeys.CARD_FACE_KEY,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\tkeys.CARD_SUIT,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\tkeys.SUIT_MASK,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\tkeys.SUIT_BIT_SHIFT,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\tEvalSeven.flush_rank,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\tEvalSeven.face_rank,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\tEvalSeven.flush_suit)\r\n\r\n\t\tt2 = timer()\r\n\t\tprint '\\tequity time = \\t{:.6f} s'.format(t2-t1)\r\n\t\tprint '\\tblock time = \\t{:.6f} s'.format(t2-t0)\r\n\r\n\tprint '\\n---------------- Monte Carlo simulation end'\r\n\tprint 'full run time = {:.6f} s'.format(t2-t_init)\r\n\tpickle(os.path.join('Tables', 'equity_array.pk'), equity_arr)\r\n\r\n\r\n\tequity_all = np.mean(equity_arr, axis=0)\r\n\tequity_win = equity_all[:, :, 0]\r\n\tequity_tie = equity_all[:, :, 1]\r\n\tdf = pd.DataFrame(data=np.concatenate((equity_win, equity_tie), axis=1),\r\n\t\t\t\t\t\tindex=all_preflop_hands,\r\n\t\t\t\t\t\tcolumns=[str(i)+'_win' for i in range(1, nb_opp+1)]+[str(i)+'_tie' for i in range(1, nb_opp+1)])\r\n\tdf.to_pickle(os.path.join('Tables', 'df_equity_montecarlo.pd'))\r\n\tdf.to_csv(os.path.join('Tables', 'df_equity_montecarlo.csv'))\r\n\r\n\tequity_mc_cvg = np.zeros_like(equity_arr)\r\n\tfor k in xrange(B):\r\n\t\tequity_mc_cvg[k, :, :, :] = np.mean(equity_arr[:k+1, :, :, :], axis=0)\r\n\tpickle(os.path.join('Tables', 'equity_mc_cvg.pk'), equity_mc_cvg)\r\n\r\n\t# df_equity_montecarlo = pd.read_pickle(os.path.join('Tables', 'df_equity_montecarlo.pd'))\r\n\t# equity_arr_1 = unpickle(os.path.join('Tables', 'test.pk'))\r\n\t# equity_mc_cvg_1 = unpickle(os.path.join('Tables', 'equity_mc_cvg.pk'))\r","def test_brute_force_ttt(self):\n def simulate(moves, human_first): \n T = TicTacToe()\n for move in moves:\n self.ri.return_value = str(move)\n moves = [T.human_move, T.computer_move]\n for i in range(2):\n moves[(i + human_first) % 2]()\n winner = T.tic_tac_toe(T.board)\n if winner:\n return winner == T.computer or winner == 'cat'\n return True\n sys.stdout, tmp = open(os.devnull, 'w'), sys.stdout\n assert True == all(simulate(moves, True) for moves in combinations_with_replacement(range(9), 5))\n assert True == all(simulate(moves, False) for moves in combinations_with_replacement(range(9), 5))\n sys.stdout = tmp","def _run():\n matching_terms = {'a', 'b'}\n source_counts = {'a': 10, 'b': 50, 'c': 25}\n target_counts = {'a': 4, 'b': 73, 'c': 15}\n source_chunk = ['a', 'b']\n target_chunk = ['a', 'c', 'b']\n source_distance = score.find_distance(\n matching_terms, source_chunk, source_counts)\n target_distance = score.find_distance(\n matching_terms, target_chunk, target_counts)\n match_score = score.vanilla(\n matching_terms, source_distance, target_distance, source_counts,\n target_counts)\n print('Calculated score:', match_score)","def run_random(self):\n manager = Manager()\n self.all_probabilities = manager.list()\n self.total_iterations = manager.Value('d', 0)\n num_counterexamples = manager.Value('d', 0)\n counter_lock = manager.Lock()\n all_probabilities_lock = manager.Lock()\n\n file_q = manager.Queue()\n\n self.mug_pipeline.set_folder_names(self.folder_name)\n self.mug_pipeline.set_optimizer_type(OptimizerType.RANDOM)\n pool = Pool(self.num_processes + 1, maxtasksperchild=60)\n\n filename = '{}/logs/results_{}.csv'.format(self.folder_name, self.trial_folder)\n watcher = Process(target=self.listener, args=(file_q, filename))\n watcher.start()\n\n iter_num = 0\n start_time = time.time()\n max_time_per_map = 60*60\n\n try:\n # TODO: change this from while true to terminate by timeout (try/except)\n while ((self.retrain_with_random and self.total_iterations.value < self.max_added_to_training) or\n (self.retrain_with_counterexamples and num_counterexamples.value < self.max_added_to_training)):\n result = None\n\n while result is None:\n try:\n result = func_timeout(max_time_per_map, pool.starmap,\n args=(self.mug_pipeline.run_inference,\n zip(self.generate_all_mug_initial_poses(), \n range(iter_num, iter_num + self.num_processes),\n repeat(self.all_probabilities), repeat(all_probabilities_lock), \n repeat(self.total_iterations), repeat(num_counterexamples),\n repeat(counter_lock), repeat(file_q), repeat(False), repeat(False))))\n except FunctionTimedOut:\n print('FUNCTION TIMED OUT, MORE THAN {} SECONDS!!!!'.format(max_time_per_map))\n\n # all_mug_initial_poses = []\n # for j in range(self.num_processes):\n # mug_initial_poses = []\n # for i in range(self.num_mugs):\n # mug_initial_poses += \\\n # RollPitchYaw(np.random.uniform(0.0, 2.0*np.pi, size=3)).ToQuaternion().wxyz().tolist() + \\\n # [np.random.uniform(-0.1, 0.1), np.random.uniform(-0.1, 0.1), np.random.uniform(0.1, 0.2)]\n # all_mug_initial_poses.append(mug_initial_poses)\n\n # result = pool.starmap(self.mug_pipeline.run_inference,\n # zip(all_mug_initial_poses, \n # range(iter_num, iter_num + self.num_processes),\n # repeat(self.all_probabilities), repeat(all_probabilities_lock), \n # repeat(self.total_iterations), repeat(num_counterexamples),\n # repeat(counter_lock), repeat(file_q), repeat(False), repeat(False)))\n\n iter_num += self.num_processes\n print('new iter_num: {}'.format(iter_num), flush=True)\n total_min = (time.time() - start_time)/60.0\n print('avg min/image: {}, total minutes: {}'.format(total_min/(iter_num + 1), total_min))\n print('------------------------------------------------', flush=True)\n sys.stdout.flush()\n except Exception as e:\n raise e\n\n pool.close()\n pool.join()\n\n sys.stdout.flush()","def executeTest(self, test):\n\n #print test\n\n if not self.validateAllCars(test):\n return \"0\"\n\n self.multiplier = 1\n\n cars = test\n cars = self.compressAll(cars)\n\n # Make sure a letter isn't in the middle of a car\n for c in cars:\n for k in cars:\n if (c[0] in k[1:-1]) or (c[-1] in k[1:-1]):\n return \"0\"\n\n cars = [c[0] + c[-1] for c in cars]\n cars = self.combineAll(cars)\n cars = self.compressAll(cars)\n\n print \"%d * %s\" % (self.multiplier, cars)\n\n return (math.factorial(len(cars)) * self.multiplier) % 1000000007\n\n c = 0\n\n for i in itertools.permutations(cars):\n train = \"\".join(i)\n train = self.compressCar(train)\n if self.validateTrain(train):\n c = c + 1\n\n c = c * self.multiplier\n\n return c % 1000000007","def testParallelRandom():\n\n N = 10\n p = .7\n\n runs = 0\n while runs < 50:\n\n G = nx.fast_gnp_random_graph(N, p)\n a = 0\n b = G.number_of_nodes()-1\n\n try:\n nx.shortest_path(G, source=a, target=b)\n except RuntimeError:\n continue\n\n i, j = [], []\n for xx in G.edges():\n i.append(xx[0])\n j.append(xx[1])\n\n # %.1f values for resistance\n val = np.round(np.random.ranf(len(i))*100)/10\n\n # and test\n nw1 = makeNW(i, j, val)\n nw2 = parallelCopy(nw1, a, b)\n ER1 = ResNetwork(nw1).effective_resistance(a, b)\n ER2 = ResNetwork(nw2).effective_resistance(a, b)\n\n # assertion\n assert (ER1/2-ER2) < 1E-6\n\n # increment runs\n runs += 1","def main():\n LIMIT = 600\n GOAL = 1000\n for i in range(1, LIMIT + 1):\n for j in range(1, LIMIT + 1):\n for k in range(1, LIMIT + 1):\n if i + j + k == GOAL:\n if i**2 == j**2 + k**2:\n print \"GOAL:\", (i, j, k)","def test_pima_indians_diabetes_scikit_learn_comparison():\n\n print('\\n===============================')\n print('=== PROJECT IMPLEMENTATION ====')\n print('===============================')\n\n seed(1)\n\n pid = PimaIndiansDiabetes()\n pid.data_preprocessing()\n project_efficiency_percent = pid.calculate_accuracy(n_folds=2)\n\n\n print('\\n===============================')\n print('=========== SKLEARN ===========')\n print('===============================')\n\n # loading data from .csv file\n filename = 'datasets/pima-indians-diabetes.csv'\n X = list()\n y = list()\n\n with open(filename, 'r') as f:\n\n csv_reader = reader(f)\n\n for i, row in enumerate(csv_reader):\n converted_row = list()\n for j in range(len(row)-1):\n converted_row.append(float(row[j]))\n X.append(converted_row)\n y.append(int(row[-1]))\n\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)\n\n gnb = GaussianNB()\n y_pred = gnb.fit(X_train, y_train).predict(X_test)\n\n num_of_points = 384\n mislabeled_points = (y_test != y_pred).sum()\n sklearn_efficiency_percent = ((num_of_points - mislabeled_points) / num_of_points) * 100\n\n print(f'\\n\\nCalculating the scikit-learn algorithm accuracy with pima-indians-diabetes.csv dataset...')\n print(f'\\nNumber of mislabeled points out of a total {num_of_points} points : {mislabeled_points}')\n print(f'\\nAlgorithm efficiency: {round(sklearn_efficiency_percent, 5)} %')\n\n assert (project_efficiency_percent - sklearn_efficiency_percent) < 10","def performance():\n\tn = 1024\n\twhile n < 5000000: \n\t\tsorted = range(n)\n\t\tnow = time()\n\n\t\t# Code whose performance is to be evalutated\n\t\tbs_contains(sorted, -1)\n\n\t\tdone = time()\n\n\t\tprint n, (done-now)*10000\n\t\tn *= 2","def main(cls, args):\n #cls.trainOfflineAndTest(100, 0.1, 0.1, 0.9);\n #cls.trainOfflineAndTest(500, 0.1, 0.1, 1.0);\n\n cls.trainer.teachActiveAndSaveStatistics(\"onlineTest\", 10, 0.8, 1.0 ,1.0, 0.0, 0.3, True, True,True);\n cls.trainer.teachActiveAndSaveStatistics(\"path\", 10, 0.0, 0.0, 0.0, 0.0, 0.0, True, False, False)\n\n #trainer.teachActiveAndSaveStatistics(\"onlineTest\", 10000, 0.1f, 0.1f, 1.0f, 0.0f, 0.1f,true, true, true);\n # \t\ttrainer.teachActiveAndSaveStatistics(\"onlineTest\", 10000, 0.1f, 0.1f, 1.0f, 0.0f, 0.1f,\n # \t\t\t\tfalse, true, true);\n # \t\t\n # \t\ttestAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1_first.net\", 10000, true);\n # \t\ttestAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1_secound.net\", 10000, true);\n #cls.testAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1_first.net\", 10000, False)\n #cls.testAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1_secound.net\", 10, False)\n # \t\ttestAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1.net\", 10000, false);","def slow_function(*args, **kwargs):\n print('Password generation...')\n time.sleep(2)\n password = randint(1, 10)\n return password","def benchmark(Algorithm_, Network_, test): \n \n def sample(Algorithm_, Network_, test):\n \"\"\"\n Runs the Algorithm on Networks of the given type, varying n.\n After every execution, runs test on the resultant Network_.\n\n @param Algorithm_: a subclass of Synchronous_Algorithm, the algorithm to test.\n @param Network_: a subclass of Network, the network on which to benchmark the algorithm.\n @param test: a function that may throw an assertion error \n @return: (size, time, comm) where size is a list of values of network size,\n and time and comm are lists of corresponding values of time and communication complexities.\n \"\"\"\n size = []\n time = []\n comm = []\n n, lgn = 2, 1\n max_time = 0\n max_comm = 0\n print \"Sampling n = ...\",\n while max(max_time, max_comm) < 10000 and n < 500:\n\n #Progress\n if n == 2:\n print \"\\b\\b\\b\\b\"+str(n)+\"...\",\n else:\n print \"\\b\\b\\b\\b, \"+str(n)+\"...\",\n\n cur_times = []\n cur_comms = []\n for i in xrange( max(4, 2+lgn) ):\n A = Algorithm_(params={'draw': False, 'verbosity': Algorithm.SILENT})\n x = Network_(n)\n A(x)\n try:\n test(x)\n except AssertionError, e:\n print \"Algorithm Failed\"\n return None\n else:\n size.append(n)\n cur_comms.append(A.message_count)\n comm.append(A.message_count)\n\n if issubclass(Algorithm_, Synchronous_Algorithm):\n cur_times.append(A.r)\n time.append(A.r)\n max_time = max(max_time, A.r)\n max_comm = max(max_comm, A.message_count)\n\n #TODO here, decide whether need more samples for this n, based on cur_times and cur_comms variance\n n*=2\n lgn += 1\n print \" DONE\"\n return size, comm, time\n\n def averages(x,y):\n \"\"\"\n Groups x's with the same value, averages corresponding y values.\n\n @param x: A sorted list of x values\n @param y: A list of corresponding y values\n @return: (x grouped by value, corresponding mean y values)\n \n Example:\n\n averages([1,1,2,2,2,3], [5,6,3,5,1,8]) --> ([1, 2, 3], [5.5, 3.0, 8.0])\n \n \"\"\"\n new_x = [x[0]]\n new_y = []\n\n cur_x = new_x[0]\n cur_ys = []\n for x_i, y_i in zip(x,y):\n if x_i == cur_x:\n cur_ys.append(y_i)\n else:\n new_y.append( sum(cur_ys)/float(len(cur_ys) ) )\n new_x.append( x_i )\n cur_ys = [y_i]\n cur_x = x_i\n new_y.append( sum(cur_ys)/float(len(cur_ys) ) )\n return new_x, new_y\n\n def plot(x, y, title):\n \"\"\"Plots the points (x[i],y[i]) for all i, fig.\"\"\"\n fig, ax = plt.subplots()\n\n x_ave,y_ave = averages(x,y)\n\n ax.scatter(x, y, label=\"data\", color='b')\n ax.scatter(x_ave, y_ave, label=\"means\", color='r')\n \n ax.set_xlim( xmin=0 ) \n ax.set_ylim( ymin=0 )\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n ax.set_title(title)\n ax.set_xlabel(Network_.__name__ +' size')\n\n data = sample(Algorithm_, Network_, test)\n if data == None: return\n size, comm, time = data\n \n if issubclass(Algorithm_, Synchronous_Algorithm):\n plot(size, time, Algorithm_.__name__ + ' Time Complexity')\n\n plot(size, comm, Algorithm_.__name__ + ' Communication Complexity')","def run_tests(): \n \n\n nextdata = [[21, 61, 42, 30], [33,45, 18, 29]]\n\n for xval, yval, snum, expect in nextdata:\n\n pmachine = PMachine()\n pmachine.serial_number = snum\n pmachine.run2_completion()\n result = pmachine.calc_square_total(xval, yval, showsquare=True)\n assert result == expect\n print(\"Got value {}={} as expected\".format(result, expect))","def main():\r\n test = TesterNeighbour()\r\n test.setUp()\r\n test.test_result_n()\r\n print(\"result_of_algorithm_test - passed\")","def sim_alternating():\n catches = 0\n for _ in range(100000):\n j = np.random.uniform()*1000\n # j = np.random.exponential(500)\n t_i = 0\n i = 0\n while t_i < j+100:\n if i % 2 == 0:\n t_i += 10\n else:\n t_i += 20\n if j < t_i and t_i < j+1:\n catches += 1\n i += 1\n print(catches/100000)","def run(self,step=2,\n sizePop=100,\n infoFields=['migrate_to','fitness'],\n recombination_rate = 0.00375,\n migration_rate = 0.01,\n mutation_rate = [0.00000001],\n subPopNames = ['x','y','z','w'],\n alleleNames = ['A','B'],\n s1 = 0.1,\n burnin=50,\n **kargs):\n\n self.reset()\n pop=sim.Population(size=[sizePop]*self.numPop, loci=self.loci, lociPos=list(range(self.dist, (self.dist*self.loci)+1,self.dist)), subPopNames=subPopNames, infoFields=infoFields)\n \n simu = sim.Simulator(pop)\n print(\"The simulation has started\")\n t1 = time.time()\n\n\n mutate_snps=range(0,50)+range(51,101)\n\n # define the initialization of each loci based the beta distribution where a and b parameters are allele frequencies from noncoding human regions\n snps=[0.14, 0.11, 0.17, 0.11, 0.32, 0.33, 0.21, 0.11, 0.11, 0.28, 0.11, 0.12, 0.8, 0.66, 0.74, 0.68, 0.66, 0.77, 0.77, 0.76, 0.77, 0.74, 0.72, 0.11, 0.73, 0.72, 0.72, 0.72, 0.54, 0.17, 0.78, 0.64, 0.78, 0.2, 0.24, 0.25, 0.78, 0.66, 0.2, 0.14, 0.75, 0.16, 0.72, 0.18, 0.77, 0.42, 0.34, 0.7, 0.17, 0.14, 0.2, 0.46, 0.13, 0.26, 0.16, 0.13, 0.14, 0.24, 0.18, 0.36, 0.71, 0.27, 0.28, 0.25, 0.25, 0.3, 0.19, 0.14, 0.16, 0.3, 0.39, 0.16, 0.24, 0.32, 0.11, 0.18, 0.48, 0.31, 0.21, 0.15, 0.34, 0.71, 0.33, 0.18, 0.71, 0.13, 0.23, 0.2, 0.22, 0.23, 0.16, 0.23, 0.23, 0.22, 0.24, 0.82, 0.36, 0.37, 0.72, 0.16, 0.14]\n self.initFreq=[]\n\n \n for i in range(len(snps)):\n alpha=float(4*sizePop*migration_rate*snps[i])\n bhta=float(4*sizePop*migration_rate*(1-snps[i])) \n p=numpy.random.beta(alpha,bhta)\n while (p>=0.9 or p<=0.1):\n p=numpy.random.beta(alpha,bhta)\n \n print \" SNP {snp} with alpha {alpha}, bhta {bhta} and frequency {p}\".format(snp=i, alpha=alpha, bhta=bhta, p=p)\n self.initFreq.append(p)\n\n simu.evolve(\n \n initOps=[sim.InitGenotype(freq=[self.initFreq[i], 1-self.initFreq[i]], loci=i) for i in range(len(snps))],\n \n\n # initialize the sex and select the 50 loci (parents)\n preOps = [sim.InitSex(maleProp=0.5,at=[0]),\n\n # initialize the genotype of locus 50 at generation 0 (in the beginning of the simulation)\n sim.PyOperator(self.genotypeBegin,at=[0]),\n \n # Wait 50 generations for the system to reach equilibrium\n # Then, change the the genotype of locus 50 at generation 50 by inserting a single copy of allele 0 in one individual \n sim.PyOperator(self.genotypeAfter,at=[50]),\n\n # function that carries out the selection proccess\n sim.MaSelector(loci=50,wildtype=0,fitness=[1+s1, 1+s1/2, 1],begin=50, end=-1,subPops=1)],\n\n # recombination\n matingScheme=sim.RandomMating(ops=[\n sim.Recombinator(rates=recombination_rate)]),\n \n # mutation and migration of offsprings\n postOps = [\n\n \n sim.SNPMutator(u=mutation_rate,loci=mutate_snps),\n \n # call function to calculate Fst and check for equilibrium state\n sim.PyOperator(self.calcFst,step=step),\n\n #migration\n # Here we define an island model, but this can easily be changed.\n # For more information about the migration models, please look in the documentation of SimuPOP here http://simupop.sourceforge.net/manual_svn/build/userGuide_ch7_sec3.html\n sim.Migrator(sim.utils.migrIslandRates(migration_rate,self.numPop)),\n \n # call function to save the allele frequencies\n sim.PyOperator(self.checkAlleles, step=step, param = subPopNames),\n \n \n # check if locus 50 is lost due to genetic drift. If yes, we terminate the simulation\n sim.Stat(alleleFreq=50,step=step,subPops=1,begin=50,end=-1),\n sim.TerminateIf('alleleFreq[50][0] == 0',step=step,begin=50,end=-1),\n \n # check the progress of the simulation\n sim.PyEval('\"Gen: %d\" % gen',step=step),\n sim.PyOutput('\\n',step=step),\n \n ],\n gen=self.Gen\n \n )\n \n \n t2 = time.time()\n print \"simulation took\", t2-t1, \"seconds.\"","def run_automatic_tester():\n number_of_target_maps = len(os.listdir(TargetDetectionTesterSettings.TARGET_DETECTION_REPORT_JSON_FILE_SAVE_PATH))\n overall_true_positive_count = 0\n overall_false_positive_count = 0\n overall_target_count = 0\n\n for index_0 in range(number_of_target_maps):\n\n answer_sheet = json.load(open(os.path.join(TargetDetectionTesterSettings.TARGET_MAP_ANSWER_SHEET_PATH, str(index_0 + 1) + \".json\")))\n answer_list = []\n\n for index_1 in range(len(answer_sheet[\"targets\"])):\n answer_list.append((answer_sheet[\"targets\"][index_1][\"target_center_coordinates\"][0], answer_sheet[\"targets\"][index_1][\"target_center_coordinates\"][1]))\n overall_target_count += len(answer_list)\n\n target_detection_result = json.load(open(os.path.join(TargetDetectionTesterSettings.TARGET_DETECTION_REPORT_JSON_FILE_SAVE_PATH, str(index_0 + 1) + \".json\")))\n result_list = []\n\n for index_2 in range(len(target_detection_result[\"image_processing_results\"])):\n result_list.append((target_detection_result[\"image_processing_results\"][index_2][\"target_location\"][0] + (target_detection_result[\"image_processing_results\"][index_2][\"target_location\"][2] / 2), target_detection_result[\"image_processing_results\"][index_2][\"target_location\"][1] + (target_detection_result[\"image_processing_results\"][index_2][\"target_location\"][3] / 2)))\n\n current_true_positive_count = 0\n current_false_positive_count = 0\n banned_index_list = []\n\n for index_3 in range(len(answer_list)):\n true_positive_found = False\n\n for index_4 in range(len(result_list)):\n is_index_4_banned = False\n\n for index_5 in range(len(banned_index_list)):\n if (index_4 == banned_index_list[index_5]):\n is_index_4_banned = True\n\n if (is_index_4_banned == True):\n continue\n\n correct_target_center_x = answer_list[index_3][0]\n correct_target_center_y = answer_list[index_3][1]\n\n detected_target_center_x = result_list[index_4][0]\n detected_target_center_y = result_list[index_4][1]\n\n if ((abs(correct_target_center_x - detected_target_center_x) <= 20) and (abs(correct_target_center_y - detected_target_center_y) <= 20)):\n current_true_positive_count += 1\n banned_index_list.append(index_4)\n true_positive_found = True\n continue\n\n current_false_positive_count = len(result_list) - current_true_positive_count\n\n overall_true_positive_count += current_true_positive_count\n overall_false_positive_count += current_false_positive_count\n\n percentage = 100 * float(overall_true_positive_count) / (overall_target_count)\n\n TargetDetectionTesterLogger.log(\"--------------------------------------------------\")\n TargetDetectionTesterLogger.log(\"Total True Positive Count: \" + str(overall_true_positive_count))\n TargetDetectionTesterLogger.log(\"Total False Positive Count: \" + str(overall_false_positive_count))\n TargetDetectionTesterLogger.log(\"Percentage of Successfully Detected Targets: \" + str(percentage) + \"%\")\n TargetDetectionTesterLogger.log(\"--------------------------------------------------\")","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\"\n aStarSearch(problem)","def run_experiment() -> List[bool]:\n return [random.random() < 0.5 for _ in range(1000)]","def test_call(self, MetricClass, seed):\n m = MetricClass()\n strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))\n result0 = np.array(m.result(strategy)) # from `result` method\n result1 = np.array(m(strategy)) # from __call__\n assert np.equal(result0, result1).all()","def train_eval_rnd(self, train_data, test_data, rand_iter, train_labels, test_labels):\n np.random.seed(0)\n shuf_tr = [np.random.permutation(train_labels)\n for _ in range(rand_iter)]\n misclass_tr, misclass_ts = [], []\n for lab in shuf_tr:\n self.class_method.fit(train_data, lab)\n misclass_tr.append(zero_one_loss(lab, self.class_method.predict(train_data)))\n misclass_ts.append(zero_one_loss(test_labels,\n _kuhn_munkres_algorithm(test_labels,\n self.class_method.predict(test_data))))\n return np.mean(misclass_tr), np.mean(misclass_ts)\n # start = time.process_time()\n # np.random.seed(0)\n # shuf_tr, shuf_val = zip(*[list(map(lambda x: np.random.permutation(x),\n # [tr_labels, val_labels])) for _ in range(rand_iter)])\n # # print(f'Shuffle train:{shuf_tr}, Shuffle val:{shuf_val}')\n # # logging.info(f'Shuffle labels: {time.process_time()-start}s')\n # # part = time.process_time()\n # model_tr = [self.class_method.fit(train_data, lab) for lab in shuf_tr]\n # # print(f'Models:{model_tr}')\n # # logging.info(f'Train model: {time.process_time()-part}s')\n # # part = time.process_time()\n # misclass_tr = [zero_one_loss(x, y.predict(train_data)) for x, y in\n # zip(shuf_tr, model_tr)]\n # # print(f'Misclassification tr:{misclass_tr}')\n # # logging.info(f'Misclass TR: {time.process_time()-part}s')\n # # part = time.process_time()\n # misclass_val = [zero_one_loss(x, _kuhn_munkres_algorithm(x,\n # y.predict(val_data))) for x, y in\n # zip(shuf_val, model_tr)]\n # # print(f'Misclassification val:{misclass_val}')\n # # logging.info(f'Misclass VAL: {time.process_time()-part}s')\n # return np.mean(misclass_tr), np.mean(misclass_val)\n # misc_avg_tr, misc_avg_ts = [], []\n # append_tr = misc_avg_tr.append\n # append_ts = misc_avg_ts.append\n # for it in range(rand_iter):\n # np.random.seed(0)\n # np.random.shuffle(tr_labels)\n # np.random.seed(0)\n # np.random.shuffle(val_labels)\n # model_tr = self.class_method.fit(train_data, tr_labels)\n # misclass_tr = zero_one_loss(tr_labels,\n # self.class_method.predict(train_data))\n # misclass_ts = zero_one_loss(val_labels,\n # _kuhn_munkres_algorithm(val_labels,\n # model_tr.predict(val_data)))\n # append_tr(misclass_tr)\n # append_ts(misclass_ts)\n # return np.mean(misc_avg_tr), np.mean(misc_avg_ts)","def general_gantest(proba, nbr_qubits):\n for m in [4096, 2048]:\n for l in [1, 2, 3]:\n print(\"Easy mode results for m={} and l={}:\".format(m, l))\n Variationer_learn_gan(1000, l, m, proba=proba, n=nbr_qubits, distri_size=0, easy=True)\n print(\"\\n\")\n print(\"Distribution learning results for m={} and l={}:\".format(m, l))\n for d in [256, 512]:\n print(\"For \", d, \": \")\n Variationer_learn_gan(1000, l, m, proba=proba, n=nbr_qubits, distri_size=d, easy=False)\n print(\"Singleton learning results for m={} and l={}:\".format(m, l))\n Variationer_learn_gan(1000, l, m, proba=proba, n=nbr_qubits, distri_size=0, easy=False)","def bruteforce(request, url, host, port, agent, \n user_key, pass_key, action_val, words):\n # successful credentials\n success = []\n success_users = set()\n\n # Add all transformations for each word\n all_words = set(words)\n transformations = transform.generate_transformations(list(words))\n for word in words:\n transformation = transformations[word]\n all_words.add(transformation.lower)\n all_words.add(transformation.upper)\n all_words.add(transformation.reverse)\n all_words.add(transformation.leet)\n \n # Try all combinations for the form described by url on host\n content_type = HTTP_CONTENTTYPE_FORMENCODED\n sleep_time = HTTP_RETRY_TIME\n for user in all_words:\n for _pass in all_words:\n data = {user_key: user, pass_key: _pass, 'action': action_val}\n body = HttpRequest.generate_post_body(content_type,data)\n content_length = len(body)\n too_many_req = 0\n while too_many_req < HTTP_TOO_MANY_REQ:\n response = request.send_post_request(url, host, \n agent, content_type,\n content_length, body)\n if response is None:\n too_many_req += 1\n print(f\" unable to contact {host}{url}. retrying in {HTTP_RETRY_TIME} seconds.\")\n time.sleep(HTTP_RETRY_TIME)\n continue\n # print(f'User: {user}, Pass: {_pass}')\n \n # See if the response contained any words that indicate a successful login.\n if verify_success_resp(tokenize_html(response.response,True)):\n # print(f' SUCCESS.')\n if user.lower() not in success_users:\n success.append(Credential(user.lower(),_pass))\n success_users.add(user.lower())\n break\n \n # Check the status code.\n status_tuple = response.status_code\n if status_tuple is not None:\n status_code, __ = status_tuple\n # print(f' FAIL. {status_code}')\n if status_code == \"429\" or status_code == \"503\":\n time.sleep(sleep_time)\n print(f\" {host}{url} was busy. retrying in {HTTP_RETRY_TIME} seconds.\")\n too_many_req += 1\n else:\n break\n if too_many_req >= HTTP_TOO_MANY_REQ:\n return success\n return success","def evaluate_model_performance():\n\n config = load_config()\n data_processor = DataProcessor()\n df_test = data_processor.create_user_click_sequence(\n start_date=config[\"test_split_date\"]\n )\n df_test[\"truths\"] = df_test[\"merchant_seq\"].apply(lambda x: list(set(x)))\n truth_dict = dict(zip(df_test[\"user_id\"], df_test[\"truths\"]))\n\n # get model\n print(\"model training...\")\n model = Merchant2VecModel()\n model.train()\n\n # compute mAP@k\n k = model.num_rec\n all_truths, all_preds = [], []\n for user_id, user_merchants in truth_dict.items():\n this_pred = model.generate_predictions(\n user_id=user_id, eval_date=config[\"test_split_date\"]\n )\n all_truths.append(user_merchants)\n all_preds.append(this_pred)\n score = mapk(all_truths, all_preds, k)\n print(\"mAP@{} for current model: {:.4f}\".format(k, score))","def fuzz(self):\n self.total_mutant_index = 0\n self.total_num_mutations = self.num_mutations()\n\n self._main_fuzz_loop(self._iterate_protocol())","def test_random_unitary_gate(self):\n shots = 2000\n circuits = ref_unitary_gate.unitary_random_gate_circuits_nondeterministic(final_measure=True)\n targets = ref_unitary_gate.unitary_random_gate_counts_nondeterministic()\n result = execute(circuits, self.SIMULATOR, shots=shots).result()\n self.assertTrue(getattr(result, 'success', False))\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)","def main(self):\n \n\tsession = db.Session()\n\tspeed = -1\n\n\t#self.checkResponseStatus()\n\n\t#secondsBetween = random.uniform(config.MIN_SCAN_DELAY, config.MIN_SCAN_DELAY + 2)\n #time.sleep(secondsBetween)\n\t\n \tstartTime = time.time()\n#\tlogger.info(\"Starting scanning at: %s\", time.asctime( time.localtime(startTime) ) )\n\n\tself.minorFailCount = 0\n for i, point in enumerate(self.points):\n\t self.minorFailCount = 0\n\t self.performMapOperations(i, point, session)\n\n endTime = time.time()\n# logger.info(\"Stopped scanning at: %s\", time.asctime( time.localtime(endTime) ) )\n\ttimeElapsed = endTime - startTime\n\tminutes = timeElapsed/60\n\tminutesRounded = math.floor(minutes)\n\tseconds = math.floor(60*(minutes-minutesRounded))\n\tlogger.info(\"Time elapsed: %d:%d\", minutesRounded, seconds)\t \n logger.info(\"Total pokemon seen: %d (average per cycle: %f)\", self.seen_per_cycle, (self.seen_per_cycle/len(self.points))) \n \n session.close()\n if self.seen_per_cycle == 0:\n self.error_code = 'NO POKEMON'","def test_ngram():\n #Some examples of functions usage\n trigram_counts, bigram_counts, unigram_counts, token_count = train_ngrams(S_train)\n print \"#trigrams: \" + str(len(trigram_counts))\n print \"#bigrams: \" + str(len(bigram_counts))\n print \"#unigrams: \" + str(len(unigram_counts))\n print \"#tokens: \" + str(token_count)\n perplexity = evaluate_ngrams(S_dev, trigram_counts, bigram_counts, unigram_counts, token_count, 0.5, 0.4)\n print \"#perplexity: \" + str(perplexity)\n ### YOUR CODE HERE\n ### END YOUR CODE","def compare(numberOfSimulations, initialValue, sigma, T, strike, r = 0):\n \n numberOfTests = 100\n \n \n #the two lists that will contain our average errors for the different tests\n errorsStandardMonteCarlo = []\n errorsMonteCarloWithAV = []\n \n #our benchmark: the analytic price of the call option\n analyticPriceBS = blackScholesPriceCall(initialValue, r, sigma, T, initialValue)\n\n #look at how lambda functions are defined in Python \n payoff = lambda x : max(x - initialValue, 0)\n \n #alternatively:\n #def payoff(x):\n # return max(x - initialValue, 0)\n \n #note how to construct an object of a class\n \n blackScholesGenerator = GenerateBlackScholes(numberOfSimulations, T, initialValue, sigma, r)\n #k=0,..,numberOfTests - 1\n for k in range(numberOfTests):\n \n \n\n #first, the valuation with the standard Monte-Carlo:\n realizationsOfTheProcessWithStandardMC = blackScholesGenerator.generateRealizations()\n \n priceCalculatorWithStandardMC = SimpleEuropeanOption(realizationsOfTheProcessWithStandardMC, r)\n priceStandardMC = priceCalculatorWithStandardMC.getPrice(payoff, T) \n errorWithStandardMC= abs(priceStandardMC - analyticPriceBS)/analyticPriceBS\n #note how to append new values to a list\n errorsStandardMonteCarlo.append(errorWithStandardMC)\n \n #then, the one with Antithetic Variables:\n realizationsOfTheProcessWithAV = blackScholesGenerator.generateRealizationsAntitheticVariables()\n \n priceCalculatorWithAV = SimpleEuropeanOption(realizationsOfTheProcessWithAV, r)\n priceWithAV = priceCalculatorWithAV.getPrice(payoff, T) \n errorWithAV= abs(priceWithAV - analyticPriceBS)/analyticPriceBS\n #note how to append new values to a list\n errorsMonteCarloWithAV.append(errorWithAV)\n\n #we get and return the respective average errors: mean is imported from\n #statistics\n averageErrorStandardMC = mean(errorsStandardMonteCarlo)\n #you can also use numpy\n averageErrorAV = np.mean(errorsMonteCarloWithAV)\n \n return averageErrorStandardMC, averageErrorAV","def test_hackerrank_sample1(self):\n result = find_digits(12)\n self.assertEquals(result, 2)","def test_generate_nb_testing(self):\n pass","def runtest(self):","def run_simulation(n, experiments, iterations, budget, recovery_count, performance_factor, current_top,\r\n precomputed=True, dataset=None):\r\n T = 0\r\n k = 5\r\n delta = 0.1\r\n range_m = 1*np.arange(1, budget+1)\r\n scores, true_top = init(n, precomputed=precomputed, dataset=dataset)\r\n true_ranks = get_ranks(scores)\r\n\r\n for exp in tqdm.tqdm(range(experiments), desc=\"experiments\"):\r\n for itr in tqdm.tqdm(range(iterations), desc=\"iterations\"):\r\n t = 1\r\n count = 0\r\n A = np.arange(n)\r\n P = np.zeros((n, n))\r\n S = np.zeros(n)\r\n r_count = 0\r\n data = []\r\n for b in range(budget):\r\n m = range_m[b]\r\n\r\n est, t, A, P, S, count, r_count, data = sparse_borda(n, t, T, k, A, P, S, delta, scores, m*n, count, r_count, data)\r\n\r\n ranking, ranks, top = get_ranking(n, est)\r\n if(top == true_top):\r\n recovery_count[b][exp] += 1\r\n performance_factor[b][exp] += ranks[true_top]\r\n current_top[b][exp] += true_ranks[top]\r\n\r\n current_top /= iterations\r\n performance_factor /= iterations\r\n\r\n return ranking, ranks, data, scores, true_top, est, recovery_count, performance_factor, current_top","def test_marketsim(description, group, inputs, outputs, grader):\n\n points_earned = 0.0 # initialize points for this test case\n try:\n # Try to import student code (only once)\n if not main_code in globals():\n import importlib\n # * Import module\n mod = importlib.import_module(main_code)\n globals()[main_code] = mod\n # * Import methods to test\n for m in ['compute_portvals']:\n globals()[m] = getattr(mod, m)\n\n incorrect = False\n msgs = []\n\n if group == 'author':\n try:\n # globals()['author'] = getattr(marketsim, 'author')\n auth_string = run_with_timeout(marketsim.author,seconds_per_test_case,(),{})\n if auth_string == 'tb34':\n incorrect = True\n msgs.append(\" Incorrect author name (tb34)\")\n points_earned = -20\n elif auth_string == '':\n incorrect = True\n msgs.append(\" Empty author name\")\n points_earned = -20\n except Exception as e:\n incorrect = True\n msgs.append(\" Exception occured when calling author() method: {}\".format(e))\n points_earned = -20\n else:\n # Unpack test case\n orders_file = inputs['orders_file']\n start_val = inputs['start_val']\n\n portvals = None\n fullpath_orders_file = orders_file#get_orders_data_file(orders_file)\n portvals = run_with_timeout(compute_portvals,seconds_per_test_case,(fullpath_orders_file,start_val),{})\n # Verify against expected outputs and assign points\n\n # * Check return type is correct, coax into Series\n assert (type(portvals) == pd.Series) or (type(portvals) == pd.DataFrame and len(portvals.columns) == 1), \"You must return a Series or single-column DataFrame!\"\n if type(portvals) == pd.DataFrame:\n portvals = portvals[portvals.columns[0]] # convert single-column DataFrame to Series\n if group == 'basic':\n if len(portvals) != outputs['num_days']:\n incorrect=True\n msgs.append(\" Incorrect number of days: {}, expected {}\".format(len(portvals), outputs['num_days']))\n else:\n points_earned += 2.0\n if abs(portvals[-1]-outputs['last_day_portval']) > (0.001*outputs['last_day_portval']):\n incorrect=True\n msgs.append(\" Incorrect final value: {}, expected {}\".format(portvals[-1],outputs['last_day_portval']))\n else:\n points_earned += 5.0\n adr,sr = get_stats(portvals)\n if abs(sr-outputs['sharpe_ratio']) > abs(0.001*outputs['sharpe_ratio']):\n incorrect=True\n msgs.append(\" Incorrect sharpe ratio: {}, expected {}\".format(sr,outputs['sharpe_ratio']))\n else:\n points_earned += 1.5\n if abs(adr-outputs['avg_daily_ret']) > abs(0.001*outputs['avg_daily_ret']):\n incorrect=True\n msgs.append(\" Incorrect avg daily return: {}, expected {}\".format(adr,outputs['avg_daily_ret']))\n else:\n points_earned += 1.0\n elif group=='leverage':\n if abs(portvals[-1]-outputs['last_day_portval']) > (0.001*outputs['last_day_portval']):\n incorrect = True\n msgs.append(\" Incorrect final value: {}, expected {}\".format(portvals[-1],outputs['last_day_portval']))\n else:\n points_earned += 1.0\n if incorrect:\n # inputs_str = \" orders_file: {}\\n\" \\\n # \" start_val: {}\\n\".format(orders_file, start_val)\n raise IncorrectOutput, \"Test failed on one or more output criteria.\\n Inputs:\\n{}\\n Failures:\\n{}\".format(inputs, \"\\n\".join(msgs))\n except Exception as e:\n # Test result: failed\n msg = \"Test case description: {}\\n\".format(description)\n \n # Generate a filtered stacktrace, only showing erroneous lines in student file(s)\n \n tb_list = tb.extract_tb(sys.exc_info()[2])\n if 'grading_traceback' in dir(e):\n tb_list = e.grading_traceback\n for i in xrange(len(tb_list)):\n row = tb_list[i]\n tb_list[i] = (os.path.basename(row[0]), row[1], row[2], row[3]) # show only filename instead of long absolute path\n tb_list = [row for row in tb_list if row[0] == 'marketsim.py']\n if tb_list:\n msg += \"Traceback:\\n\"\n msg += ''.join(tb.format_list(tb_list)) # contains newlines\n msg += \"{}: {}\".format(e.__class__.__name__, e.message)\n\n # Report failure result to grader, with stacktrace\n grader.add_result(GradeResult(outcome='failed', points=points_earned, msg=msg))\n raise\n else:\n # Test result: passed (no exceptions)\n grader.add_result(GradeResult(outcome='passed', points=points_earned, msg=None))","def algorithm_loop(self):","def faster():\n try:\n ttsEng.faster()\n except Exception, e:\n logging.error(e)","def iteration(self):\n T = self.generate_T()\n R = self.reproduce(T)\n self.P = self.choose_mi_best(R)\n #print(self.P)","def run():\n # all data and labels\n # tracemalloc.start()\n # start = time.time()\n data, labels = Startdata.getdata() # texts\n data2, labels2 = Startdata.getdata2() # emails\n # Startdata.bagofwords(data2, labels2)\n data, labels = Startdata.combinedata(data, data2, labels, labels2)\n # split into training and testing. 1/3 test, 2/3 train\n traind, trainl, testd, testl = Startdata.splitdata(data, labels)\n\n # labels\n trainlabels = Startdata.labelfix(trainl)\n testlabels = Startdata.labelfix(testl)\n\n # selective features\n #\n # extract features for use. in the shape of NxD\n # N is number of samples, D is number of features\n # current, peak = tracemalloc.get_traced_memory()\n trainfeat = Startdata.featurextract(traind, trainl)\n testfeat = Startdata.featurextract(testd, testl)\n # theta is the weights in a D+1 X 1 array\n theta = Spamfilter.train(trainfeat, trainlabels)\n #\n # trying bag of words\n #\n\n # Startdata.featurextract(data, labels)\n # error rate was 1.69% for trainingdata\n # 2.21% for testing data\n # bag, tfeat = Startdata.bagofwords(traind)\n # theta = Spamfilter.train(tfeat, trainlabels)\n # testfeat = Startdata.features(testd, bag)\n\n test(theta, testfeat, testlabels)\n # tracemalloc.stop()\n # done = time.time()\n # print(f\"Current memory usage is {current / 10**6} MB; Peak was {peak / 10**6} MB\")\n # print(\"time to complete\", done - start)\n # NTR 12/1/2020 current best featextraction at 25 iterations is about\n # 0.7-1% error for\n # trainingdata and testing data\n # NTR 12/2/2020 bag of words at 25 iterations\n # 1.69% training error, 2.21% testing error\n # NTR 12/2/2020 bag of words, 25 iter, removal of some features\n # NTR 12/3/2020 featextraction 20 iterations, new features, emails inc\n # 0.59% error on training. 0.63% testing error","def run_benchmark():\n import argparse\n parser = argparse.ArgumentParser(description='Benchmark alchemically modified system against unmodified system.')\n parser.add_argument('--platform', dest='platform_name', action='store', default=None, help='platform name to benchmark (default: None)')\n options = parser.parse_args()\n\n from sams.tests import testsystems\n for testsystem_name in ['AblImatinibExplicitAlchemical']:\n cls = getattr(testsystems, testsystem_name)\n testsystem = cls()\n factory_args = { 'ligand_atoms' : testsystem.alchemical_atoms, 'receptor_atoms' : range(0,4266) }\n benchmark(testsystem.system, testsystem.positions, platform_name=options.platform_name, nsteps=5000, timestep=1.0*unit.femtoseconds, factory_args=factory_args)","def _evaluate_performance__static_winners(self):\n # | - _evaluate_performance__\n\n # | - class attributes #################################################\n AL = self\n al_gen = self.al_gen\n verbose = self.verbose\n seed_ids = self.seed_ids\n acquisition_bin = self.acquisition_bin\n completed_ids = self.completed_ids\n CandidateSpace = self.CandidateSpace\n RegressionModel = self.RegressionModel\n DuplicateFinder = self.DuplicateFinder\n al_gen_dict = self.al_gen_dict\n\n stop_mode = self.stop_mode\n stop_num_generations = self.stop_num_generations\n\n index_acq_gen_dict = self.index_acq_gen_dict\n #__| #################################################################\n\n # #####################################################################\n mode = \"lowest_N\" # 'lowest_N' or 'lowest_perc'\n\n N_ids = 10\n lowest_perc = 5\n\n # Number of consecutive generations that the Nth best systems must\n # remain static\n M_gens = 3\n # #####################################################################\n\n if mode == \"lowest_perc\":\n num_candidates = CandidateSpace.FingerPrints.df_pre.shape[0]\n N_ids = int(num_candidates * (lowest_perc * 0.01))\n\n gen_keys = list(AL.al_gen_dict.keys())\n\n if len(gen_keys) > M_gens:\n latest_M_keys = gen_keys[-(M_gens + 1):]\n last_gen_key = gen_keys[-1]\n\n al_gen_dict_subset_i = dict(zip(\n latest_M_keys,\n [AL.al_gen_dict.get(i, None) for i in latest_M_keys]))\n\n indices_list = []\n iterator = enumerate(al_gen_dict_subset_i.items())\n for i_cnt, (gen_i, AL_i) in iterator:\n model_i = AL_i.model\n\n model_i = AL.add_main_Y_to_model(\n model_i, plot_dft_instead_of_pred=True)\n model_i = model_i[(model_i[\"duplicate\"] == False)]\n model_i = model_i.sort_values(\"Y_main\")\n\n indices_i = model_i.index.tolist()\n\n indices_list.append(indices_i)\n\n if i_cnt >= M_gens:\n indices_i = indices_list[i_cnt][0:N_ids]\n ids_static_list = []\n for j in range(M_gens):\n indices_j = indices_list[i_cnt - (j + 1)][0:N_ids]\n ids_static = indices_j == indices_i\n ids_static_list.append(ids_static)\n\n ids_are_static = all(ids_static_list)\n\n self.performance__static_winners[last_gen_key] = ids_are_static\n #__|","def simulate_run(run, maker, all_data, train_mask, test_mask, instances, independent, mixture):\n\n train_data = all_data.masked(train_mask)\n test_data = all_data.masked(test_mask)\n\n if instances is not None:\n ids = sorted(train_data.run_lists, key = lambda _: numpy.random.rand())[:instances]\n train_data = train_data.filter(*ids)\n\n if independent:\n train_data = train_data.collect_independent(mixture).only_nonempty()\n else:\n train_data = train_data.collect_systematic(mixture).only_nonempty()\n\n budget = test_data.common_budget\n #budget = test_data.common_budget / 2 # XXX\n suite = borg.fake.FakeSuite(test_data)\n\n if maker.subname == \"preplanning-dir\":\n model_kwargs = {\"K\": 64}\n\n if \"set_alpha\" in maker.variants:\n model_kwargs[\"alpha\"] = 1e-2\n else:\n model_kwargs = {}\n\n solver = maker(suite, train_data, model_kwargs = model_kwargs)\n successes = []\n\n for (i, instance_id) in enumerate(test_data.run_lists):\n logger.info(\"simulating run %i/%i on %s\", i, len(test_data), instance_id)\n\n with suite.domain.task_from_path(instance_id) as instance:\n with borg.accounting() as accountant:\n answer = solver.start(instance).run_then_stop(budget)\n\n succeeded = suite.domain.is_final(instance, answer)\n\n logger.info(\n \"%s %s on %s (%.2f CPU s)\",\n maker.name,\n \"succeeded\" if succeeded else \"failed\",\n os.path.basename(instance),\n accountant.total.cpu_seconds,\n )\n\n if succeeded:\n successes.append(accountant.total.cpu_seconds)\n\n logger.info(\n \"%s had %i successes over %i instances\",\n maker.name,\n len(successes),\n len(test_data),\n )\n\n description = \"{0} ({1})\".format(mixture, \"Sep.\" if independent else \"Sys.\")\n\n return (\n description,\n maker.name,\n instances,\n len(successes),\n numpy.mean(successes),\n numpy.median(successes),\n )"],"string":"[\n \"def main():\\n hash_str = '5411ba21c470e12d49f351a2d240e43618032950'\\n salt = '0d71906d0f735e6196c80d0a7cb1748e'\\n encrypted_code = 'Ul5SR0ISYFxUXl8OOxITFBFWVlIRQVtRXV4bHQs4ExQREhMUERJDRlhcRxwWZltdQhJaRxFTE0BUQUcUXF1XQV1XFB07EhMUE' \\\\\\n 'RITFBFCQV1fRhsTZVdAQBFhRldSV0BHV0dfGhYbOQ=='\\n bruter = CodeBrute(hash_str, salt)\\n start = timer()\\n _key, iterations = bruter.brute()\\n print('Found', _key)\\n print('Attempts:', iterations)\\n elapsed = timer() - start\\n print('Time:', elapsed)\\n bruter.decrypt_and_execute(encrypted_code, str(_key))\",\n \"def bruteForceTime():\\n start_time = time.time()\\n subjects = loadSubjects(SUBJECT_FILENAME)\\n maxWork = 8\\n answer = bruteForceAdvisor(subjects, maxWork)\\n end_time = time.time()\\n printSubjects(answer)\\n print 'Time taken: ', end_time - start_time\\n return None\",\n \"def main():\\r\\n _evaluative_test(5)\\r\\n _fuzz_test(1)\\r\\n _fuzz_test(1, 512)\\r\\n _fuzz_test(1, 1512)\\r\\n _fuzz_test(1000)\\r\\n _fuzz_test(1000, 512)\\r\\n _fuzz_test(1000, 4077)\",\n \"def test_run_sim():\\n rnd = rand.Arrivals(31, 40)\\n sim.run_sim(2, 1, 3, 4, 24, rnd)\",\n \"def mbruteforce(func, alphabet, length, method = 'upto', start = None, threads = None):\\n\\n def bruteforcewrap(func, alphabet, length, method, start, databag):\\n oldloglevel = context.log_level\\n context.log_level = 'critical'\\n res = bruteforce(func, alphabet, length, method=method, start=start, databag=databag)\\n context.log_level = oldloglevel\\n databag[\\\"result\\\"] = res\\n\\n if start == None:\\n start = (1, 1)\\n\\n if threads == None:\\n try:\\n threads = multiprocessing.cpu_count()\\n except NotImplementedError:\\n threads = 1\\n\\n h = log.waitfor('MBruteforcing')\\n processes = [None] * threads\\n shareddata = [None] * threads\\n\\n (i2, N2) = start\\n totalchunks = threads * N2\\n\\n for i in range(threads):\\n shareddata[i] = multiprocessing.Manager().dict()\\n shareddata[i]['result'] = None\\n shareddata[i]['current_item'] = \\\"\\\"\\n shareddata[i]['items_done'] = 0\\n shareddata[i]['items_total'] = 0\\n\\n chunkid = (i2-1) + (i * N2) + 1\\n\\n processes[i] = multiprocessing.Process(target=bruteforcewrap,\\n args=(func, alphabet, length, method, (chunkid, totalchunks),\\n shareddata[i]))\\n processes[i].start()\\n\\n done = False\\n\\n while not done:\\n # log status\\n current_item_list = \\\",\\\".join([\\\"\\\\\\\"%s\\\\\\\"\\\" % x[\\\"current_item\\\"]\\n for x in shareddata if x != None])\\n items_done = sum([x[\\\"items_done\\\"] for x in shareddata if x != None])\\n items_total = sum([x[\\\"items_total\\\"] for x in shareddata if x != None])\\n\\n progress = 100.0 * items_done / items_total if items_total != 0 else 0.0\\n\\n h.status('Trying %s -- %0.3f%%' % (current_item_list, progress))\\n\\n # handle finished threads\\n for i in range(threads):\\n if processes[i] and processes[i].exitcode != None:\\n # thread has terminated\\n res = shareddata[i][\\\"result\\\"]\\n processes[i].join()\\n processes[i] = None\\n\\n # if successful, kill all other threads and return success\\n if res != None:\\n for i in range(threads):\\n if processes[i] != None:\\n processes[i].terminate()\\n processes[i].join()\\n processes[i] = None\\n h.success('Found key: \\\"%s\\\"' % res)\\n return res\\n\\n if all([x == None for x in processes]):\\n done = True\\n time.sleep(0.3)\\n h.failure('No matches found')\",\n \"def _brute_force(self):\\n if self.N > 9:\\n #print(\\\"Input set is too big for brute force estimation.\\\")\\n self.best_path = None\\n else:\\n #print(\\\"Number of permutations to check: {}\\\".format(math.factorial(self.N)))\\n #init = \\n A = self._P + np.finfo(np.float).eps\\n A = (A + (1-A).T)/2\\n for i in range(A.shape[0]):\\n A[i,i] = np.finfo(np.float).eps\\n init = (A>0.5).sum(axis=1).argsort()[::-1]\\n #--- use log(p(Y=1\\\\mid s',s)) to shift multiplication to sum\\n lP = np.log(A)\\n for i in range(lP.shape[0]):\\n lP[i,i] = 0\\n #init_cost = 0\\n ##--- lP[x:x+1] está MAL hay que sumar respecto a i+1 en z, no en lP.\\n #for i in range(len(init)-1):\\n # init_cost += lP[init[i],init[i+1]:].sum()\\n z_star = []\\n z_cost = -np.inf\\n for z in permutations(range(self.N)):\\n cost = 0\\n for i in range(len(z)-1):\\n cost += lP[z[i],z[i+1:]].sum()\\n if cost > z_cost:\\n z_cost = cost\\n z_star = z\\n self.best_path = np.array(z_star)\",\n \"def test_run_sim_1():\\n rnd = rand.Arrivals(36, 41)\\n sim.run_sim(3, 2, 5, 6, 22, rnd)\",\n \"def brute_force(city_list):\\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,6)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 6 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 6 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\"-\\\")\\n \\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,7)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 7 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 7 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\"-\\\")\\n \\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,8)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 8 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 8 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\"-\\\")\\n \\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,9)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 9 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 9 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\"-\\\")\\n \\n start = time.time()*1000\\n shortest = exhaustive_search(city_list,10)\\n stop = time.time()*1000\\n print(\\\"Shortest tour for 10 first cities:\\\", tour_distance(shortest))\\n print (\\\"Time spent on 10 first cities:\\\", \\\"%.2f\\\" % (stop-start), \\\"ms\\\")\\n print(\\\" \\\")\",\n \"def evaluate_all_points():\\n start_time = timeit.default_timer()\\n mua, vra = pgen.get_pdf()\\n slack = ptsl.D\\n\\n all_alloc = list(itertools.product(range(1,ptsl.M+1),repeat=ptsl.NPH))\\n riska = []\\n f2 = open(\\\"risk-file-D216-NPH5.csv\\\",\\\"w\\\")\\n f2.write(\\\"alloc1,alloc2,alloc3,alloc4,alloc5,risk,util\\\\n\\\")\\n count = 0\\n for a in all_alloc :\\n a1, a2, a3, a4, a5 = a\\n r = compute_risk(mua, vra, a, slack)\\n \\n if r > 0.00001 and r < 1 - 0.00001 :\\n riska.append(r)\\n util = a1 * mua[a1-1] + a2 * mua[a2-1] + a3 * mua[a3-1] + a4 * mua[a4-1] + a5 * mua[a5-1]\\n f2.write(\\\"%d,%d,%d,%d,%d,%f,%f\\\\n\\\"%(a1,a2,a3,a4,a5,r,util))\\n count = count + 1\\n f2.close()\\n np.save(\\\"stored_risk\\\",riska)\\n elapsed = timeit.default_timer() - start_time\\n print(\\\"Brute Force Evaluation Time for %d points : %fs\\\"%(count,elapsed))\",\n \"def test_bottleneck(self):\\n # import the experiment variable from the example\\n exp = bottleneck_example(20, 5, render=False)\\n\\n # run the experiment for a few time steps to ensure it doesn't fail\\n exp.run(1, 5)\",\n \"def bruteforce(func, alphabet, length, method = 'upto', start = None, databag = None):\\n\\n if method == 'upto' and length > 1:\\n iterator = product(alphabet, repeat = 1)\\n for i in xrange(2, length + 1):\\n iterator = chain(iterator, product(alphabet, repeat = i))\\n\\n elif method == 'downfrom' and length > 1:\\n iterator = product(alphabet, repeat = length)\\n for i in xrange(length - 1, 1, -1):\\n iterator = chain(iterator, product(alphabet, repeat = i))\\n\\n elif method == 'fixed':\\n iterator = product(alphabet, repeat = length)\\n\\n else:\\n raise TypeError('bruteforce(): unknown method')\\n\\n if method == 'fixed':\\n total_iterations = len(alphabet) ** length\\n else:\\n total_iterations = (len(alphabet) ** (length + 1) / (len(alphabet) - 1)) - 1\\n\\n if start is not None:\\n i, N = start\\n if i > N:\\n raise ValueError('bruteforce(): invalid starting point')\\n\\n i -= 1\\n chunk_size = total_iterations / N\\n rest = total_iterations % N\\n starting_point = 0\\n\\n for chunk in range(N):\\n if chunk >= i:\\n break\\n if chunk <= rest:\\n starting_point += chunk_size + 1\\n else:\\n starting_point += chunk_size\\n\\n if rest >= i:\\n chunk_size += 1\\n\\n total_iterations = chunk_size\\n\\n h = log.waitfor('Bruteforcing')\\n cur_iteration = 0\\n if start != None:\\n consume(i, iterator)\\n for e in iterator:\\n cur = ''.join(e)\\n cur_iteration += 1\\n if cur_iteration % 2000 == 0:\\n progress = 100.0 * cur_iteration / total_iterations\\n h.status('Trying \\\"%s\\\", %0.3f%%' % (cur, progress))\\n if databag:\\n databag[\\\"current_item\\\"] = cur\\n databag[\\\"items_done\\\"] = cur_iteration\\n databag[\\\"items_total\\\"] = total_iterations\\n res = func(cur)\\n if res:\\n h.success('Found key: \\\"%s\\\"' % cur)\\n return cur\\n if start != None:\\n consume(N - 1, iterator)\\n\\n h.failure('No matches found')\",\n \"def test_stress(self):\\n primorial100 = 4711930799906184953162487834760260422020574773409675520188634839616415335845034221205289256705544681972439104097777157991804380284218315038719444943990492579030720635990538452312528339864352999310398481791730017201031090\\n for i in range(10000):\\n self.assertEqual(primorial(100), primorial100)\",\n \"def speed():\\r\\n\\r\\n algo = ['logistic_sgd', 'logistic_cg', 'mlp', 'convolutional_mlp',\\r\\n 'dA', 'SdA', 'DBN', 'rbm', 'rnnrbm']\\r\\n to_exec = [True] * len(algo)\\r\\n# to_exec = [False] * len(algo)\\r\\n# to_exec[-1] = True\\r\\n do_float64 = True\\r\\n do_float32 = True\\r\\n do_gpu = True\\r\\n\\r\\n algo_executed = [s for idx, s in enumerate(algo) if to_exec[idx]]\\r\\n #Timming expected are from the buildbot that have an i7-920 @\\r\\n # 2.67GHz with hyperthread enabled for the cpu, 12G of ram. An GeForce GTX\\r\\n # 285 for the GPU. OS=Fedora 14, gcc=4.5.1, python/BLAS from EPD\\r\\n # 7.1-2 (python 2.7.2, mkl unknow). BLAS with only 1 thread.\\r\\n\\r\\n expected_times_64 = numpy.asarray([10.0, 22.5, 76.1, 73.7, 116.4,\\r\\n 346.9, 381.9, 558.1, 186.3])\\r\\n expected_times_32 = numpy.asarray([11.6, 29.6, 42.5, 66.5, 71,\\r\\n 191.2, 226.8, 432.8, 176.2])\\r\\n\\r\\n # Number with just 1 decimal are new value that are faster with\\r\\n # the Theano version 0.5rc2 Other number are older. They are not\\r\\n # updated, as we where faster in the past!\\r\\n # TODO: find why and fix this!\\r\\n\\r\\n# Here is the value for the buildbot on February 3th 2012.\\r\\n# sgd, cg mlp conv da\\r\\n# sda dbn rbm\\r\\n# gpu times[3.72957802, 9.94316864, 29.1772666, 9.13857198, 25.91144657,\\r\\n# 18.30802011, 53.38651466, 285.41386175]\\r\\n# expected [3.076634879, 7.555234910, 18.99226785, 9.58915591, 24.130070450,\\r\\n# 24.77524018, 92.66246653, 322.340329170]\\r\\n# sgd, cg mlp conv da\\r\\n# sda dbn rbm\\r\\n#expected/get [0.82492841, 0.75984178, 0.65092691, 1.04930573, 0.93125138\\r\\n# 1.35324519 1.7356905 1.12937868]\\r\\n expected_times_gpu = numpy.asarray([3.07663488, 7.55523491, 18.99226785,\\r\\n 9.6, 24.13007045,\\r\\n 20.4, 56, 302.6, 315.4])\\r\\n expected_times_64 = [s for idx, s in enumerate(expected_times_64)\\r\\n if to_exec[idx]]\\r\\n expected_times_32 = [s for idx, s in enumerate(expected_times_32)\\r\\n if to_exec[idx]]\\r\\n expected_times_gpu = [s for idx, s in enumerate(expected_times_gpu)\\r\\n if to_exec[idx]]\\r\\n\\r\\n def time_test(m, l, idx, f, **kwargs):\\r\\n if not to_exec[idx]:\\r\\n return\\r\\n print algo[idx]\\r\\n ts = m.call_time\\r\\n try:\\r\\n f(**kwargs)\\r\\n except Exception, e:\\r\\n print >> sys.stderr, 'test', algo[idx], 'FAILED', e\\r\\n l.append(numpy.nan)\\r\\n return\\r\\n te = m.call_time\\r\\n l.append(te - ts)\\r\\n\\r\\n def do_tests():\\r\\n m = theano.compile.mode.get_default_mode()\\r\\n l = []\\r\\n time_test(m, l, 0, logistic_sgd.sgd_optimization_mnist, n_epochs=30)\\r\\n time_test(m, l, 1, logistic_cg.cg_optimization_mnist, n_epochs=30)\\r\\n time_test(m, l, 2, mlp.test_mlp, n_epochs=5)\\r\\n time_test(m, l, 3, convolutional_mlp.evaluate_lenet5, n_epochs=5,\\r\\n nkerns=[5, 5])\\r\\n time_test(m, l, 4, dA.test_dA, training_epochs=2,\\r\\n output_folder='tmp_dA_plots')\\r\\n time_test(m, l, 5, SdA.test_SdA, pretraining_epochs=1,\\r\\n training_epochs=2, batch_size=300)\\r\\n time_test(m, l, 6, DBN.test_DBN, pretraining_epochs=1,\\r\\n training_epochs=2, batch_size=300)\\r\\n time_test(m, l, 7, rbm.test_rbm, training_epochs=1, batch_size=300,\\r\\n n_chains=1, n_samples=1, output_folder='tmp_rbm_plots')\\r\\n time_test(m, l, 8, rnnrbm.test_rnnrbm, num_epochs=1)\\r\\n return numpy.asarray(l)\\r\\n\\r\\n #test in float64 in FAST_RUN mode on the cpu\\r\\n import theano\\r\\n if do_float64:\\r\\n theano.config.floatX = 'float64'\\r\\n theano.config.mode = 'FAST_RUN'\\r\\n float64_times = do_tests()\\r\\n print >> sys.stderr, algo_executed\\r\\n print >> sys.stderr, 'float64 times', float64_times\\r\\n print >> sys.stderr, 'float64 expected', expected_times_64\\r\\n print >> sys.stderr, 'float64 % expected/get', (\\r\\n expected_times_64 / float64_times)\\r\\n\\r\\n #test in float32 in FAST_RUN mode on the cpu\\r\\n theano.config.floatX = 'float32'\\r\\n if do_float32:\\r\\n float32_times = do_tests()\\r\\n print >> sys.stderr, algo_executed\\r\\n print >> sys.stderr, 'float32 times', float32_times\\r\\n print >> sys.stderr, 'float32 expected', expected_times_32\\r\\n print >> sys.stderr, 'float32 % expected/get', (\\r\\n expected_times_32 / float32_times)\\r\\n\\r\\n if do_float64:\\r\\n print >> sys.stderr, 'float64/float32', (\\r\\n float64_times / float32_times)\\r\\n print >> sys.stderr\\r\\n print >> sys.stderr, 'Duplicate the timing to have everything in one place'\\r\\n print >> sys.stderr, algo_executed\\r\\n print >> sys.stderr, 'float64 times', float64_times\\r\\n print >> sys.stderr, 'float64 expected', expected_times_64\\r\\n print >> sys.stderr, 'float64 % expected/get', (\\r\\n expected_times_64 / float64_times)\\r\\n print >> sys.stderr, 'float32 times', float32_times\\r\\n print >> sys.stderr, 'float32 expected', expected_times_32\\r\\n print >> sys.stderr, 'float32 % expected/get', (\\r\\n expected_times_32 / float32_times)\\r\\n\\r\\n print >> sys.stderr, 'float64/float32', (\\r\\n float64_times / float32_times)\\r\\n print >> sys.stderr, 'expected float64/float32', (\\r\\n expected_times_64 / float32_times)\\r\\n\\r\\n #test in float32 in FAST_RUN mode on the gpu\\r\\n import theano.sandbox.cuda\\r\\n if do_gpu:\\r\\n theano.sandbox.cuda.use('gpu')\\r\\n gpu_times = do_tests()\\r\\n print >> sys.stderr, algo_executed\\r\\n print >> sys.stderr, 'gpu times', gpu_times\\r\\n print >> sys.stderr, 'gpu expected', expected_times_gpu\\r\\n print >> sys.stderr, 'gpu % expected/get', (\\r\\n expected_times_gpu / gpu_times)\\r\\n\\r\\n if do_float64:\\r\\n print >> sys.stderr, 'float64/gpu', float64_times / gpu_times\\r\\n\\r\\n if (do_float64 + do_float32 + do_gpu) > 1:\\r\\n print >> sys.stderr\\r\\n print >> sys.stderr, 'Duplicate the timing to have everything in one place'\\r\\n print >> sys.stderr, algo_executed\\r\\n if do_float64:\\r\\n print >> sys.stderr, 'float64 times', float64_times\\r\\n print >> sys.stderr, 'float64 expected', expected_times_64\\r\\n print >> sys.stderr, 'float64 % expected/get', (\\r\\n expected_times_64 / float64_times)\\r\\n if do_float32:\\r\\n print >> sys.stderr, 'float32 times', float32_times\\r\\n print >> sys.stderr, 'float32 expected', expected_times_32\\r\\n print >> sys.stderr, 'float32 % expected/get', (\\r\\n expected_times_32 / float32_times)\\r\\n if do_gpu:\\r\\n print >> sys.stderr, 'gpu times', gpu_times\\r\\n print >> sys.stderr, 'gpu expected', expected_times_gpu\\r\\n print >> sys.stderr, 'gpu % expected/get', (\\r\\n expected_times_gpu / gpu_times)\\r\\n\\r\\n if do_float64 and do_float32:\\r\\n print >> sys.stderr, 'float64/float32', (\\r\\n float64_times / float32_times)\\r\\n print >> sys.stderr, 'expected float64/float32', (\\r\\n expected_times_64 / float32_times)\\r\\n if do_float64 and do_gpu:\\r\\n print >> sys.stderr, 'float64/gpu', float64_times / gpu_times\\r\\n print >> sys.stderr, 'expected float64/gpu', (\\r\\n expected_times_64 / gpu_times)\\r\\n if do_float32 and do_gpu:\\r\\n print >> sys.stderr, 'float32/gpu', float32_times / gpu_times\\r\\n print >> sys.stderr, 'expected float32/gpu', (\\r\\n expected_times_32 / gpu_times)\\r\\n\\r\\n def compare(x, y):\\r\\n ratio = x / y\\r\\n # If there is more then 5% difference between the expected\\r\\n # time and the real time, we consider this an error.\\r\\n return sum((ratio < 0.95) + (ratio > 1.05))\\r\\n\\r\\n if do_float64:\\r\\n err = compare(expected_times_64, float64_times)\\r\\n print >> sys.stderr, 'speed_failure_float64=' + str(err)\\r\\n if do_float32:\\r\\n err = compare(expected_times_32, float32_times)\\r\\n print >> sys.stderr, 'speed_failure_float32=' + str(err)\\r\\n if do_gpu:\\r\\n err = compare(expected_times_gpu, gpu_times)\\r\\n print >> sys.stderr, 'speed_failure_gpu=' + str(err)\\r\\n\\r\\n assert not numpy.isnan(gpu_times).any()\",\n \"def printAlgorithmResults (test_case, key_size, plaintext, ciphertext, e, n, d):\\r\\n brute_force_time = -1\\r\\n\\r\\n if test_case < 7:\\r\\n start = time.time()\\r\\n d_actual_bf = crackRsaBruteForce(e, n)\\r\\n end = time.time()\\r\\n brute_force_time = '%.3f'%(end-start)\\r\\n\\r\\n start = time.time()\\r\\n d_actual = crackRsaPrivateKey(e, n)\\r\\n end = time.time()\\r\\n cracking_time = '%.3f'%(end-start)\\r\\n\\r\\n print (\\\" **************** Test Case \\\"+str(test_case+1)+\\\" - \\\"+str(key_size)+\\\" bits **************** \\\\n\\\")\\r\\n print (\\\"d expected: \\\"+str(d))\\r\\n print (\\\"d actual: \\\"+str(d_actual))\\r\\n print (\\\"plaintext (expected): \\\"+str(plaintext))\\r\\n print (\\\"plaintext (actual): \\\"+str(decryptRSA(d_actual,n,ciphertext)))\\r\\n print (\\\"ciphertext (expected): \\\"+str(ciphertext))\\r\\n print (\\\"ciphertext (actual): \\\"+str(encryptRSA(e,n,plaintext)))\\r\\n print (\\\"cracking took \\\"+str(cracking_time)+\\\" seconds\\\")\\r\\n\\r\\n if brute_force_time == -1:\\r\\n print (\\\"could not crack the key using brute force\\\\n\\\")\\r\\n else:\\r\\n print (\\\"brute force took \\\"+str(brute_force_time)+\\\" seconds\\\\n\\\")\",\n \"def test_handcrafted_examples(self):\\n for i in range(1000):\\n self.assertEqual(perfectd(0), True)\\n self.assertEqual(prime(0), False)\\n self.assertEqual(prime(2), True)\\n self.assertEqual(prime(7), True)\\n self.assertEqual(prime(15), False)\\n self.assertEqual(perfectd(6), True)\\n self.assertEqual(perfectd(15), False)\",\n \"def basic_experiments(k, p, num_iter, transforms, train_path, test_path):\\n start_time = time.time()\\n print(\\\"Generating advice\\\")\\n with open(train_path, \\\"r\\\") as f:\\n train_data = f.readlines()\\n advice = generate_advice(train_data, transforms)\\n print(\\\"Done: \\\" + str(time.time() - start_time) + \\\"\\\\n\\\")\\n\\n print(\\\"Generating real count for test data\\\")\\n with open(test_path, \\\"r\\\") as f:\\n test_data = f.readlines()\\n real_count = generate_advice(test_data, transforms)\\n print(\\\"Done: \\\" + str(time.time() - start_time))\\n actual = [x.moment(p) for x in real_count]\\n print(\\\"Actual moments:\\\")\\n print(actual)\\n\\n print(\\\"Estimating using noisy advice:\\\")\\n est_with_advice = []\\n for i in range(num_iter):\\n seed = str(random.randint(1, 2**64 + 1)) + str(random.randint(1, 2**64 + 1))\\n this_hash_exp = lambda x: hash_exp(x, seed)\\n est_with_advice.append(\\n estimate_using_advice(test_data, transforms, k, p, this_hash_exp,\\n advice))\\n print(\\\"Done: \\\" + str(time.time() - start_time))\\n print(est_with_advice)\\n\\n print(\\\"Estimating using perfect advice:\\\")\\n est_perfect_advice = []\\n for i in range(num_iter):\\n seed = str(random.randint(1, 2**64 + 1)) + str(random.randint(1, 2**64 + 1))\\n this_hash_exp = lambda x: hash_exp(x, seed)\\n est_perfect_advice.append(\\n estimate_using_advice(test_data, transforms, k, p, this_hash_exp,\\n real_count))\\n print(\\\"Done: \\\" + str(time.time() - start_time))\\n print(est_perfect_advice)\\n\\n print(\\\"Estimating using PPSWOR:\\\")\\n est_ppswor = []\\n for i in range(num_iter):\\n cur = []\\n for x in real_count:\\n cur.append(ppswor_estimate_moment(x.counts.items(), k, p))\\n est_ppswor.append(cur)\\n print(\\\"Done: \\\" + str(time.time() - start_time))\\n print(est_ppswor)\\n\\n print(\\\"Estimating using ell_2 PPSWOR:\\\")\\n est_ppswor_l2 = []\\n for i in range(num_iter):\\n cur = []\\n for x in real_count:\\n cur.append(ppswor_estimate_moment(x.counts.items(), k, p, 2))\\n est_ppswor_l2.append(cur)\\n print(\\\"Done: \\\" + str(time.time() - start_time))\\n print(est_ppswor_l2)\",\n \"def find():\\n b = 0\\n q = 0\\n while b == q:\\n seq = [randint(-10, 10) for _ in range(randint(15, 30))]\\n b, b_at = brute_force(seq)\\n q = solution(seq)\\n print(seq, b, q, b_at)\",\n \"def random_test(self, source):\\r\\n ret = 1\\r\\n for seed in range(1, 40):\\r\\n if source.run(temp_params={\\\"fitness_function\\\": (lambda x: -np.sum(x)**2+10),\\r\\n \\\"population_size\\\": 10,\\r\\n \\\"time_constraint\\\": 2,\\r\\n \\\"axes\\\": [(0, 5)],\\r\\n \\\"seed\\\": seed}) != \\\\\\r\\n source.run(temp_params={\\\"fitness_function\\\": (lambda x: -np.sum(x) ** 2 + 10),\\r\\n \\\"population_size\\\": 10,\\r\\n \\\"time_constraint\\\": 2,\\r\\n \\\"axes\\\": [(0, 5)],\\r\\n \\\"seed\\\": seed}):\\r\\n ret = 0\\r\\n if ret == 0:\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: Random seed non functional, results cannot be replicated.\\\")\\r\\n return 0\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(\\\"Random seed functional, results replicable if a seed is used.\\\")\\r\\n return 1\",\n \"def brute_tree(XTRAIN,istopTRAIN,XTEST,istopTEST):\\n \\n ntrain=XTRAIN.shape[0]\\n ntest=XTEST.shape[0]\\n \\n if np.sum(istopTRAIN)==0:\\n return 0,[]\\n\\n cost0=np.zeros(Ngammas*Nreps)\\n cost1=np.zeros(Ngammas*Nreps)\\n cost0test=np.zeros(Ngammas*Nreps)\\n cost1test=np.zeros(Ngammas*Nreps)\\n \\n precisionTRAIN=np.zeros(Ngammas*Nreps)\\n precisionTEST=np.zeros(Ngammas*Nreps)\\n recallTEST=np.zeros(Ngammas*Nreps)\\n rate=np.zeros(Ngammas*Nreps)\\n \\n for iii in range(Ngammas):\\n \\n gamma=GAMMA[iii]\\n \\n for jjj in range(Nreps):\\n \\n \\\"\\\"\\\" train a tree using training data with random splitting \\\"\\\"\\\"\\n \\n tree_hyperparameters['class_weight']={0:1,1:gamma}\\n clf=tree.DecisionTreeClassifier(**tree_hyperparameters)\\n clf.fit(XTRAIN,istopTRAIN)\\n \\n \\\"\\\"\\\"\\\" record costs and precision on validation data \\\"\\\"\\\"\\n \\n pTRAIN=clf.predict(XTRAIN)\\n precisionTRAIN[iii*Nreps+jjj]=np.divide(sum(1 for i in range(ntrain) if pTRAIN[i] == 1 and istopTRAIN[i]==1),sum(pTRAIN))\\n cost0[iii*Nreps+jjj]=sum(1 for i in range(ntrain) if pTRAIN[i] == 1 and istopTRAIN[i]==0)\\n cost1[iii*Nreps+jjj]=sum(1 for i in range(ntrain) if pTRAIN[i] == 0 and istopTRAIN[i]==1)\\n \\n \\\"\\\"\\\" record precision on test data \\\"\\\"\\\"\\n \\n pTEST=clf.predict(XTEST)\\n precisionTEST[iii*Nreps+jjj]=np.divide(sum(1 for i in range(ntest) if pTEST[i] == 1 and istopTEST[i]==1),sum(pTEST))\\n recallTEST[iii*Nreps+jjj]=sum(1 for i in range(ntest) if pTEST[i] == 1 and istopTEST[i]==1)/sum(istopTEST)\\n cost0test[iii*Nreps+jjj]=sum(1 for i in range(ntest) if pTEST[i] == 1 and istopTEST[i]==0)\\n cost1test[iii*Nreps+jjj]=sum(1 for i in range(ntest) if pTEST[i] == 0 and istopTEST[i]==1)\\n \\n \\\"\\\"\\\" record positive rate on full data \\\"\\\"\\\"\\n \\n rate[iii*Nreps+jjj]=(sum(pTRAIN)+sum(pTEST))/(ntrain+ntest)\\n \\n \\\"\\\"\\\" Compute Pareto front for validation data \\\"\\\"\\\"\\n \\n Pareto = Lower_Convex_Hull(np.concatenate((cost0.reshape(-1,1),cost1.reshape(-1,1)),1))\\n \\n \\\"\\\"\\\" make some nice plots for whoever is watching \\\"\\\"\\\"\\n \\n plt.figure(figsize=(10,5))\\n plt.subplot(121)\\n plt.plot(cost0,cost1,'.')\\n plt.plot(cost0[Pareto],cost1[Pareto],'d')\\n plt.xlabel('errors on class zero training data')\\n plt.ylabel('errors on class one training data')\\n\\n plt.subplot(122)\\n plt.plot(cost0test,cost1test,'.')\\n plt.plot(cost0test[Pareto],cost1test[Pareto],'d')\\n plt.xlabel('errors on class zero test data')\\n plt.ylabel('errors on class one test data')\\n plt.show()\\n \\n plt.figure(figsize=(15,5))\\n plt.subplot(131)\\n plt.semilogy(precisionTRAIN,rate,'.')\\n plt.semilogy(precisionTRAIN[Pareto],rate[Pareto],'d')\\n plt.xlabel('precision on training data')\\n plt.ylabel('positive rate')\\n\\n plt.subplot(132) \\n plt.semilogy(precisionTEST,rate,'.')\\n plt.semilogy(precisionTEST[Pareto],rate[Pareto],'d')\\n plt.xlabel('precision on test data')\\n plt.ylabel('positive rate')\\n\\n plt.subplot(133) \\n plt.plot(precisionTEST,recallTEST,'.')\\n plt.plot(precisionTEST[Pareto],recallTEST[Pareto],'d')\\n plt.xlabel('precision on test data')\\n plt.ylabel('recall on test data')\\n plt.show() \\n \\n return {'cost0':cost0,'cost1':cost1,'cost0test':cost0test,'cost1test':cost1test,'precisionTRAIN':precisionTRAIN,'precisionTEST':precisionTEST,'recallTEST':recallTEST,'rate':rate,'Pareto':Pareto}\",\n \"def test_rand_func2(self):\\n for i in range(0, 100000):\\n num = random.randint(0, 32535143990)\\n func2_comp(num)\",\n \"def run_and_evaluate():\\n tsp_problems = read_all_problems()\\n # Empty list of metrics\\n results = []\\n for problem in tqdm.tqdm(tsp_problems):\\n # As random factors are involved repeat experiments a couple of times\\n best_routes_base = []\\n best_routes_af = []\\n best_routes_ms = []\\n base_times = []\\n af_times = []\\n ms_times = []\\n for i in range(10):\\n # Base solution\\n start_time = timeit.default_timer()\\n best_route_base = solve_tsp_basic(problem)\\n base_time = timeit.default_timer() - start_time\\n best_routes_base.append(Fitness(route=best_route_base).route_distance())\\n base_times.append(base_time)\\n\\n # AF clustering solution\\n start_time = timeit.default_timer()\\n best_route_af = solve_tsp_affinity_propagation(problem)\\n af_time = timeit.default_timer() - start_time\\n best_routes_af.append(Fitness(route=best_route_af).route_distance())\\n af_times.append(af_time)\\n\\n # MS solution\\n start_time = timeit.default_timer()\\n best_route_ms = solve_mean_shift(problem)\\n ms_time = timeit.default_timer() - start_time\\n best_routes_ms.append(Fitness(route=best_route_ms).route_distance())\\n ms_times.append(ms_time)\\n\\n results.append(\\n {\\n \\\"problem name\\\": problem.name,\\n \\\"optimal solution\\\": find_route_optimal_route_length(problem),\\n \\\"baseline tour length\\\": mean(best_routes_base),\\n \\\"af clustering tour length\\\": mean(best_routes_af),\\n \\\"ms clustering tour length\\\": mean(best_routes_ms),\\n \\\"baseline algorithm time\\\": mean(base_times),\\n \\\"af clustering algorithm time\\\": mean(af_times),\\n \\\"ms clustering algorithm time\\\": mean(ms_times),\\n }\\n )\\n # Create dataframe and safe results\\n df = pd.DataFrame(results)\\n df.to_csv(\\\"results.csv\\\", index=False)\\n return df\",\n \"def challenge2(self):\\n # Create emulator, with 6 registers. Set register 0 to 1\\n emulator = Emulator(6)\\n emulator.registers[0] = 1\\n\\n # Running this program seems to take forever... let's see if there's a pattern.\\n # OK, so after dumping out lots of instructions, this pattern is repeated a lot:\\n # [ 3] mulr 1 5 3\\n # [ 4] eqrr 3 2 3\\n # [ 5] addr 3 4 4\\n # [ 6] addi 4 1 4\\n # [ 8] addi 5 1 5\\n # [ 9] gtrr 5 2 3\\n # [10] addr 4 3 4\\n # [11] seti 2 2 4\\n # In this program, register 4 is the IP register. (IP is shown in [] above)\\n # So instruction 6 is just jumping to instruction 8, we can optimize that out\\n # And seti 2 2 4 will act as a jump back to instruction 3 (= 2 + 1)\\n # Registers look like this after instruction 3:\\n # IP: 4 Reg: [0, 1, 10551376, 145834, 3, 145834]\\n # So effectively we have, per loop iteration:\\n # reg[3] = reg[1] * reg[5]\\n # reg[3] = 1 if reg[3] == reg[2] else 0\\n # reg[4] = reg[3] + reg[4] => If the above was false, we go to instruction 6.\\n # Otherwise we go to instruction 7 (outside the normal loop flow) and do:\\n # addr 1 0 0 => reg[0] = reg[0] + reg[1], then proceed as below.\\n # If we stay in the loop, or just fallen through now, we are at instruction 8:\\n # reg[5] = reg[5] + reg[1]\\n # reg[3] = 1 if reg[5] > reg[2] else 0\\n # reg[4] = reg[3] + reg[4] => If the above was false, we go to instruction 11 => back to the start.\\n # Otherwise, we jump outside the loop to instruction 12.\\n # So to write the above in Python code, with registers named R0 etc:\\n # while R5 <= R2:\\n # R3 = R1 * R5\\n # if R3 == R2:\\n # R0 += R1\\n # R5 += R1\\n #\\n # This appears to be a brute force way of checking if R1 is a factor of R2 - and if it is, adding it to R0\\n # After this loop, if we go to instruction 12:\\n # addi 1 1 1 => R1 += 1\\n # gtrr 1 2 3 => R3 = 1 if R1 > R2 else 0\\n # addr 3 4 4\\n # seti 1 4 4\\n # mulr 4 4 4\\n # These last three mean \\\"jump to instruction 2 if R1 <= R2 else terminate (by squaring the IP)\\\"\\n # So putting this together, along with instructions 2 and 3 of:\\n # seti 1 8 1 => R1 = 1\\n # seti 1 3 5 => R5 = 1\\n # We are brute-force finding all the factors of R2 and adding all of them together into R0\\n # As R2 contains 10551376, we can do this in a cleverer, non brute force way to find the final value of R0!\\n number_to_factorize = 10551376\\n \\n def factors(n): \\n return set(reduce(list.__add__, \\n ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))\\n\\n sum_factors = sum(factors(number_to_factorize))\\n print(f\\\"Final value of register 0: {sum_factors}\\\")\",\n \"def test_compare(self):\\n config = {\\n 'num_components': 512,\\n 'num_features': 128,\\n 'covariance': 'spherical'\\n }\\n\\n samples = self.generate_samples(config, 100_000)\\n sklearn_time = np.mean([self.train_sklearn(config, samples) for _ in range(3)])\\n ours_cpu_time = np.mean([self.train_ours(config, samples) for _ in range(3)])\\n ours_gpu_time = np.mean([\\n self.train_ours(config, samples.cuda(), gpu=True) for _ in range(3)\\n ])\\n\\n print(f\\\"-------------------------------------\\\")\\n print(f\\\"Speedup of CPU implementation: {sklearn_time / ours_cpu_time:.2f}\\\")\\n print(f\\\"Speedup of GPU implementation: {sklearn_time / ours_gpu_time:.2f}\\\")\\n print(f\\\"-------------------------------------\\\")\",\n \"def test_strategy_evaluate(self, MetricClass, seed):\\n m = MetricClass()\\n strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))\\n result0 = np.array(m.result(strategy)) # from metric method\\n result1 = np.array(strategy.evaluate(m)) # from strategy method\\n assert np.equal(result0, result1).all()\",\n \"def run_tests(test_count=1000, buyer_count=10):\\n\\n found_error = False\\n\\n for i in range(test_count):\\n\\n bp, sp, bw = get_preferences(buyer_count)\\n matches = get_matches(bp, sp, bw)\\n\\n if not check_stability(bp, sp, matches):\\n print('ERROR!!!')\\n found_error = True\\n\\n if not found_error:\\n print('Executed {} tests without errors'.format(test_count))\",\n \"def test_custom_works_fine(self):\\n\\n ba_custom = BatAlgorithm(NP=20, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, seed=self.seed)\\n ba_customc = BatAlgorithm(NP=20, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, seed=self.seed)\\n AlgorithmTestCase.algorithm_run_test(self, ba_custom, ba_customc, MyBenchmark())\",\n \"def test_run_jackknifed_beta_diversity_parallel(self):\\r\\n\\r\\n run_jackknifed_beta_diversity(\\r\\n self.test_data['biom'][0],\\r\\n self.test_data['tree'][0],\\r\\n 20,\\r\\n self.test_out,\\r\\n call_commands_serially,\\r\\n self.params,\\r\\n self.qiime_config,\\r\\n self.test_data['map'][0],\\r\\n parallel=True,\\r\\n status_update_callback=no_status_updates)\\r\\n\\r\\n weighted_unifrac_upgma_tree_fp = join(self.test_out,\\r\\n 'weighted_unifrac',\\r\\n 'upgma_cmp', 'jackknife_named_nodes.tre')\\r\\n unweighted_unifrac_upgma_tree_fp = join(\\r\\n self.test_out, 'unweighted_unifrac', 'upgma_cmp',\\r\\n 'jackknife_named_nodes.tre')\\r\\n weighted_unifrac_emperor_index_fp = join(\\r\\n self.test_out, 'weighted_unifrac', 'emperor_pcoa_plots',\\r\\n 'index.html')\\r\\n unweighted_unifrac_emperor_index_fp = join(\\r\\n self.test_out, 'unweighted_unifrac', 'emperor_pcoa_plots',\\r\\n 'index.html')\\r\\n\\r\\n input_file_basename = splitext(split(self.test_data['biom'][0])[1])[0]\\r\\n unweighted_unifrac_dm_fp = join(self.test_out,\\r\\n 'unweighted_unifrac_%s.txt' % input_file_basename)\\r\\n weighted_unifrac_dm_fp = join(self.test_out,\\r\\n 'weighted_unifrac_%s.txt' % input_file_basename)\\r\\n\\r\\n # check for expected relations between values in the unweighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n # check for expected relations between values in the weighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n\\r\\n # check that final output files have non-zero size\\r\\n self.assertTrue(getsize(weighted_unifrac_upgma_tree_fp) > 0)\\r\\n self.assertTrue(getsize(unweighted_unifrac_upgma_tree_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_emperor_index_fp) > 0)\\r\\n self.assertTrue(getsize(unweighted_unifrac_emperor_index_fp) > 0)\\r\\n\\r\\n # Check that the log file is created and has size > 0\\r\\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\\r\\n self.assertTrue(getsize(log_fp) > 0)\",\n \"def test_v2_runtime(self):\\r\\n\\r\\n start_time = time.time()\\r\\n\\r\\n for n in range(1, 30000):\\r\\n prime_numbers_v2(n)\\r\\n\\r\\n elapsed_time = round(time.time() - start_time, 3)\\r\\n\\r\\n print(f\\\"v2, time required: {elapsed_time}\\\")\",\n \"def brute_force_search_solution():\\n return len(coin_search(TOTAL, COINS))\",\n \"def test_huge_answers(self):\\n self.init_player(\\n '0', 'Welcome to Oppia!', 'do you know where the name \\\\'Oppia\\\\'')\\n self.submit_and_compare(\\n '0', '', 'In fact, the word Oppia means \\\\'learn\\\\'.')\\n # This could potentially cause errors in stats_models when the answer\\n # is persisted to the backend.\\n self.submit_and_compare(\\n 'a' * 1000500, 'Sorry, nope, we didn\\\\'t get it', '')\",\n \"def performBMItests():\\r\\n feet = 5\\r\\n inches = 60\\r\\n\\r\\n expectedBMIa = 18.4\\r\\n poundsA = 92\\r\\n expectedBMIb = 18.5\\r\\n poundsB = 92.5\\r\\n expectedBMIc = 24.9\\r\\n poundsC = 124.5\\r\\n expectedBMId = 25.0\\r\\n poundsD = 125.0\\r\\n expectedBMIe = 29.9\\r\\n poundsE = 149.5\\r\\n expectedBMIf = 30.0\\r\\n poundsF = 150.0\\r\\n\\r\\n expectedResulta = \\\"Underweight\\\"\\r\\n expectedResultb = \\\"Normal\\\"\\r\\n expectedResultc = \\\"Normal\\\"\\r\\n expectedResultd = \\\"Overweight\\\"\\r\\n expectedResulte = \\\"Overweight\\\"\\r\\n expectedResultf = \\\"Obese\\\"\\r\\n\\r\\n BMIa, resultA = calculateBMI(feet, inches, poundsA)\\r\\n BMIb, resultB = calculateBMI(feet, inches, poundsB)\\r\\n BMIc, resultC = calculateBMI(feet, inches, poundsC)\\r\\n BMId, resultD = calculateBMI(feet, inches, poundsD)\\r\\n BMIe, resultE = calculateBMI(feet, inches, poundsE)\\r\\n BMIf, resultF = calculateBMI(feet, inches, poundsF)\\r\\n\\r\\n print(\\\"\\\")\\r\\n print(\\\"\\\")\\r\\n bmi_test(expectedBMIa, BMIa, expectedResulta, resultA)\\r\\n bmi_test(expectedBMIb, BMIb, expectedResultb, resultB)\\r\\n bmi_test(expectedBMIc, BMIc, expectedResultc, resultC)\\r\\n bmi_test(expectedBMId, BMId, expectedResultd, resultD)\\r\\n bmi_test(expectedBMIe, BMIe, expectedResulte, resultE)\\r\\n bmi_test(expectedBMIf, BMIf, expectedResultf, resultF)\\r\\n print(\\\"\\\")\\r\\n print(\\\"\\\")\",\n \"def test_v1_runtime(self):\\r\\n\\r\\n start_time = time.time()\\r\\n\\r\\n for n in range(1, 30000):\\r\\n prime_numbers_v1(n)\\r\\n\\r\\n elapsed_time = round(time.time() - start_time, 3)\\r\\n\\r\\n print(f\\\"v1, time required: {elapsed_time}\\\")\",\n \"def run_experiment():\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def run_experiment():\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def run_experiment():\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def run_experiment():\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def test_calculate_class_2_individuals_best_response_simulation_all_inds_in_one():\\n all_individuals_to_first = calculate_class_2_individuals_best_response(\\n lambda_2=0.3,\\n lambda_1_1=0.1,\\n lambda_1_2=3,\\n mu_1=10,\\n mu_2=2,\\n num_of_servers_1=8,\\n num_of_servers_2=4,\\n threshold_1=6,\\n threshold_2=3,\\n system_capacity_1=float(\\\"inf\\\"),\\n system_capacity_2=float(\\\"inf\\\"),\\n buffer_capacity_1=float(\\\"inf\\\"),\\n buffer_capacity_2=float(\\\"inf\\\"),\\n use_simulation=True,\\n runtime=500,\\n num_of_trials=5,\\n warm_up_time=100,\\n seed_num_1=10,\\n seed_num_2=10,\\n )\\n assert all_individuals_to_first == 1\\n\\n all_individuals_to_second = calculate_class_2_individuals_best_response(\\n lambda_2=0.3,\\n lambda_1_1=3,\\n lambda_1_2=0.1,\\n mu_1=2,\\n mu_2=10,\\n num_of_servers_1=4,\\n num_of_servers_2=8,\\n threshold_1=3,\\n threshold_2=6,\\n system_capacity_1=float(\\\"inf\\\"),\\n system_capacity_2=float(\\\"inf\\\"),\\n buffer_capacity_1=float(\\\"inf\\\"),\\n buffer_capacity_2=float(\\\"inf\\\"),\\n use_simulation=True,\\n runtime=500,\\n num_of_trials=5,\\n warm_up_time=100,\\n seed_num_1=10,\\n seed_num_2=10,\\n )\\n assert all_individuals_to_second == 0\",\n \"def speed_test(self):\\n self.lg.debug('Performing speed test no. {}'.format(self.runs))\\n self.st.get_best_server()\\n self.st.upload()\\n self.st.download()\\n up = self.st.results.upload // 1e6\\n down = self.st.results.download // 1e6\\n timestamp = time.localtime(time.time())\\n self.lg.debug('Timestamp: {}'.format(\\n time.strftime('%H:%M:%S', timestamp)))\\n self.lg.debug(\\n 'Upload is {} Mbps'.format(up))\\n self.lg.debug(\\n 'Download is {} Mbps'.format(down))\\n self.results_up.append(up)\\n self.results_down.append(down)\\n self.results_timestamp.append(timestamp)\",\n \"def main():\\n\\n tests = [500, 1000, 10000]\\n results = {\\n 'Insertion Sort': 0.0,\\n 'Shell Sort': 0.0,\\n 'Python Sort': 0.0\\n }\\n\\n for test in tests:\\n i = 0\\n\\n while i < 100:\\n test_list = gen_random_list(test)\\n results['Insertion Sort'] += insertion_sort(test_list)[0]\\n results['Shell Sort'] += shell_sort(test_list)[0]\\n results['Python Sort'] += python_sort(test_list)[0]\\n i += 1\\n\\n print(\\\"Sort results for list of size %s items:\\\" % test)\\n for key, value in results.items():\\n print(\\\"%s took %10.7f seconds to run, on average.\\\" % (key, (value/100)))\\n print(\\\"\\\\n\\\")\",\n \"def run(method, n):\\n \\n m1,m2 = generate(n)\\n \\n start = time.time()\\n method(m1,m2)\\n end = time.time()\\n \\n exe = end - start\\n \\n return exe\",\n \"def test_custom_works_fine(self):\\n\\t\\thsaba_custom = self.algo(NP=10, Limit=2, seed=self.seed)\\n\\t\\thsaba_customc = self.algo(NP=10, Limit=2, seed=self.seed)\\n\\t\\tAlgorithmTestCase.test_algorithm_run(self, hsaba_custom, hsaba_customc, MyBenchmark())\",\n \"def simulation(self, n = 42):\\n\\n self.initialisation()\\n i = 0\\n while i < n and self.agent.vivant :\\n self.step()\\n i+= 1\\n return self.perfGlobale\",\n \"async def test_random_caching(players, strats, _):\\n game = gamegen.samplegame(players, strats)\\n rest1, rest2 = game.random_restrictions(2)\\n sched = gamesched.samplegamesched(game)\\n sgame = schedgame.schedgame(sched)\\n assert str(sgame) == str(sched)\\n\\n rgame11 = await sgame.get_restricted_game(rest1)\\n rgame21 = await sgame.get_restricted_game(rest2)\\n devs11 = await sgame.get_deviation_game(rest1)\\n devs21 = await sgame.get_deviation_game(rest2)\\n\\n rgame12 = await sgame.get_restricted_game(rest1)\\n rgame22 = await sgame.get_restricted_game(rest2)\\n assert rgame11 == rgame12\\n assert rgame21 == rgame22\\n\\n devs12 = await sgame.get_deviation_game(rest1)\\n devs22 = await sgame.get_deviation_game(rest2)\\n assert devs11 == devs12\\n assert devs21 == devs22\",\n \"def bruteforce(vierhidden, totalecombinatie):\\r\\n for x in range(0, 1296):\\r\\n code = totalecombinatie[x]\\r\\n if validatecombination(vierhidden, code)[0] == 4:\\r\\n return 'Gevonden na ' + str(x + 1) + ' zetten.'\",\n \"def compare_cow_transport_algorithms():\\r\\n cows_test = load_cows(\\\"ps1_cow_data.txt\\\")\\r\\n time0 = time.time()\\r\\n greedy = greedy_cow_transport(cows_test)\\r\\n time1 = time.time()\\r\\n brute = brute_force_cow_transport(cows_test)\\r\\n time2 = time.time()\\r\\n print (\\\"# of Trips by Greedy Algorithm:\\\", len(greedy))\\r\\n print (\\\"# of Trips by Brute Force Algo:\\\", len(brute))\\r\\n \\r\\n print (\\\"Greedy Algo took time:\\\", time1-time0)\\r\\n print (\\\"Brute Force Algo took time:\\\", time2-time1)\\r\\n pass\",\n \"def test_check_cost():\",\n \"def brute_force_solution():\\n def is_pythagorean_triplet(a, b, c):\\n return c**2 == a**2 + b**2\\n\\n return next(\\n a * b * (TRIPLET_SUM - a - b)\\n for a in range(1, TRIPLET_SUM)\\n for b in range(a + 1, TRIPLET_SUM - a)\\n if is_pythagorean_triplet(a, b, TRIPLET_SUM - a - b)\\n )\",\n \"def test(numTrials):\\n # Your Code Here\\n hits = 0.0\\n for i in range(numTrials):\\n result = trial()\\n #print result\\n hits += result\\n return hits / numTrials\",\n \"def test_statistic(self):\\n for seed in range(5):\\n\\n random_state = np.random.RandomState(seed)\\n\\n for i in range(4, self.test_max_size + 1):\\n arr1 = random_state.rand(i, 1)\\n arr2 = random_state.rand(i, 1)\\n\\n stat = dcor_internals._distance_correlation_sqr_naive(\\n arr1, arr2)\\n stat_fast = dcor_internals._distance_correlation_sqr_fast(\\n arr1, arr2)\\n\\n self.assertAlmostEqual(stat, stat_fast)\",\n \"def run_grid_search():\\n\\n best_score = 0\\n best_learning_rate = 0\\n best_discount_rate = 0\\n best_initial_q_hat = 0\\n trial_results = []\\n number_of_trials = 30\\n # TODO These ought to be done with numpy.arange but I don't have that package installed at the moment\\n for learning_rate_raw in range(5, 50, 5):\\n for discount_rate_raw in range(5, 20, 5):\\n for initial_q_hat in range(0, 10, 1):\\n learning_rate = learning_rate_raw * 0.01\\n discount_rate = discount_rate_raw * 0.05\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent, learning_rate, discount_rate, initial_q_hat) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0, display=False) # create simulator (uses pygame when display=True, if available)\\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\\n\\n sim.run(n_trials=number_of_trials) # run for a specified number of trials\\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\\n score = a.get_score()\\n if score > best_score:\\n best_score = score\\n best_learning_rate = learning_rate\\n best_discount_rate = discount_rate\\n best_initial_q_hat = initial_q_hat\\n trial_results.append((learning_rate, discount_rate, initial_q_hat, score, a.get_proportion_of_states_visited(), len(a.get_failed_trials())/ float(number_of_trials)))\\n print \\\"Gridsearch finished, best learning rate: %.2f, best discount rate: %.2f, best initial q hat %i\\\" % (best_learning_rate, best_discount_rate, best_initial_q_hat)\\n\\n with open('gridsearch_results.csv', 'wb') as csvfile:\\n spamwriter = csv.writer(csvfile, delimiter=';', quotechar='|', quoting=csv.QUOTE_MINIMAL)\\n spamwriter.writerow(('learning rate', 'discount factor', 'initial q-hat value', 'score', 'states visited', 'failed trials'))\\n for result in trial_results:\\n spamwriter.writerow(result)\",\n \"def faster_brute_force_solution():\\n def calc_b(a, sum):\\n return ((sum**2/2) - (sum * a)) / (sum - a)\\n\\n a, b = next(\\n (a, calc_b(a, TRIPLET_SUM))\\n for a in range(1, TRIPLET_SUM)\\n if calc_b(a, TRIPLET_SUM).is_integer()\\n )\\n\\n return a * b * (TRIPLET_SUM - a - b)\",\n \"def performance_test(n):\\n \\n def analyze_result(test_results, start_index, end_index, range_):\\n \\\"\\\"\\\"Helper method - analyzes test results of one range (short, mid, or long).\\n \\n Args:\\n test_results: list of test results containing tuples of (euclidean_distance, time_dijkstra, time_idastar)\\n start_index: start index of this range in test results list\\n end_index: end index of this range in test results list\\n range_: Short, Mid, or Long range\\n \\n Returns:\\n String describing analysis of test results in this range\\n \\\"\\\"\\\"\\n time_dij = 0\\n time_ida = 0\\n ida_not_finished = 0\\n for i in range(start_index, end_index):\\n result = test_results[i]\\n time_dij += result[1]\\n if result[2] == \\\"no_time\\\":\\n ida_not_finished += 1\\n else: # ida finished\\n time_ida += result[2]\\n result_dij = \\\"Algorithm: Dijkstra - Average time: \\\" + str(round(time_dij/(end_index-start_index)*1000, 3)) + \\\" ms\\\\n\\\"\\n result_ida = \\\"Algorithm: IDA* - Average time: \\\" + str(round(time_ida/(end_index-start_index-ida_not_finished)*1000, 3)) + \\\" ms [\\\" + str(ida_not_finished) + \\\" attempts not finished]\\\\n\\\"\\n header = range_ + \\\"-range results [\\\" + str(end_index-start_index) + \\\" tests]:\\\\n\\\"\\n return header + result_dij + result_ida\\n \\n \\n print(\\\"\\\\nCalculating...\\\\n\\\")\\n \\n test_results = []\\n \\n for _ in range(n):\\n # random start and end cities\\n start = cities[randint(0, len(cities)-1)]\\n end = cities[randint(0, len(cities)-1)]\\n while start == end:\\n end = cities[randint(0, len(cities)-1)]\\n # calculate euclidean distance\\n x_diff = coordinates[start][0] - coordinates[end][0]\\n y_diff = coordinates[start][1] - coordinates[end][1]\\n eucl_dist = sqrt(x_diff**2 + y_diff**2)\\n \\n # Dijkstra\\n dist_dij, path_dij, time_dij = dijkstra(start, end, adjlist)\\n # IDA*\\n dist_ida, path_ida, time_ida = idastar(start, end, adjlist, coordinates)\\n \\n test_results.append( (eucl_dist, time_dij, time_ida) )\\n \\n # Analysis of results\\n test_results.sort()\\n short_index = 0\\n mid_index = n//3\\n long_index = n//3*2\\n \\n # Short-range\\n print(analyze_result(test_results, short_index, mid_index, \\\"Short\\\"))\\n # Mid-range\\n print(analyze_result(test_results, mid_index, long_index, \\\"Mid\\\"))\\n # Long-range\\n print(analyze_result(test_results, long_index, len(test_results), \\\"Long\\\"))\",\n \"def test_random_smoke(fastonly):\\n word_length = 5\\n while word_length < 65:\\n run_random_test(word_length, 3, 1000 if fastonly else 100000, word_length)\\n word_length += 1\",\n \"def simulatie(n=20, m=10):\\n\\twith Stopwatch(message=\\\"v0: Python\\\"):\\n\\t\\tcoordinatenLaagsteE = 0\\n\\t\\tnummerRunLaagsteE = 0\\n\\t\\tLaagsteE = math.inf\\n\\t\\ttotalePot = 0\\n\\t\\tgemiddelde = 0\\n\\t\\tpotentialenlijst = list()\\n\\t\\tfor i in range(m):\\n\\t\\t\\t#print(\\\"Bezig met het simuleren van run\\\", i+1, \\\"van\\\", m)\\n\\t\\t\\trun = atomen.Atomen(n)\\n\\t\\t\\tpot = run.berekenLJPot()\\n\\t\\t\\ttotalePot = totalePot + pot\\n\\t\\t\\tgemiddelde = totalePot / (i + 1)\\n\\t\\t\\tpotentialenlijst.append(pot)\\n\\t\\t\\tif pot < LaagsteE:\\n\\t\\t\\t\\tcoordinatenLaagsteE = run.getCoordinaten()\\n\\t\\t\\t\\tnummerRunLaagsteE = i\\n\\t\\t\\t\\tLaagsteE = pot\\n\\tprint(\\\" \\\")\\n\\tprint(\\\"----------RESULTATEN----------\\\")\\n\\tprint(\\\"Run\\\", nummerRunLaagsteE + 1,\\\"van\\\", m, \\\"had de laagste totale Lennard Jones Potentiaal, namelijk:\\\", LaagsteE)\\n\\t#print(\\\"De Coordinaten van de atomen van deze run zijn:\\\", coordinatenLaagsteE)\\n\\tprint(\\\"De gemiddelde potentiaal:\\\", gemiddelde)\\n\\tprint(\\\"De standaardafwijking is:\\\", stdev(potentialenlijst))\\n\\t\\n\\t\\\"\\\"\\\"montecarlo_v1.simulatie(n, m)\\n\\tmontecarlo_v2.simulatie(n, m)\\n\\tmontecarlo_v3.simulatie(n, m)\\\"\\\"\\\"\",\n \"def countbrute(m):\\n nfound=0\\n\\n for i in range(1,m+1):\\n for j in range(1,i+1):\\n for k in range(1,j+1):\\n d1=i*i+(j+k)*(j+k) \\n if(checkpsq(d1)):\\n nfound=nfound+1\\n\\n return nfound\",\n \"def q2test():\\n \\n correct = True\\n time0 = time.time()\\n result = count_ephemeral(1, 10, 2)\\n time1 = time.time()\\n if result != 2:\\n correct = False\\n print(\\\"test failed for n1=1, n2=10, k=2; correct result is 2, result obtained was\\\", result)\\n else:\\n print(\\\"test passed for for n1=1, n2=10, k=2 in\\\", time1 - time0, \\\"seconds.\\\")\\n\\n time0 = time.time()\\n result = count_ephemeral(1000, 10000, 3)\\n time1 = time.time()\\n if result != 91:\\n correct = False\\n print(\\\"test failed for n1=1000, n2=10000, k=3; correct result is 91, result obtained was\\\", result)\\n else:\\n print(\\\"test passed for for n1=1000, n2=10000, k=3 in\\\", time1 - time0, \\\"seconds.\\\")\\n\\n time0 = time.time()\\n result = count_ephemeral(123456, 654321, 4)\\n time1 = time.time()\\n if result != 376:\\n correct = False\\n print(\\\"test failed for n1=123456, n2=654321, k=4; correct result is 376, result obtained was\\\", result)\\n else:\\n print(\\\"test passed for for n1=123456, n2=654321, k=4 in\\\", time1 - time0, \\\"seconds.\\\")\\n if correct:\\n print(\\\"all tests passed\\\")\\n \\n time0 = time.time()\\n result = count_ephemeral(1, 10000000, 2)\\n time1 = time.time()\\n print(result, time1 - time0)\\n \\n time0 = time.time()\\n result = count_ephemeral(1, 10000000, 3)\\n time1 = time.time()\\n print(result, time1 - time0)\\n \\n time0 = time.time()\\n result = count_ephemeral(1, 10000000, 4)\\n time1 = time.time()\\n print(result, time1 - time0)\",\n \"def brute_force(savedPnts, unitRadius, point):\\n for pnt in savedPnts:\\n d = distance(pnt, point)\\n if d < unitRadius: return False\\n return True\",\n \"def compare_cow_transport_algorithms():\\n cow_set = load_cows(\\\"ps1_cow_data.txt\\\")\\n \\n def get_run_time(func):\\n start = time.time()\\n print(func(cow_set))\\n end = time.time()\\n return end-start\\n \\n greedy_time = get_run_time(greedy_cow_transport)\\n brute_force_time = get_run_time(brute_force_cow_transport)\\n \\n print(\\\"---\\\"*20)\\n print(\\\"greedy runtime: \\\",greedy_time)\\n print(\\\"brute force runtime: \\\", brute_force_time)\",\n \"def test_machine_learning():\",\n \"def mc_simul_all_hands():\\r\\n\\tglobal hands, H, G, B, P, rnd, equity_arr, equity_all, equity_win, equity_tie, df, equity_mc_cvg\\r\\n\\r\\n\\thands = np.array(map(hand_str_to_no, all_preflop_hands), dtype=np.int32)\\r\\n\\tH = hands.shape[0]\\r\\n\\tG = int(2e5)\\t\\t\\t# 1e6\\t\\t2e5\\r\\n\\tB = int(500)\\t\\t\\t# 300\\t\\t500\\r\\n\\tnb_opp = 9\\r\\n\\tequity_arr = np.zeros([B, H, nb_opp, 2], dtype=np.float32)\\r\\n\\r\\n\\tprint '\\\\n---------------- Monte Carlo simulation start'\\r\\n\\tprint 'nb of hands = {}'.format(H)\\r\\n\\tprint 'nb of random games per block = {}'.format(G)\\r\\n\\tprint 'nb of blocks = {}\\\\n'.format(B)\\r\\n\\r\\n\\r\\n\\tt_init = timer()\\r\\n\\tfor b in xrange(B):\\r\\n\\t\\tprint 'block #{}'.format(b)\\r\\n\\t\\tt0 = timer()\\r\\n\\r\\n\\t\\t# random games generation\\r\\n\\t\\tC = 50-2\\r\\n\\t\\tP = 2*nb_opp+5\\r\\n\\t\\tN = int(2*P*G)\\r\\n\\t\\tseed = 0\\t# None\\r\\n\\t\\trnd = rnd_games(G, P, C, N, seed)\\r\\n\\t\\t# rnd = rnd_games_slow(G, P, C)\\r\\n\\r\\n\\t\\tt1 = timer()\\r\\n\\t\\tprint '\\\\tRNG time = \\\\t{:.6f} s'.format(t1-t0)\\r\\n\\r\\n\\t\\t# hand ranking\\r\\n\\t\\tequity_arr[b, :, :, :] = mc_block_all_fast(hands, nb_opp, rnd, keys.CARD_FLUSH_KEY,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tkeys.CARD_FACE_KEY,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tkeys.CARD_SUIT,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tkeys.SUIT_MASK,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tkeys.SUIT_BIT_SHIFT,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tEvalSeven.flush_rank,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tEvalSeven.face_rank,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tEvalSeven.flush_suit)\\r\\n\\r\\n\\t\\tt2 = timer()\\r\\n\\t\\tprint '\\\\tequity time = \\\\t{:.6f} s'.format(t2-t1)\\r\\n\\t\\tprint '\\\\tblock time = \\\\t{:.6f} s'.format(t2-t0)\\r\\n\\r\\n\\tprint '\\\\n---------------- Monte Carlo simulation end'\\r\\n\\tprint 'full run time = {:.6f} s'.format(t2-t_init)\\r\\n\\tpickle(os.path.join('Tables', 'equity_array.pk'), equity_arr)\\r\\n\\r\\n\\r\\n\\tequity_all = np.mean(equity_arr, axis=0)\\r\\n\\tequity_win = equity_all[:, :, 0]\\r\\n\\tequity_tie = equity_all[:, :, 1]\\r\\n\\tdf = pd.DataFrame(data=np.concatenate((equity_win, equity_tie), axis=1),\\r\\n\\t\\t\\t\\t\\t\\tindex=all_preflop_hands,\\r\\n\\t\\t\\t\\t\\t\\tcolumns=[str(i)+'_win' for i in range(1, nb_opp+1)]+[str(i)+'_tie' for i in range(1, nb_opp+1)])\\r\\n\\tdf.to_pickle(os.path.join('Tables', 'df_equity_montecarlo.pd'))\\r\\n\\tdf.to_csv(os.path.join('Tables', 'df_equity_montecarlo.csv'))\\r\\n\\r\\n\\tequity_mc_cvg = np.zeros_like(equity_arr)\\r\\n\\tfor k in xrange(B):\\r\\n\\t\\tequity_mc_cvg[k, :, :, :] = np.mean(equity_arr[:k+1, :, :, :], axis=0)\\r\\n\\tpickle(os.path.join('Tables', 'equity_mc_cvg.pk'), equity_mc_cvg)\\r\\n\\r\\n\\t# df_equity_montecarlo = pd.read_pickle(os.path.join('Tables', 'df_equity_montecarlo.pd'))\\r\\n\\t# equity_arr_1 = unpickle(os.path.join('Tables', 'test.pk'))\\r\\n\\t# equity_mc_cvg_1 = unpickle(os.path.join('Tables', 'equity_mc_cvg.pk'))\\r\",\n \"def test_brute_force_ttt(self):\\n def simulate(moves, human_first): \\n T = TicTacToe()\\n for move in moves:\\n self.ri.return_value = str(move)\\n moves = [T.human_move, T.computer_move]\\n for i in range(2):\\n moves[(i + human_first) % 2]()\\n winner = T.tic_tac_toe(T.board)\\n if winner:\\n return winner == T.computer or winner == 'cat'\\n return True\\n sys.stdout, tmp = open(os.devnull, 'w'), sys.stdout\\n assert True == all(simulate(moves, True) for moves in combinations_with_replacement(range(9), 5))\\n assert True == all(simulate(moves, False) for moves in combinations_with_replacement(range(9), 5))\\n sys.stdout = tmp\",\n \"def _run():\\n matching_terms = {'a', 'b'}\\n source_counts = {'a': 10, 'b': 50, 'c': 25}\\n target_counts = {'a': 4, 'b': 73, 'c': 15}\\n source_chunk = ['a', 'b']\\n target_chunk = ['a', 'c', 'b']\\n source_distance = score.find_distance(\\n matching_terms, source_chunk, source_counts)\\n target_distance = score.find_distance(\\n matching_terms, target_chunk, target_counts)\\n match_score = score.vanilla(\\n matching_terms, source_distance, target_distance, source_counts,\\n target_counts)\\n print('Calculated score:', match_score)\",\n \"def run_random(self):\\n manager = Manager()\\n self.all_probabilities = manager.list()\\n self.total_iterations = manager.Value('d', 0)\\n num_counterexamples = manager.Value('d', 0)\\n counter_lock = manager.Lock()\\n all_probabilities_lock = manager.Lock()\\n\\n file_q = manager.Queue()\\n\\n self.mug_pipeline.set_folder_names(self.folder_name)\\n self.mug_pipeline.set_optimizer_type(OptimizerType.RANDOM)\\n pool = Pool(self.num_processes + 1, maxtasksperchild=60)\\n\\n filename = '{}/logs/results_{}.csv'.format(self.folder_name, self.trial_folder)\\n watcher = Process(target=self.listener, args=(file_q, filename))\\n watcher.start()\\n\\n iter_num = 0\\n start_time = time.time()\\n max_time_per_map = 60*60\\n\\n try:\\n # TODO: change this from while true to terminate by timeout (try/except)\\n while ((self.retrain_with_random and self.total_iterations.value < self.max_added_to_training) or\\n (self.retrain_with_counterexamples and num_counterexamples.value < self.max_added_to_training)):\\n result = None\\n\\n while result is None:\\n try:\\n result = func_timeout(max_time_per_map, pool.starmap,\\n args=(self.mug_pipeline.run_inference,\\n zip(self.generate_all_mug_initial_poses(), \\n range(iter_num, iter_num + self.num_processes),\\n repeat(self.all_probabilities), repeat(all_probabilities_lock), \\n repeat(self.total_iterations), repeat(num_counterexamples),\\n repeat(counter_lock), repeat(file_q), repeat(False), repeat(False))))\\n except FunctionTimedOut:\\n print('FUNCTION TIMED OUT, MORE THAN {} SECONDS!!!!'.format(max_time_per_map))\\n\\n # all_mug_initial_poses = []\\n # for j in range(self.num_processes):\\n # mug_initial_poses = []\\n # for i in range(self.num_mugs):\\n # mug_initial_poses += \\\\\\n # RollPitchYaw(np.random.uniform(0.0, 2.0*np.pi, size=3)).ToQuaternion().wxyz().tolist() + \\\\\\n # [np.random.uniform(-0.1, 0.1), np.random.uniform(-0.1, 0.1), np.random.uniform(0.1, 0.2)]\\n # all_mug_initial_poses.append(mug_initial_poses)\\n\\n # result = pool.starmap(self.mug_pipeline.run_inference,\\n # zip(all_mug_initial_poses, \\n # range(iter_num, iter_num + self.num_processes),\\n # repeat(self.all_probabilities), repeat(all_probabilities_lock), \\n # repeat(self.total_iterations), repeat(num_counterexamples),\\n # repeat(counter_lock), repeat(file_q), repeat(False), repeat(False)))\\n\\n iter_num += self.num_processes\\n print('new iter_num: {}'.format(iter_num), flush=True)\\n total_min = (time.time() - start_time)/60.0\\n print('avg min/image: {}, total minutes: {}'.format(total_min/(iter_num + 1), total_min))\\n print('------------------------------------------------', flush=True)\\n sys.stdout.flush()\\n except Exception as e:\\n raise e\\n\\n pool.close()\\n pool.join()\\n\\n sys.stdout.flush()\",\n \"def executeTest(self, test):\\n\\n #print test\\n\\n if not self.validateAllCars(test):\\n return \\\"0\\\"\\n\\n self.multiplier = 1\\n\\n cars = test\\n cars = self.compressAll(cars)\\n\\n # Make sure a letter isn't in the middle of a car\\n for c in cars:\\n for k in cars:\\n if (c[0] in k[1:-1]) or (c[-1] in k[1:-1]):\\n return \\\"0\\\"\\n\\n cars = [c[0] + c[-1] for c in cars]\\n cars = self.combineAll(cars)\\n cars = self.compressAll(cars)\\n\\n print \\\"%d * %s\\\" % (self.multiplier, cars)\\n\\n return (math.factorial(len(cars)) * self.multiplier) % 1000000007\\n\\n c = 0\\n\\n for i in itertools.permutations(cars):\\n train = \\\"\\\".join(i)\\n train = self.compressCar(train)\\n if self.validateTrain(train):\\n c = c + 1\\n\\n c = c * self.multiplier\\n\\n return c % 1000000007\",\n \"def testParallelRandom():\\n\\n N = 10\\n p = .7\\n\\n runs = 0\\n while runs < 50:\\n\\n G = nx.fast_gnp_random_graph(N, p)\\n a = 0\\n b = G.number_of_nodes()-1\\n\\n try:\\n nx.shortest_path(G, source=a, target=b)\\n except RuntimeError:\\n continue\\n\\n i, j = [], []\\n for xx in G.edges():\\n i.append(xx[0])\\n j.append(xx[1])\\n\\n # %.1f values for resistance\\n val = np.round(np.random.ranf(len(i))*100)/10\\n\\n # and test\\n nw1 = makeNW(i, j, val)\\n nw2 = parallelCopy(nw1, a, b)\\n ER1 = ResNetwork(nw1).effective_resistance(a, b)\\n ER2 = ResNetwork(nw2).effective_resistance(a, b)\\n\\n # assertion\\n assert (ER1/2-ER2) < 1E-6\\n\\n # increment runs\\n runs += 1\",\n \"def main():\\n LIMIT = 600\\n GOAL = 1000\\n for i in range(1, LIMIT + 1):\\n for j in range(1, LIMIT + 1):\\n for k in range(1, LIMIT + 1):\\n if i + j + k == GOAL:\\n if i**2 == j**2 + k**2:\\n print \\\"GOAL:\\\", (i, j, k)\",\n \"def test_pima_indians_diabetes_scikit_learn_comparison():\\n\\n print('\\\\n===============================')\\n print('=== PROJECT IMPLEMENTATION ====')\\n print('===============================')\\n\\n seed(1)\\n\\n pid = PimaIndiansDiabetes()\\n pid.data_preprocessing()\\n project_efficiency_percent = pid.calculate_accuracy(n_folds=2)\\n\\n\\n print('\\\\n===============================')\\n print('=========== SKLEARN ===========')\\n print('===============================')\\n\\n # loading data from .csv file\\n filename = 'datasets/pima-indians-diabetes.csv'\\n X = list()\\n y = list()\\n\\n with open(filename, 'r') as f:\\n\\n csv_reader = reader(f)\\n\\n for i, row in enumerate(csv_reader):\\n converted_row = list()\\n for j in range(len(row)-1):\\n converted_row.append(float(row[j]))\\n X.append(converted_row)\\n y.append(int(row[-1]))\\n\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)\\n\\n gnb = GaussianNB()\\n y_pred = gnb.fit(X_train, y_train).predict(X_test)\\n\\n num_of_points = 384\\n mislabeled_points = (y_test != y_pred).sum()\\n sklearn_efficiency_percent = ((num_of_points - mislabeled_points) / num_of_points) * 100\\n\\n print(f'\\\\n\\\\nCalculating the scikit-learn algorithm accuracy with pima-indians-diabetes.csv dataset...')\\n print(f'\\\\nNumber of mislabeled points out of a total {num_of_points} points : {mislabeled_points}')\\n print(f'\\\\nAlgorithm efficiency: {round(sklearn_efficiency_percent, 5)} %')\\n\\n assert (project_efficiency_percent - sklearn_efficiency_percent) < 10\",\n \"def performance():\\n\\tn = 1024\\n\\twhile n < 5000000: \\n\\t\\tsorted = range(n)\\n\\t\\tnow = time()\\n\\n\\t\\t# Code whose performance is to be evalutated\\n\\t\\tbs_contains(sorted, -1)\\n\\n\\t\\tdone = time()\\n\\n\\t\\tprint n, (done-now)*10000\\n\\t\\tn *= 2\",\n \"def main(cls, args):\\n #cls.trainOfflineAndTest(100, 0.1, 0.1, 0.9);\\n #cls.trainOfflineAndTest(500, 0.1, 0.1, 1.0);\\n\\n cls.trainer.teachActiveAndSaveStatistics(\\\"onlineTest\\\", 10, 0.8, 1.0 ,1.0, 0.0, 0.3, True, True,True);\\n cls.trainer.teachActiveAndSaveStatistics(\\\"path\\\", 10, 0.0, 0.0, 0.0, 0.0, 0.0, True, False, False)\\n\\n #trainer.teachActiveAndSaveStatistics(\\\"onlineTest\\\", 10000, 0.1f, 0.1f, 1.0f, 0.0f, 0.1f,true, true, true);\\n # \\t\\ttrainer.teachActiveAndSaveStatistics(\\\"onlineTest\\\", 10000, 0.1f, 0.1f, 1.0f, 0.0f, 0.1f,\\n # \\t\\t\\t\\tfalse, true, true);\\n # \\t\\t\\n # \\t\\ttestAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1_first.net\\\", 10000, true);\\n # \\t\\ttestAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1_secound.net\\\", 10000, true);\\n #cls.testAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1_first.net\\\", 10000, False)\\n #cls.testAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1_secound.net\\\", 10, False)\\n # \\t\\ttestAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1.net\\\", 10000, false);\",\n \"def slow_function(*args, **kwargs):\\n print('Password generation...')\\n time.sleep(2)\\n password = randint(1, 10)\\n return password\",\n \"def benchmark(Algorithm_, Network_, test): \\n \\n def sample(Algorithm_, Network_, test):\\n \\\"\\\"\\\"\\n Runs the Algorithm on Networks of the given type, varying n.\\n After every execution, runs test on the resultant Network_.\\n\\n @param Algorithm_: a subclass of Synchronous_Algorithm, the algorithm to test.\\n @param Network_: a subclass of Network, the network on which to benchmark the algorithm.\\n @param test: a function that may throw an assertion error \\n @return: (size, time, comm) where size is a list of values of network size,\\n and time and comm are lists of corresponding values of time and communication complexities.\\n \\\"\\\"\\\"\\n size = []\\n time = []\\n comm = []\\n n, lgn = 2, 1\\n max_time = 0\\n max_comm = 0\\n print \\\"Sampling n = ...\\\",\\n while max(max_time, max_comm) < 10000 and n < 500:\\n\\n #Progress\\n if n == 2:\\n print \\\"\\\\b\\\\b\\\\b\\\\b\\\"+str(n)+\\\"...\\\",\\n else:\\n print \\\"\\\\b\\\\b\\\\b\\\\b, \\\"+str(n)+\\\"...\\\",\\n\\n cur_times = []\\n cur_comms = []\\n for i in xrange( max(4, 2+lgn) ):\\n A = Algorithm_(params={'draw': False, 'verbosity': Algorithm.SILENT})\\n x = Network_(n)\\n A(x)\\n try:\\n test(x)\\n except AssertionError, e:\\n print \\\"Algorithm Failed\\\"\\n return None\\n else:\\n size.append(n)\\n cur_comms.append(A.message_count)\\n comm.append(A.message_count)\\n\\n if issubclass(Algorithm_, Synchronous_Algorithm):\\n cur_times.append(A.r)\\n time.append(A.r)\\n max_time = max(max_time, A.r)\\n max_comm = max(max_comm, A.message_count)\\n\\n #TODO here, decide whether need more samples for this n, based on cur_times and cur_comms variance\\n n*=2\\n lgn += 1\\n print \\\" DONE\\\"\\n return size, comm, time\\n\\n def averages(x,y):\\n \\\"\\\"\\\"\\n Groups x's with the same value, averages corresponding y values.\\n\\n @param x: A sorted list of x values\\n @param y: A list of corresponding y values\\n @return: (x grouped by value, corresponding mean y values)\\n \\n Example:\\n\\n averages([1,1,2,2,2,3], [5,6,3,5,1,8]) --> ([1, 2, 3], [5.5, 3.0, 8.0])\\n \\n \\\"\\\"\\\"\\n new_x = [x[0]]\\n new_y = []\\n\\n cur_x = new_x[0]\\n cur_ys = []\\n for x_i, y_i in zip(x,y):\\n if x_i == cur_x:\\n cur_ys.append(y_i)\\n else:\\n new_y.append( sum(cur_ys)/float(len(cur_ys) ) )\\n new_x.append( x_i )\\n cur_ys = [y_i]\\n cur_x = x_i\\n new_y.append( sum(cur_ys)/float(len(cur_ys) ) )\\n return new_x, new_y\\n\\n def plot(x, y, title):\\n \\\"\\\"\\\"Plots the points (x[i],y[i]) for all i, fig.\\\"\\\"\\\"\\n fig, ax = plt.subplots()\\n\\n x_ave,y_ave = averages(x,y)\\n\\n ax.scatter(x, y, label=\\\"data\\\", color='b')\\n ax.scatter(x_ave, y_ave, label=\\\"means\\\", color='r')\\n \\n ax.set_xlim( xmin=0 ) \\n ax.set_ylim( ymin=0 )\\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\\n ax.set_title(title)\\n ax.set_xlabel(Network_.__name__ +' size')\\n\\n data = sample(Algorithm_, Network_, test)\\n if data == None: return\\n size, comm, time = data\\n \\n if issubclass(Algorithm_, Synchronous_Algorithm):\\n plot(size, time, Algorithm_.__name__ + ' Time Complexity')\\n\\n plot(size, comm, Algorithm_.__name__ + ' Communication Complexity')\",\n \"def run_tests(): \\n \\n\\n nextdata = [[21, 61, 42, 30], [33,45, 18, 29]]\\n\\n for xval, yval, snum, expect in nextdata:\\n\\n pmachine = PMachine()\\n pmachine.serial_number = snum\\n pmachine.run2_completion()\\n result = pmachine.calc_square_total(xval, yval, showsquare=True)\\n assert result == expect\\n print(\\\"Got value {}={} as expected\\\".format(result, expect))\",\n \"def main():\\r\\n test = TesterNeighbour()\\r\\n test.setUp()\\r\\n test.test_result_n()\\r\\n print(\\\"result_of_algorithm_test - passed\\\")\",\n \"def sim_alternating():\\n catches = 0\\n for _ in range(100000):\\n j = np.random.uniform()*1000\\n # j = np.random.exponential(500)\\n t_i = 0\\n i = 0\\n while t_i < j+100:\\n if i % 2 == 0:\\n t_i += 10\\n else:\\n t_i += 20\\n if j < t_i and t_i < j+1:\\n catches += 1\\n i += 1\\n print(catches/100000)\",\n \"def run(self,step=2,\\n sizePop=100,\\n infoFields=['migrate_to','fitness'],\\n recombination_rate = 0.00375,\\n migration_rate = 0.01,\\n mutation_rate = [0.00000001],\\n subPopNames = ['x','y','z','w'],\\n alleleNames = ['A','B'],\\n s1 = 0.1,\\n burnin=50,\\n **kargs):\\n\\n self.reset()\\n pop=sim.Population(size=[sizePop]*self.numPop, loci=self.loci, lociPos=list(range(self.dist, (self.dist*self.loci)+1,self.dist)), subPopNames=subPopNames, infoFields=infoFields)\\n \\n simu = sim.Simulator(pop)\\n print(\\\"The simulation has started\\\")\\n t1 = time.time()\\n\\n\\n mutate_snps=range(0,50)+range(51,101)\\n\\n # define the initialization of each loci based the beta distribution where a and b parameters are allele frequencies from noncoding human regions\\n snps=[0.14, 0.11, 0.17, 0.11, 0.32, 0.33, 0.21, 0.11, 0.11, 0.28, 0.11, 0.12, 0.8, 0.66, 0.74, 0.68, 0.66, 0.77, 0.77, 0.76, 0.77, 0.74, 0.72, 0.11, 0.73, 0.72, 0.72, 0.72, 0.54, 0.17, 0.78, 0.64, 0.78, 0.2, 0.24, 0.25, 0.78, 0.66, 0.2, 0.14, 0.75, 0.16, 0.72, 0.18, 0.77, 0.42, 0.34, 0.7, 0.17, 0.14, 0.2, 0.46, 0.13, 0.26, 0.16, 0.13, 0.14, 0.24, 0.18, 0.36, 0.71, 0.27, 0.28, 0.25, 0.25, 0.3, 0.19, 0.14, 0.16, 0.3, 0.39, 0.16, 0.24, 0.32, 0.11, 0.18, 0.48, 0.31, 0.21, 0.15, 0.34, 0.71, 0.33, 0.18, 0.71, 0.13, 0.23, 0.2, 0.22, 0.23, 0.16, 0.23, 0.23, 0.22, 0.24, 0.82, 0.36, 0.37, 0.72, 0.16, 0.14]\\n self.initFreq=[]\\n\\n \\n for i in range(len(snps)):\\n alpha=float(4*sizePop*migration_rate*snps[i])\\n bhta=float(4*sizePop*migration_rate*(1-snps[i])) \\n p=numpy.random.beta(alpha,bhta)\\n while (p>=0.9 or p<=0.1):\\n p=numpy.random.beta(alpha,bhta)\\n \\n print \\\" SNP {snp} with alpha {alpha}, bhta {bhta} and frequency {p}\\\".format(snp=i, alpha=alpha, bhta=bhta, p=p)\\n self.initFreq.append(p)\\n\\n simu.evolve(\\n \\n initOps=[sim.InitGenotype(freq=[self.initFreq[i], 1-self.initFreq[i]], loci=i) for i in range(len(snps))],\\n \\n\\n # initialize the sex and select the 50 loci (parents)\\n preOps = [sim.InitSex(maleProp=0.5,at=[0]),\\n\\n # initialize the genotype of locus 50 at generation 0 (in the beginning of the simulation)\\n sim.PyOperator(self.genotypeBegin,at=[0]),\\n \\n # Wait 50 generations for the system to reach equilibrium\\n # Then, change the the genotype of locus 50 at generation 50 by inserting a single copy of allele 0 in one individual \\n sim.PyOperator(self.genotypeAfter,at=[50]),\\n\\n # function that carries out the selection proccess\\n sim.MaSelector(loci=50,wildtype=0,fitness=[1+s1, 1+s1/2, 1],begin=50, end=-1,subPops=1)],\\n\\n # recombination\\n matingScheme=sim.RandomMating(ops=[\\n sim.Recombinator(rates=recombination_rate)]),\\n \\n # mutation and migration of offsprings\\n postOps = [\\n\\n \\n sim.SNPMutator(u=mutation_rate,loci=mutate_snps),\\n \\n # call function to calculate Fst and check for equilibrium state\\n sim.PyOperator(self.calcFst,step=step),\\n\\n #migration\\n # Here we define an island model, but this can easily be changed.\\n # For more information about the migration models, please look in the documentation of SimuPOP here http://simupop.sourceforge.net/manual_svn/build/userGuide_ch7_sec3.html\\n sim.Migrator(sim.utils.migrIslandRates(migration_rate,self.numPop)),\\n \\n # call function to save the allele frequencies\\n sim.PyOperator(self.checkAlleles, step=step, param = subPopNames),\\n \\n \\n # check if locus 50 is lost due to genetic drift. If yes, we terminate the simulation\\n sim.Stat(alleleFreq=50,step=step,subPops=1,begin=50,end=-1),\\n sim.TerminateIf('alleleFreq[50][0] == 0',step=step,begin=50,end=-1),\\n \\n # check the progress of the simulation\\n sim.PyEval('\\\"Gen: %d\\\" % gen',step=step),\\n sim.PyOutput('\\\\n',step=step),\\n \\n ],\\n gen=self.Gen\\n \\n )\\n \\n \\n t2 = time.time()\\n print \\\"simulation took\\\", t2-t1, \\\"seconds.\\\"\",\n \"def run_automatic_tester():\\n number_of_target_maps = len(os.listdir(TargetDetectionTesterSettings.TARGET_DETECTION_REPORT_JSON_FILE_SAVE_PATH))\\n overall_true_positive_count = 0\\n overall_false_positive_count = 0\\n overall_target_count = 0\\n\\n for index_0 in range(number_of_target_maps):\\n\\n answer_sheet = json.load(open(os.path.join(TargetDetectionTesterSettings.TARGET_MAP_ANSWER_SHEET_PATH, str(index_0 + 1) + \\\".json\\\")))\\n answer_list = []\\n\\n for index_1 in range(len(answer_sheet[\\\"targets\\\"])):\\n answer_list.append((answer_sheet[\\\"targets\\\"][index_1][\\\"target_center_coordinates\\\"][0], answer_sheet[\\\"targets\\\"][index_1][\\\"target_center_coordinates\\\"][1]))\\n overall_target_count += len(answer_list)\\n\\n target_detection_result = json.load(open(os.path.join(TargetDetectionTesterSettings.TARGET_DETECTION_REPORT_JSON_FILE_SAVE_PATH, str(index_0 + 1) + \\\".json\\\")))\\n result_list = []\\n\\n for index_2 in range(len(target_detection_result[\\\"image_processing_results\\\"])):\\n result_list.append((target_detection_result[\\\"image_processing_results\\\"][index_2][\\\"target_location\\\"][0] + (target_detection_result[\\\"image_processing_results\\\"][index_2][\\\"target_location\\\"][2] / 2), target_detection_result[\\\"image_processing_results\\\"][index_2][\\\"target_location\\\"][1] + (target_detection_result[\\\"image_processing_results\\\"][index_2][\\\"target_location\\\"][3] / 2)))\\n\\n current_true_positive_count = 0\\n current_false_positive_count = 0\\n banned_index_list = []\\n\\n for index_3 in range(len(answer_list)):\\n true_positive_found = False\\n\\n for index_4 in range(len(result_list)):\\n is_index_4_banned = False\\n\\n for index_5 in range(len(banned_index_list)):\\n if (index_4 == banned_index_list[index_5]):\\n is_index_4_banned = True\\n\\n if (is_index_4_banned == True):\\n continue\\n\\n correct_target_center_x = answer_list[index_3][0]\\n correct_target_center_y = answer_list[index_3][1]\\n\\n detected_target_center_x = result_list[index_4][0]\\n detected_target_center_y = result_list[index_4][1]\\n\\n if ((abs(correct_target_center_x - detected_target_center_x) <= 20) and (abs(correct_target_center_y - detected_target_center_y) <= 20)):\\n current_true_positive_count += 1\\n banned_index_list.append(index_4)\\n true_positive_found = True\\n continue\\n\\n current_false_positive_count = len(result_list) - current_true_positive_count\\n\\n overall_true_positive_count += current_true_positive_count\\n overall_false_positive_count += current_false_positive_count\\n\\n percentage = 100 * float(overall_true_positive_count) / (overall_target_count)\\n\\n TargetDetectionTesterLogger.log(\\\"--------------------------------------------------\\\")\\n TargetDetectionTesterLogger.log(\\\"Total True Positive Count: \\\" + str(overall_true_positive_count))\\n TargetDetectionTesterLogger.log(\\\"Total False Positive Count: \\\" + str(overall_false_positive_count))\\n TargetDetectionTesterLogger.log(\\\"Percentage of Successfully Detected Targets: \\\" + str(percentage) + \\\"%\\\")\\n TargetDetectionTesterLogger.log(\\\"--------------------------------------------------\\\")\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\\\"\\n aStarSearch(problem)\",\n \"def run_experiment() -> List[bool]:\\n return [random.random() < 0.5 for _ in range(1000)]\",\n \"def test_call(self, MetricClass, seed):\\n m = MetricClass()\\n strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))\\n result0 = np.array(m.result(strategy)) # from `result` method\\n result1 = np.array(m(strategy)) # from __call__\\n assert np.equal(result0, result1).all()\",\n \"def train_eval_rnd(self, train_data, test_data, rand_iter, train_labels, test_labels):\\n np.random.seed(0)\\n shuf_tr = [np.random.permutation(train_labels)\\n for _ in range(rand_iter)]\\n misclass_tr, misclass_ts = [], []\\n for lab in shuf_tr:\\n self.class_method.fit(train_data, lab)\\n misclass_tr.append(zero_one_loss(lab, self.class_method.predict(train_data)))\\n misclass_ts.append(zero_one_loss(test_labels,\\n _kuhn_munkres_algorithm(test_labels,\\n self.class_method.predict(test_data))))\\n return np.mean(misclass_tr), np.mean(misclass_ts)\\n # start = time.process_time()\\n # np.random.seed(0)\\n # shuf_tr, shuf_val = zip(*[list(map(lambda x: np.random.permutation(x),\\n # [tr_labels, val_labels])) for _ in range(rand_iter)])\\n # # print(f'Shuffle train:{shuf_tr}, Shuffle val:{shuf_val}')\\n # # logging.info(f'Shuffle labels: {time.process_time()-start}s')\\n # # part = time.process_time()\\n # model_tr = [self.class_method.fit(train_data, lab) for lab in shuf_tr]\\n # # print(f'Models:{model_tr}')\\n # # logging.info(f'Train model: {time.process_time()-part}s')\\n # # part = time.process_time()\\n # misclass_tr = [zero_one_loss(x, y.predict(train_data)) for x, y in\\n # zip(shuf_tr, model_tr)]\\n # # print(f'Misclassification tr:{misclass_tr}')\\n # # logging.info(f'Misclass TR: {time.process_time()-part}s')\\n # # part = time.process_time()\\n # misclass_val = [zero_one_loss(x, _kuhn_munkres_algorithm(x,\\n # y.predict(val_data))) for x, y in\\n # zip(shuf_val, model_tr)]\\n # # print(f'Misclassification val:{misclass_val}')\\n # # logging.info(f'Misclass VAL: {time.process_time()-part}s')\\n # return np.mean(misclass_tr), np.mean(misclass_val)\\n # misc_avg_tr, misc_avg_ts = [], []\\n # append_tr = misc_avg_tr.append\\n # append_ts = misc_avg_ts.append\\n # for it in range(rand_iter):\\n # np.random.seed(0)\\n # np.random.shuffle(tr_labels)\\n # np.random.seed(0)\\n # np.random.shuffle(val_labels)\\n # model_tr = self.class_method.fit(train_data, tr_labels)\\n # misclass_tr = zero_one_loss(tr_labels,\\n # self.class_method.predict(train_data))\\n # misclass_ts = zero_one_loss(val_labels,\\n # _kuhn_munkres_algorithm(val_labels,\\n # model_tr.predict(val_data)))\\n # append_tr(misclass_tr)\\n # append_ts(misclass_ts)\\n # return np.mean(misc_avg_tr), np.mean(misc_avg_ts)\",\n \"def general_gantest(proba, nbr_qubits):\\n for m in [4096, 2048]:\\n for l in [1, 2, 3]:\\n print(\\\"Easy mode results for m={} and l={}:\\\".format(m, l))\\n Variationer_learn_gan(1000, l, m, proba=proba, n=nbr_qubits, distri_size=0, easy=True)\\n print(\\\"\\\\n\\\")\\n print(\\\"Distribution learning results for m={} and l={}:\\\".format(m, l))\\n for d in [256, 512]:\\n print(\\\"For \\\", d, \\\": \\\")\\n Variationer_learn_gan(1000, l, m, proba=proba, n=nbr_qubits, distri_size=d, easy=False)\\n print(\\\"Singleton learning results for m={} and l={}:\\\".format(m, l))\\n Variationer_learn_gan(1000, l, m, proba=proba, n=nbr_qubits, distri_size=0, easy=False)\",\n \"def bruteforce(request, url, host, port, agent, \\n user_key, pass_key, action_val, words):\\n # successful credentials\\n success = []\\n success_users = set()\\n\\n # Add all transformations for each word\\n all_words = set(words)\\n transformations = transform.generate_transformations(list(words))\\n for word in words:\\n transformation = transformations[word]\\n all_words.add(transformation.lower)\\n all_words.add(transformation.upper)\\n all_words.add(transformation.reverse)\\n all_words.add(transformation.leet)\\n \\n # Try all combinations for the form described by url on host\\n content_type = HTTP_CONTENTTYPE_FORMENCODED\\n sleep_time = HTTP_RETRY_TIME\\n for user in all_words:\\n for _pass in all_words:\\n data = {user_key: user, pass_key: _pass, 'action': action_val}\\n body = HttpRequest.generate_post_body(content_type,data)\\n content_length = len(body)\\n too_many_req = 0\\n while too_many_req < HTTP_TOO_MANY_REQ:\\n response = request.send_post_request(url, host, \\n agent, content_type,\\n content_length, body)\\n if response is None:\\n too_many_req += 1\\n print(f\\\" unable to contact {host}{url}. retrying in {HTTP_RETRY_TIME} seconds.\\\")\\n time.sleep(HTTP_RETRY_TIME)\\n continue\\n # print(f'User: {user}, Pass: {_pass}')\\n \\n # See if the response contained any words that indicate a successful login.\\n if verify_success_resp(tokenize_html(response.response,True)):\\n # print(f' SUCCESS.')\\n if user.lower() not in success_users:\\n success.append(Credential(user.lower(),_pass))\\n success_users.add(user.lower())\\n break\\n \\n # Check the status code.\\n status_tuple = response.status_code\\n if status_tuple is not None:\\n status_code, __ = status_tuple\\n # print(f' FAIL. {status_code}')\\n if status_code == \\\"429\\\" or status_code == \\\"503\\\":\\n time.sleep(sleep_time)\\n print(f\\\" {host}{url} was busy. retrying in {HTTP_RETRY_TIME} seconds.\\\")\\n too_many_req += 1\\n else:\\n break\\n if too_many_req >= HTTP_TOO_MANY_REQ:\\n return success\\n return success\",\n \"def evaluate_model_performance():\\n\\n config = load_config()\\n data_processor = DataProcessor()\\n df_test = data_processor.create_user_click_sequence(\\n start_date=config[\\\"test_split_date\\\"]\\n )\\n df_test[\\\"truths\\\"] = df_test[\\\"merchant_seq\\\"].apply(lambda x: list(set(x)))\\n truth_dict = dict(zip(df_test[\\\"user_id\\\"], df_test[\\\"truths\\\"]))\\n\\n # get model\\n print(\\\"model training...\\\")\\n model = Merchant2VecModel()\\n model.train()\\n\\n # compute mAP@k\\n k = model.num_rec\\n all_truths, all_preds = [], []\\n for user_id, user_merchants in truth_dict.items():\\n this_pred = model.generate_predictions(\\n user_id=user_id, eval_date=config[\\\"test_split_date\\\"]\\n )\\n all_truths.append(user_merchants)\\n all_preds.append(this_pred)\\n score = mapk(all_truths, all_preds, k)\\n print(\\\"mAP@{} for current model: {:.4f}\\\".format(k, score))\",\n \"def fuzz(self):\\n self.total_mutant_index = 0\\n self.total_num_mutations = self.num_mutations()\\n\\n self._main_fuzz_loop(self._iterate_protocol())\",\n \"def test_random_unitary_gate(self):\\n shots = 2000\\n circuits = ref_unitary_gate.unitary_random_gate_circuits_nondeterministic(final_measure=True)\\n targets = ref_unitary_gate.unitary_random_gate_counts_nondeterministic()\\n result = execute(circuits, self.SIMULATOR, shots=shots).result()\\n self.assertTrue(getattr(result, 'success', False))\\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)\",\n \"def main(self):\\n \\n\\tsession = db.Session()\\n\\tspeed = -1\\n\\n\\t#self.checkResponseStatus()\\n\\n\\t#secondsBetween = random.uniform(config.MIN_SCAN_DELAY, config.MIN_SCAN_DELAY + 2)\\n #time.sleep(secondsBetween)\\n\\t\\n \\tstartTime = time.time()\\n#\\tlogger.info(\\\"Starting scanning at: %s\\\", time.asctime( time.localtime(startTime) ) )\\n\\n\\tself.minorFailCount = 0\\n for i, point in enumerate(self.points):\\n\\t self.minorFailCount = 0\\n\\t self.performMapOperations(i, point, session)\\n\\n endTime = time.time()\\n# logger.info(\\\"Stopped scanning at: %s\\\", time.asctime( time.localtime(endTime) ) )\\n\\ttimeElapsed = endTime - startTime\\n\\tminutes = timeElapsed/60\\n\\tminutesRounded = math.floor(minutes)\\n\\tseconds = math.floor(60*(minutes-minutesRounded))\\n\\tlogger.info(\\\"Time elapsed: %d:%d\\\", minutesRounded, seconds)\\t \\n logger.info(\\\"Total pokemon seen: %d (average per cycle: %f)\\\", self.seen_per_cycle, (self.seen_per_cycle/len(self.points))) \\n \\n session.close()\\n if self.seen_per_cycle == 0:\\n self.error_code = 'NO POKEMON'\",\n \"def test_ngram():\\n #Some examples of functions usage\\n trigram_counts, bigram_counts, unigram_counts, token_count = train_ngrams(S_train)\\n print \\\"#trigrams: \\\" + str(len(trigram_counts))\\n print \\\"#bigrams: \\\" + str(len(bigram_counts))\\n print \\\"#unigrams: \\\" + str(len(unigram_counts))\\n print \\\"#tokens: \\\" + str(token_count)\\n perplexity = evaluate_ngrams(S_dev, trigram_counts, bigram_counts, unigram_counts, token_count, 0.5, 0.4)\\n print \\\"#perplexity: \\\" + str(perplexity)\\n ### YOUR CODE HERE\\n ### END YOUR CODE\",\n \"def compare(numberOfSimulations, initialValue, sigma, T, strike, r = 0):\\n \\n numberOfTests = 100\\n \\n \\n #the two lists that will contain our average errors for the different tests\\n errorsStandardMonteCarlo = []\\n errorsMonteCarloWithAV = []\\n \\n #our benchmark: the analytic price of the call option\\n analyticPriceBS = blackScholesPriceCall(initialValue, r, sigma, T, initialValue)\\n\\n #look at how lambda functions are defined in Python \\n payoff = lambda x : max(x - initialValue, 0)\\n \\n #alternatively:\\n #def payoff(x):\\n # return max(x - initialValue, 0)\\n \\n #note how to construct an object of a class\\n \\n blackScholesGenerator = GenerateBlackScholes(numberOfSimulations, T, initialValue, sigma, r)\\n #k=0,..,numberOfTests - 1\\n for k in range(numberOfTests):\\n \\n \\n\\n #first, the valuation with the standard Monte-Carlo:\\n realizationsOfTheProcessWithStandardMC = blackScholesGenerator.generateRealizations()\\n \\n priceCalculatorWithStandardMC = SimpleEuropeanOption(realizationsOfTheProcessWithStandardMC, r)\\n priceStandardMC = priceCalculatorWithStandardMC.getPrice(payoff, T) \\n errorWithStandardMC= abs(priceStandardMC - analyticPriceBS)/analyticPriceBS\\n #note how to append new values to a list\\n errorsStandardMonteCarlo.append(errorWithStandardMC)\\n \\n #then, the one with Antithetic Variables:\\n realizationsOfTheProcessWithAV = blackScholesGenerator.generateRealizationsAntitheticVariables()\\n \\n priceCalculatorWithAV = SimpleEuropeanOption(realizationsOfTheProcessWithAV, r)\\n priceWithAV = priceCalculatorWithAV.getPrice(payoff, T) \\n errorWithAV= abs(priceWithAV - analyticPriceBS)/analyticPriceBS\\n #note how to append new values to a list\\n errorsMonteCarloWithAV.append(errorWithAV)\\n\\n #we get and return the respective average errors: mean is imported from\\n #statistics\\n averageErrorStandardMC = mean(errorsStandardMonteCarlo)\\n #you can also use numpy\\n averageErrorAV = np.mean(errorsMonteCarloWithAV)\\n \\n return averageErrorStandardMC, averageErrorAV\",\n \"def test_hackerrank_sample1(self):\\n result = find_digits(12)\\n self.assertEquals(result, 2)\",\n \"def test_generate_nb_testing(self):\\n pass\",\n \"def runtest(self):\",\n \"def run_simulation(n, experiments, iterations, budget, recovery_count, performance_factor, current_top,\\r\\n precomputed=True, dataset=None):\\r\\n T = 0\\r\\n k = 5\\r\\n delta = 0.1\\r\\n range_m = 1*np.arange(1, budget+1)\\r\\n scores, true_top = init(n, precomputed=precomputed, dataset=dataset)\\r\\n true_ranks = get_ranks(scores)\\r\\n\\r\\n for exp in tqdm.tqdm(range(experiments), desc=\\\"experiments\\\"):\\r\\n for itr in tqdm.tqdm(range(iterations), desc=\\\"iterations\\\"):\\r\\n t = 1\\r\\n count = 0\\r\\n A = np.arange(n)\\r\\n P = np.zeros((n, n))\\r\\n S = np.zeros(n)\\r\\n r_count = 0\\r\\n data = []\\r\\n for b in range(budget):\\r\\n m = range_m[b]\\r\\n\\r\\n est, t, A, P, S, count, r_count, data = sparse_borda(n, t, T, k, A, P, S, delta, scores, m*n, count, r_count, data)\\r\\n\\r\\n ranking, ranks, top = get_ranking(n, est)\\r\\n if(top == true_top):\\r\\n recovery_count[b][exp] += 1\\r\\n performance_factor[b][exp] += ranks[true_top]\\r\\n current_top[b][exp] += true_ranks[top]\\r\\n\\r\\n current_top /= iterations\\r\\n performance_factor /= iterations\\r\\n\\r\\n return ranking, ranks, data, scores, true_top, est, recovery_count, performance_factor, current_top\",\n \"def test_marketsim(description, group, inputs, outputs, grader):\\n\\n points_earned = 0.0 # initialize points for this test case\\n try:\\n # Try to import student code (only once)\\n if not main_code in globals():\\n import importlib\\n # * Import module\\n mod = importlib.import_module(main_code)\\n globals()[main_code] = mod\\n # * Import methods to test\\n for m in ['compute_portvals']:\\n globals()[m] = getattr(mod, m)\\n\\n incorrect = False\\n msgs = []\\n\\n if group == 'author':\\n try:\\n # globals()['author'] = getattr(marketsim, 'author')\\n auth_string = run_with_timeout(marketsim.author,seconds_per_test_case,(),{})\\n if auth_string == 'tb34':\\n incorrect = True\\n msgs.append(\\\" Incorrect author name (tb34)\\\")\\n points_earned = -20\\n elif auth_string == '':\\n incorrect = True\\n msgs.append(\\\" Empty author name\\\")\\n points_earned = -20\\n except Exception as e:\\n incorrect = True\\n msgs.append(\\\" Exception occured when calling author() method: {}\\\".format(e))\\n points_earned = -20\\n else:\\n # Unpack test case\\n orders_file = inputs['orders_file']\\n start_val = inputs['start_val']\\n\\n portvals = None\\n fullpath_orders_file = orders_file#get_orders_data_file(orders_file)\\n portvals = run_with_timeout(compute_portvals,seconds_per_test_case,(fullpath_orders_file,start_val),{})\\n # Verify against expected outputs and assign points\\n\\n # * Check return type is correct, coax into Series\\n assert (type(portvals) == pd.Series) or (type(portvals) == pd.DataFrame and len(portvals.columns) == 1), \\\"You must return a Series or single-column DataFrame!\\\"\\n if type(portvals) == pd.DataFrame:\\n portvals = portvals[portvals.columns[0]] # convert single-column DataFrame to Series\\n if group == 'basic':\\n if len(portvals) != outputs['num_days']:\\n incorrect=True\\n msgs.append(\\\" Incorrect number of days: {}, expected {}\\\".format(len(portvals), outputs['num_days']))\\n else:\\n points_earned += 2.0\\n if abs(portvals[-1]-outputs['last_day_portval']) > (0.001*outputs['last_day_portval']):\\n incorrect=True\\n msgs.append(\\\" Incorrect final value: {}, expected {}\\\".format(portvals[-1],outputs['last_day_portval']))\\n else:\\n points_earned += 5.0\\n adr,sr = get_stats(portvals)\\n if abs(sr-outputs['sharpe_ratio']) > abs(0.001*outputs['sharpe_ratio']):\\n incorrect=True\\n msgs.append(\\\" Incorrect sharpe ratio: {}, expected {}\\\".format(sr,outputs['sharpe_ratio']))\\n else:\\n points_earned += 1.5\\n if abs(adr-outputs['avg_daily_ret']) > abs(0.001*outputs['avg_daily_ret']):\\n incorrect=True\\n msgs.append(\\\" Incorrect avg daily return: {}, expected {}\\\".format(adr,outputs['avg_daily_ret']))\\n else:\\n points_earned += 1.0\\n elif group=='leverage':\\n if abs(portvals[-1]-outputs['last_day_portval']) > (0.001*outputs['last_day_portval']):\\n incorrect = True\\n msgs.append(\\\" Incorrect final value: {}, expected {}\\\".format(portvals[-1],outputs['last_day_portval']))\\n else:\\n points_earned += 1.0\\n if incorrect:\\n # inputs_str = \\\" orders_file: {}\\\\n\\\" \\\\\\n # \\\" start_val: {}\\\\n\\\".format(orders_file, start_val)\\n raise IncorrectOutput, \\\"Test failed on one or more output criteria.\\\\n Inputs:\\\\n{}\\\\n Failures:\\\\n{}\\\".format(inputs, \\\"\\\\n\\\".join(msgs))\\n except Exception as e:\\n # Test result: failed\\n msg = \\\"Test case description: {}\\\\n\\\".format(description)\\n \\n # Generate a filtered stacktrace, only showing erroneous lines in student file(s)\\n \\n tb_list = tb.extract_tb(sys.exc_info()[2])\\n if 'grading_traceback' in dir(e):\\n tb_list = e.grading_traceback\\n for i in xrange(len(tb_list)):\\n row = tb_list[i]\\n tb_list[i] = (os.path.basename(row[0]), row[1], row[2], row[3]) # show only filename instead of long absolute path\\n tb_list = [row for row in tb_list if row[0] == 'marketsim.py']\\n if tb_list:\\n msg += \\\"Traceback:\\\\n\\\"\\n msg += ''.join(tb.format_list(tb_list)) # contains newlines\\n msg += \\\"{}: {}\\\".format(e.__class__.__name__, e.message)\\n\\n # Report failure result to grader, with stacktrace\\n grader.add_result(GradeResult(outcome='failed', points=points_earned, msg=msg))\\n raise\\n else:\\n # Test result: passed (no exceptions)\\n grader.add_result(GradeResult(outcome='passed', points=points_earned, msg=None))\",\n \"def algorithm_loop(self):\",\n \"def faster():\\n try:\\n ttsEng.faster()\\n except Exception, e:\\n logging.error(e)\",\n \"def iteration(self):\\n T = self.generate_T()\\n R = self.reproduce(T)\\n self.P = self.choose_mi_best(R)\\n #print(self.P)\",\n \"def run():\\n # all data and labels\\n # tracemalloc.start()\\n # start = time.time()\\n data, labels = Startdata.getdata() # texts\\n data2, labels2 = Startdata.getdata2() # emails\\n # Startdata.bagofwords(data2, labels2)\\n data, labels = Startdata.combinedata(data, data2, labels, labels2)\\n # split into training and testing. 1/3 test, 2/3 train\\n traind, trainl, testd, testl = Startdata.splitdata(data, labels)\\n\\n # labels\\n trainlabels = Startdata.labelfix(trainl)\\n testlabels = Startdata.labelfix(testl)\\n\\n # selective features\\n #\\n # extract features for use. in the shape of NxD\\n # N is number of samples, D is number of features\\n # current, peak = tracemalloc.get_traced_memory()\\n trainfeat = Startdata.featurextract(traind, trainl)\\n testfeat = Startdata.featurextract(testd, testl)\\n # theta is the weights in a D+1 X 1 array\\n theta = Spamfilter.train(trainfeat, trainlabels)\\n #\\n # trying bag of words\\n #\\n\\n # Startdata.featurextract(data, labels)\\n # error rate was 1.69% for trainingdata\\n # 2.21% for testing data\\n # bag, tfeat = Startdata.bagofwords(traind)\\n # theta = Spamfilter.train(tfeat, trainlabels)\\n # testfeat = Startdata.features(testd, bag)\\n\\n test(theta, testfeat, testlabels)\\n # tracemalloc.stop()\\n # done = time.time()\\n # print(f\\\"Current memory usage is {current / 10**6} MB; Peak was {peak / 10**6} MB\\\")\\n # print(\\\"time to complete\\\", done - start)\\n # NTR 12/1/2020 current best featextraction at 25 iterations is about\\n # 0.7-1% error for\\n # trainingdata and testing data\\n # NTR 12/2/2020 bag of words at 25 iterations\\n # 1.69% training error, 2.21% testing error\\n # NTR 12/2/2020 bag of words, 25 iter, removal of some features\\n # NTR 12/3/2020 featextraction 20 iterations, new features, emails inc\\n # 0.59% error on training. 0.63% testing error\",\n \"def run_benchmark():\\n import argparse\\n parser = argparse.ArgumentParser(description='Benchmark alchemically modified system against unmodified system.')\\n parser.add_argument('--platform', dest='platform_name', action='store', default=None, help='platform name to benchmark (default: None)')\\n options = parser.parse_args()\\n\\n from sams.tests import testsystems\\n for testsystem_name in ['AblImatinibExplicitAlchemical']:\\n cls = getattr(testsystems, testsystem_name)\\n testsystem = cls()\\n factory_args = { 'ligand_atoms' : testsystem.alchemical_atoms, 'receptor_atoms' : range(0,4266) }\\n benchmark(testsystem.system, testsystem.positions, platform_name=options.platform_name, nsteps=5000, timestep=1.0*unit.femtoseconds, factory_args=factory_args)\",\n \"def _evaluate_performance__static_winners(self):\\n # | - _evaluate_performance__\\n\\n # | - class attributes #################################################\\n AL = self\\n al_gen = self.al_gen\\n verbose = self.verbose\\n seed_ids = self.seed_ids\\n acquisition_bin = self.acquisition_bin\\n completed_ids = self.completed_ids\\n CandidateSpace = self.CandidateSpace\\n RegressionModel = self.RegressionModel\\n DuplicateFinder = self.DuplicateFinder\\n al_gen_dict = self.al_gen_dict\\n\\n stop_mode = self.stop_mode\\n stop_num_generations = self.stop_num_generations\\n\\n index_acq_gen_dict = self.index_acq_gen_dict\\n #__| #################################################################\\n\\n # #####################################################################\\n mode = \\\"lowest_N\\\" # 'lowest_N' or 'lowest_perc'\\n\\n N_ids = 10\\n lowest_perc = 5\\n\\n # Number of consecutive generations that the Nth best systems must\\n # remain static\\n M_gens = 3\\n # #####################################################################\\n\\n if mode == \\\"lowest_perc\\\":\\n num_candidates = CandidateSpace.FingerPrints.df_pre.shape[0]\\n N_ids = int(num_candidates * (lowest_perc * 0.01))\\n\\n gen_keys = list(AL.al_gen_dict.keys())\\n\\n if len(gen_keys) > M_gens:\\n latest_M_keys = gen_keys[-(M_gens + 1):]\\n last_gen_key = gen_keys[-1]\\n\\n al_gen_dict_subset_i = dict(zip(\\n latest_M_keys,\\n [AL.al_gen_dict.get(i, None) for i in latest_M_keys]))\\n\\n indices_list = []\\n iterator = enumerate(al_gen_dict_subset_i.items())\\n for i_cnt, (gen_i, AL_i) in iterator:\\n model_i = AL_i.model\\n\\n model_i = AL.add_main_Y_to_model(\\n model_i, plot_dft_instead_of_pred=True)\\n model_i = model_i[(model_i[\\\"duplicate\\\"] == False)]\\n model_i = model_i.sort_values(\\\"Y_main\\\")\\n\\n indices_i = model_i.index.tolist()\\n\\n indices_list.append(indices_i)\\n\\n if i_cnt >= M_gens:\\n indices_i = indices_list[i_cnt][0:N_ids]\\n ids_static_list = []\\n for j in range(M_gens):\\n indices_j = indices_list[i_cnt - (j + 1)][0:N_ids]\\n ids_static = indices_j == indices_i\\n ids_static_list.append(ids_static)\\n\\n ids_are_static = all(ids_static_list)\\n\\n self.performance__static_winners[last_gen_key] = ids_are_static\\n #__|\",\n \"def simulate_run(run, maker, all_data, train_mask, test_mask, instances, independent, mixture):\\n\\n train_data = all_data.masked(train_mask)\\n test_data = all_data.masked(test_mask)\\n\\n if instances is not None:\\n ids = sorted(train_data.run_lists, key = lambda _: numpy.random.rand())[:instances]\\n train_data = train_data.filter(*ids)\\n\\n if independent:\\n train_data = train_data.collect_independent(mixture).only_nonempty()\\n else:\\n train_data = train_data.collect_systematic(mixture).only_nonempty()\\n\\n budget = test_data.common_budget\\n #budget = test_data.common_budget / 2 # XXX\\n suite = borg.fake.FakeSuite(test_data)\\n\\n if maker.subname == \\\"preplanning-dir\\\":\\n model_kwargs = {\\\"K\\\": 64}\\n\\n if \\\"set_alpha\\\" in maker.variants:\\n model_kwargs[\\\"alpha\\\"] = 1e-2\\n else:\\n model_kwargs = {}\\n\\n solver = maker(suite, train_data, model_kwargs = model_kwargs)\\n successes = []\\n\\n for (i, instance_id) in enumerate(test_data.run_lists):\\n logger.info(\\\"simulating run %i/%i on %s\\\", i, len(test_data), instance_id)\\n\\n with suite.domain.task_from_path(instance_id) as instance:\\n with borg.accounting() as accountant:\\n answer = solver.start(instance).run_then_stop(budget)\\n\\n succeeded = suite.domain.is_final(instance, answer)\\n\\n logger.info(\\n \\\"%s %s on %s (%.2f CPU s)\\\",\\n maker.name,\\n \\\"succeeded\\\" if succeeded else \\\"failed\\\",\\n os.path.basename(instance),\\n accountant.total.cpu_seconds,\\n )\\n\\n if succeeded:\\n successes.append(accountant.total.cpu_seconds)\\n\\n logger.info(\\n \\\"%s had %i successes over %i instances\\\",\\n maker.name,\\n len(successes),\\n len(test_data),\\n )\\n\\n description = \\\"{0} ({1})\\\".format(mixture, \\\"Sep.\\\" if independent else \\\"Sys.\\\")\\n\\n return (\\n description,\\n maker.name,\\n instances,\\n len(successes),\\n numpy.mean(successes),\\n numpy.median(successes),\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6661952","0.6618818","0.64001924","0.63427407","0.6263836","0.6232404","0.6223552","0.59330684","0.59220713","0.59127235","0.58657014","0.58575463","0.5836921","0.58361584","0.58269995","0.5803118","0.5761818","0.573099","0.57286465","0.57004774","0.56819415","0.5672517","0.56461215","0.5611996","0.5586655","0.55782086","0.5568866","0.55688524","0.5551811","0.5546691","0.5521504","0.5518895","0.5493754","0.5493754","0.5493754","0.5493754","0.5492133","0.5481826","0.5481358","0.5479279","0.5478091","0.5466449","0.54597276","0.5458827","0.5456288","0.54497457","0.5449003","0.5444795","0.54397225","0.5433674","0.5429238","0.54110116","0.54028195","0.5401643","0.53896844","0.5388477","0.5385889","0.53792596","0.53760475","0.5367152","0.5366581","0.53494066","0.53473854","0.5336477","0.53362536","0.53327787","0.5331884","0.5329384","0.53175294","0.53142595","0.53133744","0.5312925","0.5308847","0.52885073","0.5284561","0.52833474","0.5282263","0.52816176","0.5280826","0.5280381","0.52789754","0.52731806","0.5272919","0.52728206","0.52720666","0.5269454","0.52600116","0.52549493","0.5254487","0.52475125","0.523804","0.5237237","0.5232533","0.5230309","0.52240264","0.5219752","0.521951","0.52193004","0.5211885","0.5210809"],"string":"[\n \"0.6661952\",\n \"0.6618818\",\n \"0.64001924\",\n \"0.63427407\",\n \"0.6263836\",\n \"0.6232404\",\n \"0.6223552\",\n \"0.59330684\",\n \"0.59220713\",\n \"0.59127235\",\n \"0.58657014\",\n \"0.58575463\",\n \"0.5836921\",\n \"0.58361584\",\n \"0.58269995\",\n \"0.5803118\",\n \"0.5761818\",\n \"0.573099\",\n \"0.57286465\",\n \"0.57004774\",\n \"0.56819415\",\n \"0.5672517\",\n \"0.56461215\",\n \"0.5611996\",\n \"0.5586655\",\n \"0.55782086\",\n \"0.5568866\",\n \"0.55688524\",\n \"0.5551811\",\n \"0.5546691\",\n \"0.5521504\",\n \"0.5518895\",\n \"0.5493754\",\n \"0.5493754\",\n \"0.5493754\",\n \"0.5493754\",\n \"0.5492133\",\n \"0.5481826\",\n \"0.5481358\",\n \"0.5479279\",\n \"0.5478091\",\n \"0.5466449\",\n \"0.54597276\",\n \"0.5458827\",\n \"0.5456288\",\n \"0.54497457\",\n \"0.5449003\",\n \"0.5444795\",\n \"0.54397225\",\n \"0.5433674\",\n \"0.5429238\",\n \"0.54110116\",\n \"0.54028195\",\n \"0.5401643\",\n \"0.53896844\",\n \"0.5388477\",\n \"0.5385889\",\n \"0.53792596\",\n \"0.53760475\",\n \"0.5367152\",\n \"0.5366581\",\n \"0.53494066\",\n \"0.53473854\",\n \"0.5336477\",\n \"0.53362536\",\n \"0.53327787\",\n \"0.5331884\",\n \"0.5329384\",\n \"0.53175294\",\n \"0.53142595\",\n \"0.53133744\",\n \"0.5312925\",\n \"0.5308847\",\n \"0.52885073\",\n \"0.5284561\",\n \"0.52833474\",\n \"0.5282263\",\n \"0.52816176\",\n \"0.5280826\",\n \"0.5280381\",\n \"0.52789754\",\n \"0.52731806\",\n \"0.5272919\",\n \"0.52728206\",\n \"0.52720666\",\n \"0.5269454\",\n \"0.52600116\",\n \"0.52549493\",\n \"0.5254487\",\n \"0.52475125\",\n \"0.523804\",\n \"0.5237237\",\n \"0.5232533\",\n \"0.5230309\",\n \"0.52240264\",\n \"0.5219752\",\n \"0.521951\",\n \"0.52193004\",\n \"0.5211885\",\n \"0.5210809\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6652606"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":10493,"cells":{"query":{"kind":"string","value":"Returns Classroom in good representation for user"},"document":{"kind":"string","value":"def __str__(self):\n return 'Classroom {} has a capacity of {} persons and ' \\\n 'has the following equipment: {}.'.format(\n self.number, str(self.capacity), ', '.join(self.equipment))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __repr__(self):\n return \"Classroom('{}', {}, {})\".format(self.number, self.capacity,\n str(self.equipment))","def __str__(self):\n return self.room_name","def __str__(self):\n return self.room.name","def json(self):\n return {'name': self.neighbourhood_group, 'neighbourhood': self.room_type}","def __repr__(self):\n return f'ResidenciaModel(name={self.neighbourhood_group}, neighbourhood={self.room_type})'","def format_room(room):\n new = {}\n new[\"name\"] = \"Room\"\n new[\"info\"] = {}\n for key in room:\n if key != \"containedSpaces\" and key != \"topLevelSpace\" and key != \"parentSpace\" and key != 'description' and key != 'id' and key!= 'type':\n new[\"info\"][key] = room[key]\n return new","def get_print_room_data(self, room):\n habitants = self.all_rooms[room]['occupants']\n\n return {'room': room, 'names': habitants}","def __str__(self):\n fields = []\n try:\n walls = self._walls\n if walls != 0:\n field = \"walls=\"\n if walls & Direction.North:\n field += \"N\"\n if walls & Direction.South:\n field += \"S\"\n if walls & Direction.East:\n field += \"E\"\n if walls & Direction.West:\n field += \"W\"\n fields.append(field)\n except Exception:\n pass\n try:\n egress = self._egress\n if egress:\n fields.append(\"egress=\" + str(egress))\n except Exception:\n pass\n try:\n distance = self._distance\n if distance:\n fields.append(\"distance=\" + str(distance))\n except Exception:\n pass\n try:\n self._check()\n except Exception as excp:\n fields.append(\"error=\" + repr(excp))\n result = \"Room(\" + \", \".join(fields) + \")\"\n return result","def addClassroom(classroomName, capacity,location):\n for classroom in classroomEntities:\n if classroom[\"classroomName\"] == classroomName:\n print(\"Two classrooms can not have same name\")\n return False\n\n if classroomEntities==[]:\n lastSavedIdNumber = \"0\"\n else:\n lastSavedId=classroomEntities[-1][\"classroomId\"] #update classroomId as first element in classroomEntities list\n lastSavedIdNumber=lastSavedId[2:]\n numberOfDigitsInID = 3\n if lastSavedIdNumber == \"9\" * len(lastSavedIdNumber):\n numberOfDigitsInID = len(lastSavedIdNumber) + 1\n classroomId=\"CR\"+str(int(lastSavedIdNumber)+1).rjust(numberOfDigitsInID,\"0\")\n\n # add the new Classroom\n newClassroom = {}\n newClassroom[\"classroomId\"] = classroomId\n newClassroom[\"classroomName\"] = classroomName\n newClassroom[\"capacity\"] = capacity\n newClassroom[\"location\"] = location\n classroomEntities.append(newClassroom)\n print(f\"Class Room is added into the system, Class Room id is {classroomId}.\")\n return True","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'owner' : self.user.name,\n 'room' : self.room.name,\n 'description' : self.description,\n 'price' : self.price,\n }","def helpClassroom(classroomId):\n selectedClassroomCopy = getClassroomById(classroomId)\n print(\"Class Id: \" + selectedClassroomCopy[\"classroomId\"])\n print(\"Name: \" + selectedClassroomCopy[\"classroomName\"])\n print(\"Capacity: \" + selectedClassroomCopy[\"capacity\"])\n print(\"Location: \" + selectedClassroomCopy[\"location\"])\n return True","def __str__(self):\n return self.nivel_participacao","def getClassroomById(classroomId):\n for classroom in classroomEntities:\n if classroom[\"classroomId\"] == classroomId:\n return classroom.copy()\n return None","def __str__(self):\n return '{0}: {1} \"{2}\" {3}'.format(\n self.race, self.name, self.nick, self.surname)","def us_citizen(self, instance):\r\n return instance.user.profile.us_citizen","def retrieve_google_classroom_data(request, sociallogin, **kwargs):\n # updates user's extra data\n user = User.objects.get(pk=request.user.id)\n user.name = sociallogin.account.extra_data['name']\n user.avatar = sociallogin.account.extra_data['picture']\n user.save()\n\n # get the user's authorization token\n token = SocialToken.objects.filter(account__user=request.user, account__provider='google')[0].token\n\n save_courses(user, token)","def to_representation(self, instance):\n\n return instance.courier_type","def serialize(self):\n return {\n \"grade\": self.grade,\n \"student\": {\n \"id\": self.student_id,\n \"fname\": self.student.fname,\n \"lname\": self.student.lname,\n \"dob\": self.student.dob,\n \"grad_year\": self.student.grad_year,\n \"gpa\": self.student.gpa,\n \"occupation\": self.student.occupation.serialize\n },\n \"course\": {\n \"id\": self.course_id,\n \"course_name\": self.course.course_name,\n \"field\": self.course.field.serialize,\n \"faculty\": self.course.faculty.serialize,\n \"semester\": self.course.semester.serialize\n }\n }","def test_user_only_sees_own_classroom_state(self):\n self.client.force_authenticate(self.global_user_1)\n data = self.client.get(self.api_classroom_detail_url, {'user': 'current'}).data\n self.assertTrue(data.get('enrolled'))\n\n not_enrolled_user = get_user_model().objects.annotate(\n classrooms_count=Count('classrooms_states'),\n ).filter(classrooms_count=0)[0]\n self.client.force_authenticate(not_enrolled_user)\n data = self.client.get(self.api_classroom_detail_url, {'user': 'current'}).data\n self.assertFalse(data.get('enrolled'))","def to_string(self):\n return \"{base_msg} Courses: {courses}\".format(\n base_msg=super().to_string(),\n courses=self.courses_string()\n )","def __str__(self):\n return f\"{self.semester} | {self.school} | {self.position} | {self.class_name}\"","def get_joint_gensec(self, obj):\n serializer = UserProfileSerializer(obj.joint_gensec, many=True)\n return serializer.data","def __str__(self):\n return self.meeting_type","def __str__(self):\n print(\"Welcome to our house\")\n for room in self.rooms:\n print(room.name, room.sqr_ft)","def __repr__(self):\n return f\"<Tutor {self.first_name.title()} {self.last_name.title()}>\"","def serialize(self):\n return {'professor_id': self.professor_id,\n 'attendance': self.attendance,\n 'clarity_color': self.clarity_color,\n 'easy_color': self.easy_color,\n 'help_color': self.help_color,\n 'help_count': self.help_count,\n 'not_help_count': self.not_help_count,\n 'online_class': self.online_class,\n 'quality': self.quality,\n 'clarity': self.clarity,\n 'course': self.course,\n 'comments': self.comments,\n 'date': self.date,\n 'easy': self.easy,\n 'easy_string': self.easy_string,\n 'helpful': self.helpful,\n 'interest': self.interest,\n 'overall': self.overall,\n 'overall_string': self.overall_string,\n 'status': self.status,\n 'text_book_use': self.text_book_use,\n 'would_take_again': self.would_take_again,\n 'sid': self.sid,\n 'taken_for_credit': self.taken_for_credit,\n 'teacher': self.teacher,\n 'teacher_grade': self.teacher_grade,\n 'teacher_rating_tags': self.teacher_rating_tags,\n 'unuseful_grouping': self.unuseful_grouping,\n 'useful_grouping': self.useful_grouping}","def __repr__(self):\r\n\r\n return f\"<User info: id = {self.user_id}, name = {self.fname} {self.lname} email = {self.email}>\"","def __str__(self):\n return str(self.user)","def __str__(self):\n return str(self.user)","def __str__(self):\n return str(self.user)","def __str__(self):\n return str(self.user)","def __str__(self):\n return str(self.user)","def __str__(self):\n return \"student:\"+str(self.name)+\":\"+str(self.age)+\":\"+str(self.major)","def __str__(self):\r\n return str(self.user)","def modifyClassroom(classroomId, classroomName, capacity,location):\n for classroom in classroomEntities:\n if classroom[\"classroomId\"] == classroomId:\n selectedClassroom = classroom\n selectedClassroom[\"classroomName\"] = classroomName\n selectedClassroom[\"capacity\"] = capacity\n selectedClassroom[\"location\"] = location\n return True\n return False","def to_str(self) -> str:\n private = self.privacy == 1\n owners: List[str] = []\n for o in self.owners:\n user = self.bot.get_user(o)\n owners.append(user.name if user else \"Unknown user\")\n return f\"Wormhole: {self.name}\\n┗━▷ Private: {private} - Admins: {', '.join(owners)} - **{self.channels}** Discord channels are linked\"","def __repr__(self):\n\n\t\treturn f\"<Venue id={self.venue_id} city={self.city} name={self.city} country={self.country_code} description={self.description} status={self.status} length={self.length} turns={self.turns} latitude={self.latitude} longitude={self.longitude} maplink = {self.maplink}>\"","def richContestants():\n return prepJSON(cs411_dash.richContestants())","def __repr__(self):\n\n\t\treturn \"<Competitor id={} name={} gender={} nationality={} vehicle_number={} team={} result={}\".format(\n\t\t\tself.competitor_id, self.name, self.gender, self.country_code, self.vehicle_number, self.team, self.result)","def __repr__(self):\r\n return {'name':self.name, 'weight':self.organ_weight_grams, 'vital organ': self.vital_organ, 'organ system': self.organ_system}","def __str__(self):\n\t\t\n\t\tstring = \"{Jokers: \"\n\t\tfor card in self.jokers:\n\t\t\tstring += str(card)+\", \"\n\n\t\tstring += \"}\"\n\n\t\tfor i in range(len(self.grps)):\n\t\t\tstring += \", {group \"+str(i+1)+\": \"\n\t\t\tfor card in self.grps[i]:\n\t\t\t\tstring += str(card)+\", \"\n\t\t\tstring += \"}\"\n\t\treturn string","def test_user_enrolled_to_classroom(self):\n self.client.force_authenticate(self.global_user_1)\n data = self.client.get(self.api_classroom_detail_url, {'user': 'current'}).data\n\n self.assertTrue(data.get('enrolled'))","def __str__(self):\n profile = {\n 'address': self.address,\n 'bio': self.bio,\n 'website': self.website,\n 'hireable': self.hireable,\n 'travel_radius': self.travel_radius,\n 'phone number': self.phone_number,\n 'camera type': self.camera_type,\n 'type of photography': self.photography_type\n }\n return str(self.user.username)","def __str__(self):\r\n return str(self.userid)","def __str__(self):\n return self.user","def __str__(self):\n return \"cat:\"+str(self.name)+\":\"+str(self.age)","def __repr__(self):\r\n return \"Lesson(id='%i', courseName='%s', teachers='%s', semester_groups='%s')\" % \\\r\n (self.id, self.course.name,\r\n str(list(map(lambda t: t.id, self.teachers))),\r\n str(list(map(lambda s: s.id, self.course.semester_groups))))","def __str__(self):\r\n return f'{self.user}'","def __str__(self):\r\n return f'{self.user}'","def __str__(self):\r\n return f'{self.user}'","def __str__(self):\r\n return f'{self.user}'","def __str__(self):\n description = \"Object class Critter.\"\n description += \"\\nName: \" + self.name + \"\\nMood: \" + self.mood + \"\\nHunger: \" + str(self.hunger) + \"\\nBoredom: \" + str(self.boredom) + \"\\n\"\n return description","def get_joint_secy(self, obj):\n serializer = UserProfileSerializer(obj.joint_secy, many=True)\n return serializer.data","def __str__(self):\n return self.specialty","def __str__(self):\n return \"%s %s\" % (self.course.code, self.code)","def stringify(cls, relationship):\n\n\t\tif relationship == cls.STUDENT:\n\t\t\treturn \"STUDENT\"\n\t\tif relationship == cls.TEACHER:\n\t\t\treturn \"TEACHER\"\n\t\tif relationship == cls.BOTH:\n\t\t\treturn \"BOTH\"\n\t\treturn \"ERROR\"","def to_string(self):\n if self.new_owner == self.user:\n output = u'%s unorphaned : %s [%s]' % (\n self.user.ljust(15), self.name, ','.join(sorted(self.branch)))\n elif self.new_owner == 'orphan':\n output = u'%s [%s] was orphaned by %s' % (\n self.name, ','.join(sorted(self.branch)), self.user)\n elif self.new_owner == 'retired':\n output = u'%s [%s] was retired by %s' % (\n self.name, ','.join(sorted(self.branch)), self.user)\n else:\n output = u'%s gave to %s : %s [%s]' % (\n self.user.ljust(15), self.new_owner.ljust(15),\n self.name, ','.join(sorted(self.branch)))\n return output","def get_room_type(self):\n\t\troom_type = ''\n\t\tnum = randint(1,8)\n\n\t\tif num >= 1 and num <= 4:\n\t\t\troom_type = 'Empty'\n\t\telif num >= 5 and num <= 7:\n\t\t\troom_type = 'Monster'\n\t\telif num == 8:\n\t\t\troom_type = 'Treasure'\n\t\t\n\t\treturn room_type","def __repr__(self):\n return f'<RestaurantCourier restaurant: {self.restaurant_id} courier: {self.courier_id}>'","def _get_pretty_campus(self, raw_campus):\n campus_dict = {\n 'cascadescampus': 'Cascades',\n 'osucorvallis': 'Corvallis',\n 'hmsc': 'HMSC'\n }\n campus = None\n raw_campus = raw_campus.lower()\n if raw_campus in campus_dict:\n campus = campus_dict[raw_campus]\n elif raw_campus:\n campus = 'Other'\n\n return campus","def get_room_str(room):\n name = room.name\n if room.db.x_coord is not None and room.db.y_coord is not None:\n pos = (room.db.x_coord, room.db.y_coord)\n name = \"%s %s\" % (name, str(pos))\n return name","def serialize(self):\n\t\treturn {\n\t\t\t\"approver_id\": self.approver_id,\n\t\t\t\"room_id\": self.room_id,\n\t\t\t\"priority\": self.priority\n\t\t}","def __str__(self):\n return self.name + ' - ' + str(self.date_of_contact) + ' - ' + str(self.specialty)","def room_type(self):\n return self._room_type","def room_type(self):\n return self._room_type","def __str__(self):\n return_string = self.name + \"\\n\" + str(self.traits)\n\n return return_string","def serialize(self):\n return {\n \"first_name\" : self.first_name.capitalize(),\n \"last_name\" : self.last_name.capitalize(),\n \"name\" : self.first_name.capitalize() + ' ' + self.last_name.capitalize(),\n \"user_id\" : self.id,\n }","def __str__(self):\n return f'{self.mission} {self.category}: {self.title} / {self.created_at}'","def serialize(self):\n return {\n 'user_id' : self.user_id,\n 'conference_id' : self.conference_id,\n }","def serialize(self):\n return {\n 'user_id': self.user_id,\n 'id': self.id,\n 'meal_type': self.meal_type,\n 'location_string': self.location_string,\n 'meal_time': self.meal_time,\n 'filled': self.filled\n }","def to_representation(self, value):\n model = apps.get_model(getattr(settings, 'AUTH_USER_MODEL'))\n try:\n return str(model.objects.get(id=value.id))\n except ObjectDoesNotExist:\n raise Exception('User Id: {0} not found!'.format(value.id))","def __str__(self):\r\n hobby_string = \"Hobby Name: \" + self.__name\r\n hobby_string += \"\\n Cover Photo: \" + self.__cover_photo\r\n hobby_string += \"\\n Projects: \\n\" + list_str_breaks(self.__projects)\r\n\r\n return hobby_string","def __str__(self):\r\n to_string = \"ID: \" + str(self.dat_id) + \" --- CLASSIFICATION: \" + str(self.dat_party) + \" --- VOTED: \" + str(self.dat_votes)\r\n return to_string","def get_gensec(self, obj):\n if obj.gensec is None:\n return None\n serializer = UserProfileSerializer(obj.gensec)\n return serializer.data","def get_meeting_room_name(self, obj):\n return obj.meeting_room.name","def __str__(self):\n return str(self.__student_name) + \" has grade \" + str(self.__grade_value) + \" at \" + str(self.__discipline_name)","async def roominfo(self, ctx: Message):\n\t\tawait self.send(\n\t\t f\"Name: {self.room.name} • Description: {self.room.description} • ID: {self.room.id} • Member Count: {self.room.count} • Created at: {self.room.created_at} • Is Private?: {self.room.is_private}\"\n\t\t)","def __repr__(self):\n\n u = self\n return f\"<User {u.id} {u.first_name} {u.last_name} {u.image_url}>\"","def __str__(self):\n return \"CLA obj [\" + self.marathonURL + \", \" + self.appid + \", \" + str(self.totalports) + \"]\"","def __str__(self):\n return self.user.get_full_name()","def __repr__(self):\n\n return f'<User user_id={self.user_id} name={self.name}\\\n email ={self.email} user_password={self.password} phone_num={self.phone_num}>'","def __str__(self):\n return \"%s %s %s %s\" % (self.assignment.course.code, self.assignment.code, self.student.username, self.sub_date)","def get_classification(self):\n try:\n receiver = self.cleaned_data[\"customer\"]\n classification = self.CLASSIFICATION_DICT[receiver]\n except KeyError:\n return \"------\"\n except AttributeError:\n return \"------\"\n\n return classification","def to_string(self):\n return \"User: {} Description: {} Ratings: {}\".format(self.id_user, self.description, self.ratings)","def __str__(self):\n return self.make_flat()","def __repr__(self):\n u = self\n return f\"<User id={u.id}, first_name={u.first_name}, last_name={u.last_name}, image_url={u.image_url}>\"","def _parse_classification(self, meeting_type):\n if 'committee' in meeting_type:\n return COMMITTEE\n elif 'board' in meeting_type:\n return BOARD\n return NOT_CLASSIFIED","def __str__(self) -> str:\n\n return self.user.get_full_name()","def __repr__(self):\n\n return \"<Instructor instructor_id=%s name=%s>\" % (self.instructor_id, self.name)","def __repr__(self):\n\n return \"<Rider id={}, ride_id={}, user_id={}>\".format(self.id, \n self.ride_id, self.user_id)","def __str__(self):\n return str(self.user_id) + \": \" + \\\n str(self.user_name) + \": \" + str(self.user_email)","def getRole(self, desired=None):\n return {\"roleName\":\"hasici\",\n \"roleTitle\":\"Soptici\"}","def __str__(self):\n return self.skill","def __repr__(self):\r\n return {'name':self.name, 'weight':self.organ_weight_grams, 'vital organ': self.vital_organ, 'organ system': self.organ_system, 'heart thickness': self.heart_thickness_cm, 'heart breadth': self.heart_breadth_cm, \"heart length\": self.heart_length_cm}","def __str__(self):\n return self.user.username + \"'s Profile\"","def get_serializer_class(self):\n profile = self.get_object()\n\n # Owner of the profile\n if self.request.user == profile.user:\n if profile.filled_out or self.request.data.get('filled_out'):\n return self.serializer_class_filled_out\n else:\n return self.serializer_class_owner\n # Staff or instructor is looking at profile\n elif not self.request.user.is_anonymous and self.request.user.role_set.filter(\n role__in=(Staff.ROLE_ID, Instructor.ROLE_ID),\n program__programenrollment__user__profile=profile,\n ).exists():\n return self.serializer_class_staff\n # Profile is public\n elif profile.account_privacy == Profile.PUBLIC:\n return self.serializer_class_limited\n # Profile is public to mm verified users only\n elif profile.account_privacy == Profile.PUBLIC_TO_MM:\n return self.serializer_class_limited\n # this should never happen, but just in case\n return self.serializer_class_limited","def __repr__(self):\n\n return f\"\"\"<User user_id={self.user_id} fname={self.fname}\n lname={self.lname} email={self.email} phone={self.phone}\n password={self.password}>\"\"\"","def see_associated_classes(self, username: str, token: str) -> List[Dict[str, object]]:\n\n # Validate user first\n if not self.validate(username=username, token=token, check_privilege='student'):\n raise RuntimeError(\"User not verified!\")\n\n # Get UID from user's username\n uid = self.get_uid(username=username)\n\n # Query database for courses associated with this UID\n cursor = self._db_connection.cursor()\n cursor.execute(\n '''\n SELECT \n courses.course_id,\n courses.course_abbreviation,\n courses.course_name,\n courses.instructor_id, \n courses.time,\n courses.seats \n FROM \n courses \n INNER JOIN \n enrollment_records \n ON \n courses.course_id = enrollment_records.course_id \n WHERE \n enrollment_records.uid = ?\n ;\n ''', (uid,))\n\n db_results = cursor.fetchall()\n\n if db_results is None:\n print(\"No associated courses found!\")\n return []\n\n # Build information dicts for every course this user is enrolled in\n courses = []\n for result in db_results:\n # Get the instructor's username (we don't want to be giving UIDs)\n instructor_name = self.get_username(result[3])\n\n # Get the number of students enrolled in this course already\n cursor.execute('''SELECT COUNT(*) FROM enrollment_records WHERE course_id = ?;''', (result[0],))\n students_enrolled = cursor.fetchone()[0]\n if students_enrolled is None:\n students_enrolled = 0\n\n # Build a course dict from the data\n courses.append({\n \"course_abbreviation\": result[1],\n \"course_name\": result[2],\n \"instructor\": instructor_name,\n \"time\": result[4],\n \"students_enrolled\": students_enrolled,\n \"capacity\": result[5],\n })\n\n return courses","def __str__(self):\n # Use 'Unknown' if the course instance does not have a term\n if self.course_instance.term:\n term = self.course_instance.term.verbose_name()\n else:\n term = 'Unknown'\n\n exam_unicode = '{term} {number} {type} for {course}'.format(\n term=term,\n number=self.get_exam_number_display(),\n type=self.get_exam_type_display(),\n course=self.course_instance.course)\n if self.instructors:\n instructors = ', '.join([i.last_name for i in self.instructors])\n return '{}, taught by {}'.format(exam_unicode, instructors)\n else:\n return '{} (Instructors Unknown)'.format(exam_unicode)","def __str__(self):\n\t\treturn self.full_name"],"string":"[\n \"def __repr__(self):\\n return \\\"Classroom('{}', {}, {})\\\".format(self.number, self.capacity,\\n str(self.equipment))\",\n \"def __str__(self):\\n return self.room_name\",\n \"def __str__(self):\\n return self.room.name\",\n \"def json(self):\\n return {'name': self.neighbourhood_group, 'neighbourhood': self.room_type}\",\n \"def __repr__(self):\\n return f'ResidenciaModel(name={self.neighbourhood_group}, neighbourhood={self.room_type})'\",\n \"def format_room(room):\\n new = {}\\n new[\\\"name\\\"] = \\\"Room\\\"\\n new[\\\"info\\\"] = {}\\n for key in room:\\n if key != \\\"containedSpaces\\\" and key != \\\"topLevelSpace\\\" and key != \\\"parentSpace\\\" and key != 'description' and key != 'id' and key!= 'type':\\n new[\\\"info\\\"][key] = room[key]\\n return new\",\n \"def get_print_room_data(self, room):\\n habitants = self.all_rooms[room]['occupants']\\n\\n return {'room': room, 'names': habitants}\",\n \"def __str__(self):\\n fields = []\\n try:\\n walls = self._walls\\n if walls != 0:\\n field = \\\"walls=\\\"\\n if walls & Direction.North:\\n field += \\\"N\\\"\\n if walls & Direction.South:\\n field += \\\"S\\\"\\n if walls & Direction.East:\\n field += \\\"E\\\"\\n if walls & Direction.West:\\n field += \\\"W\\\"\\n fields.append(field)\\n except Exception:\\n pass\\n try:\\n egress = self._egress\\n if egress:\\n fields.append(\\\"egress=\\\" + str(egress))\\n except Exception:\\n pass\\n try:\\n distance = self._distance\\n if distance:\\n fields.append(\\\"distance=\\\" + str(distance))\\n except Exception:\\n pass\\n try:\\n self._check()\\n except Exception as excp:\\n fields.append(\\\"error=\\\" + repr(excp))\\n result = \\\"Room(\\\" + \\\", \\\".join(fields) + \\\")\\\"\\n return result\",\n \"def addClassroom(classroomName, capacity,location):\\n for classroom in classroomEntities:\\n if classroom[\\\"classroomName\\\"] == classroomName:\\n print(\\\"Two classrooms can not have same name\\\")\\n return False\\n\\n if classroomEntities==[]:\\n lastSavedIdNumber = \\\"0\\\"\\n else:\\n lastSavedId=classroomEntities[-1][\\\"classroomId\\\"] #update classroomId as first element in classroomEntities list\\n lastSavedIdNumber=lastSavedId[2:]\\n numberOfDigitsInID = 3\\n if lastSavedIdNumber == \\\"9\\\" * len(lastSavedIdNumber):\\n numberOfDigitsInID = len(lastSavedIdNumber) + 1\\n classroomId=\\\"CR\\\"+str(int(lastSavedIdNumber)+1).rjust(numberOfDigitsInID,\\\"0\\\")\\n\\n # add the new Classroom\\n newClassroom = {}\\n newClassroom[\\\"classroomId\\\"] = classroomId\\n newClassroom[\\\"classroomName\\\"] = classroomName\\n newClassroom[\\\"capacity\\\"] = capacity\\n newClassroom[\\\"location\\\"] = location\\n classroomEntities.append(newClassroom)\\n print(f\\\"Class Room is added into the system, Class Room id is {classroomId}.\\\")\\n return True\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'owner' : self.user.name,\\n 'room' : self.room.name,\\n 'description' : self.description,\\n 'price' : self.price,\\n }\",\n \"def helpClassroom(classroomId):\\n selectedClassroomCopy = getClassroomById(classroomId)\\n print(\\\"Class Id: \\\" + selectedClassroomCopy[\\\"classroomId\\\"])\\n print(\\\"Name: \\\" + selectedClassroomCopy[\\\"classroomName\\\"])\\n print(\\\"Capacity: \\\" + selectedClassroomCopy[\\\"capacity\\\"])\\n print(\\\"Location: \\\" + selectedClassroomCopy[\\\"location\\\"])\\n return True\",\n \"def __str__(self):\\n return self.nivel_participacao\",\n \"def getClassroomById(classroomId):\\n for classroom in classroomEntities:\\n if classroom[\\\"classroomId\\\"] == classroomId:\\n return classroom.copy()\\n return None\",\n \"def __str__(self):\\n return '{0}: {1} \\\"{2}\\\" {3}'.format(\\n self.race, self.name, self.nick, self.surname)\",\n \"def us_citizen(self, instance):\\r\\n return instance.user.profile.us_citizen\",\n \"def retrieve_google_classroom_data(request, sociallogin, **kwargs):\\n # updates user's extra data\\n user = User.objects.get(pk=request.user.id)\\n user.name = sociallogin.account.extra_data['name']\\n user.avatar = sociallogin.account.extra_data['picture']\\n user.save()\\n\\n # get the user's authorization token\\n token = SocialToken.objects.filter(account__user=request.user, account__provider='google')[0].token\\n\\n save_courses(user, token)\",\n \"def to_representation(self, instance):\\n\\n return instance.courier_type\",\n \"def serialize(self):\\n return {\\n \\\"grade\\\": self.grade,\\n \\\"student\\\": {\\n \\\"id\\\": self.student_id,\\n \\\"fname\\\": self.student.fname,\\n \\\"lname\\\": self.student.lname,\\n \\\"dob\\\": self.student.dob,\\n \\\"grad_year\\\": self.student.grad_year,\\n \\\"gpa\\\": self.student.gpa,\\n \\\"occupation\\\": self.student.occupation.serialize\\n },\\n \\\"course\\\": {\\n \\\"id\\\": self.course_id,\\n \\\"course_name\\\": self.course.course_name,\\n \\\"field\\\": self.course.field.serialize,\\n \\\"faculty\\\": self.course.faculty.serialize,\\n \\\"semester\\\": self.course.semester.serialize\\n }\\n }\",\n \"def test_user_only_sees_own_classroom_state(self):\\n self.client.force_authenticate(self.global_user_1)\\n data = self.client.get(self.api_classroom_detail_url, {'user': 'current'}).data\\n self.assertTrue(data.get('enrolled'))\\n\\n not_enrolled_user = get_user_model().objects.annotate(\\n classrooms_count=Count('classrooms_states'),\\n ).filter(classrooms_count=0)[0]\\n self.client.force_authenticate(not_enrolled_user)\\n data = self.client.get(self.api_classroom_detail_url, {'user': 'current'}).data\\n self.assertFalse(data.get('enrolled'))\",\n \"def to_string(self):\\n return \\\"{base_msg} Courses: {courses}\\\".format(\\n base_msg=super().to_string(),\\n courses=self.courses_string()\\n )\",\n \"def __str__(self):\\n return f\\\"{self.semester} | {self.school} | {self.position} | {self.class_name}\\\"\",\n \"def get_joint_gensec(self, obj):\\n serializer = UserProfileSerializer(obj.joint_gensec, many=True)\\n return serializer.data\",\n \"def __str__(self):\\n return self.meeting_type\",\n \"def __str__(self):\\n print(\\\"Welcome to our house\\\")\\n for room in self.rooms:\\n print(room.name, room.sqr_ft)\",\n \"def __repr__(self):\\n return f\\\"<Tutor {self.first_name.title()} {self.last_name.title()}>\\\"\",\n \"def serialize(self):\\n return {'professor_id': self.professor_id,\\n 'attendance': self.attendance,\\n 'clarity_color': self.clarity_color,\\n 'easy_color': self.easy_color,\\n 'help_color': self.help_color,\\n 'help_count': self.help_count,\\n 'not_help_count': self.not_help_count,\\n 'online_class': self.online_class,\\n 'quality': self.quality,\\n 'clarity': self.clarity,\\n 'course': self.course,\\n 'comments': self.comments,\\n 'date': self.date,\\n 'easy': self.easy,\\n 'easy_string': self.easy_string,\\n 'helpful': self.helpful,\\n 'interest': self.interest,\\n 'overall': self.overall,\\n 'overall_string': self.overall_string,\\n 'status': self.status,\\n 'text_book_use': self.text_book_use,\\n 'would_take_again': self.would_take_again,\\n 'sid': self.sid,\\n 'taken_for_credit': self.taken_for_credit,\\n 'teacher': self.teacher,\\n 'teacher_grade': self.teacher_grade,\\n 'teacher_rating_tags': self.teacher_rating_tags,\\n 'unuseful_grouping': self.unuseful_grouping,\\n 'useful_grouping': self.useful_grouping}\",\n \"def __repr__(self):\\r\\n\\r\\n return f\\\"<User info: id = {self.user_id}, name = {self.fname} {self.lname} email = {self.email}>\\\"\",\n \"def __str__(self):\\n return str(self.user)\",\n \"def __str__(self):\\n return str(self.user)\",\n \"def __str__(self):\\n return str(self.user)\",\n \"def __str__(self):\\n return str(self.user)\",\n \"def __str__(self):\\n return str(self.user)\",\n \"def __str__(self):\\n return \\\"student:\\\"+str(self.name)+\\\":\\\"+str(self.age)+\\\":\\\"+str(self.major)\",\n \"def __str__(self):\\r\\n return str(self.user)\",\n \"def modifyClassroom(classroomId, classroomName, capacity,location):\\n for classroom in classroomEntities:\\n if classroom[\\\"classroomId\\\"] == classroomId:\\n selectedClassroom = classroom\\n selectedClassroom[\\\"classroomName\\\"] = classroomName\\n selectedClassroom[\\\"capacity\\\"] = capacity\\n selectedClassroom[\\\"location\\\"] = location\\n return True\\n return False\",\n \"def to_str(self) -> str:\\n private = self.privacy == 1\\n owners: List[str] = []\\n for o in self.owners:\\n user = self.bot.get_user(o)\\n owners.append(user.name if user else \\\"Unknown user\\\")\\n return f\\\"Wormhole: {self.name}\\\\n┗━▷ Private: {private} - Admins: {', '.join(owners)} - **{self.channels}** Discord channels are linked\\\"\",\n \"def __repr__(self):\\n\\n\\t\\treturn f\\\"<Venue id={self.venue_id} city={self.city} name={self.city} country={self.country_code} description={self.description} status={self.status} length={self.length} turns={self.turns} latitude={self.latitude} longitude={self.longitude} maplink = {self.maplink}>\\\"\",\n \"def richContestants():\\n return prepJSON(cs411_dash.richContestants())\",\n \"def __repr__(self):\\n\\n\\t\\treturn \\\"<Competitor id={} name={} gender={} nationality={} vehicle_number={} team={} result={}\\\".format(\\n\\t\\t\\tself.competitor_id, self.name, self.gender, self.country_code, self.vehicle_number, self.team, self.result)\",\n \"def __repr__(self):\\r\\n return {'name':self.name, 'weight':self.organ_weight_grams, 'vital organ': self.vital_organ, 'organ system': self.organ_system}\",\n \"def __str__(self):\\n\\t\\t\\n\\t\\tstring = \\\"{Jokers: \\\"\\n\\t\\tfor card in self.jokers:\\n\\t\\t\\tstring += str(card)+\\\", \\\"\\n\\n\\t\\tstring += \\\"}\\\"\\n\\n\\t\\tfor i in range(len(self.grps)):\\n\\t\\t\\tstring += \\\", {group \\\"+str(i+1)+\\\": \\\"\\n\\t\\t\\tfor card in self.grps[i]:\\n\\t\\t\\t\\tstring += str(card)+\\\", \\\"\\n\\t\\t\\tstring += \\\"}\\\"\\n\\t\\treturn string\",\n \"def test_user_enrolled_to_classroom(self):\\n self.client.force_authenticate(self.global_user_1)\\n data = self.client.get(self.api_classroom_detail_url, {'user': 'current'}).data\\n\\n self.assertTrue(data.get('enrolled'))\",\n \"def __str__(self):\\n profile = {\\n 'address': self.address,\\n 'bio': self.bio,\\n 'website': self.website,\\n 'hireable': self.hireable,\\n 'travel_radius': self.travel_radius,\\n 'phone number': self.phone_number,\\n 'camera type': self.camera_type,\\n 'type of photography': self.photography_type\\n }\\n return str(self.user.username)\",\n \"def __str__(self):\\r\\n return str(self.userid)\",\n \"def __str__(self):\\n return self.user\",\n \"def __str__(self):\\n return \\\"cat:\\\"+str(self.name)+\\\":\\\"+str(self.age)\",\n \"def __repr__(self):\\r\\n return \\\"Lesson(id='%i', courseName='%s', teachers='%s', semester_groups='%s')\\\" % \\\\\\r\\n (self.id, self.course.name,\\r\\n str(list(map(lambda t: t.id, self.teachers))),\\r\\n str(list(map(lambda s: s.id, self.course.semester_groups))))\",\n \"def __str__(self):\\r\\n return f'{self.user}'\",\n \"def __str__(self):\\r\\n return f'{self.user}'\",\n \"def __str__(self):\\r\\n return f'{self.user}'\",\n \"def __str__(self):\\r\\n return f'{self.user}'\",\n \"def __str__(self):\\n description = \\\"Object class Critter.\\\"\\n description += \\\"\\\\nName: \\\" + self.name + \\\"\\\\nMood: \\\" + self.mood + \\\"\\\\nHunger: \\\" + str(self.hunger) + \\\"\\\\nBoredom: \\\" + str(self.boredom) + \\\"\\\\n\\\"\\n return description\",\n \"def get_joint_secy(self, obj):\\n serializer = UserProfileSerializer(obj.joint_secy, many=True)\\n return serializer.data\",\n \"def __str__(self):\\n return self.specialty\",\n \"def __str__(self):\\n return \\\"%s %s\\\" % (self.course.code, self.code)\",\n \"def stringify(cls, relationship):\\n\\n\\t\\tif relationship == cls.STUDENT:\\n\\t\\t\\treturn \\\"STUDENT\\\"\\n\\t\\tif relationship == cls.TEACHER:\\n\\t\\t\\treturn \\\"TEACHER\\\"\\n\\t\\tif relationship == cls.BOTH:\\n\\t\\t\\treturn \\\"BOTH\\\"\\n\\t\\treturn \\\"ERROR\\\"\",\n \"def to_string(self):\\n if self.new_owner == self.user:\\n output = u'%s unorphaned : %s [%s]' % (\\n self.user.ljust(15), self.name, ','.join(sorted(self.branch)))\\n elif self.new_owner == 'orphan':\\n output = u'%s [%s] was orphaned by %s' % (\\n self.name, ','.join(sorted(self.branch)), self.user)\\n elif self.new_owner == 'retired':\\n output = u'%s [%s] was retired by %s' % (\\n self.name, ','.join(sorted(self.branch)), self.user)\\n else:\\n output = u'%s gave to %s : %s [%s]' % (\\n self.user.ljust(15), self.new_owner.ljust(15),\\n self.name, ','.join(sorted(self.branch)))\\n return output\",\n \"def get_room_type(self):\\n\\t\\troom_type = ''\\n\\t\\tnum = randint(1,8)\\n\\n\\t\\tif num >= 1 and num <= 4:\\n\\t\\t\\troom_type = 'Empty'\\n\\t\\telif num >= 5 and num <= 7:\\n\\t\\t\\troom_type = 'Monster'\\n\\t\\telif num == 8:\\n\\t\\t\\troom_type = 'Treasure'\\n\\t\\t\\n\\t\\treturn room_type\",\n \"def __repr__(self):\\n return f'<RestaurantCourier restaurant: {self.restaurant_id} courier: {self.courier_id}>'\",\n \"def _get_pretty_campus(self, raw_campus):\\n campus_dict = {\\n 'cascadescampus': 'Cascades',\\n 'osucorvallis': 'Corvallis',\\n 'hmsc': 'HMSC'\\n }\\n campus = None\\n raw_campus = raw_campus.lower()\\n if raw_campus in campus_dict:\\n campus = campus_dict[raw_campus]\\n elif raw_campus:\\n campus = 'Other'\\n\\n return campus\",\n \"def get_room_str(room):\\n name = room.name\\n if room.db.x_coord is not None and room.db.y_coord is not None:\\n pos = (room.db.x_coord, room.db.y_coord)\\n name = \\\"%s %s\\\" % (name, str(pos))\\n return name\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t\\\"approver_id\\\": self.approver_id,\\n\\t\\t\\t\\\"room_id\\\": self.room_id,\\n\\t\\t\\t\\\"priority\\\": self.priority\\n\\t\\t}\",\n \"def __str__(self):\\n return self.name + ' - ' + str(self.date_of_contact) + ' - ' + str(self.specialty)\",\n \"def room_type(self):\\n return self._room_type\",\n \"def room_type(self):\\n return self._room_type\",\n \"def __str__(self):\\n return_string = self.name + \\\"\\\\n\\\" + str(self.traits)\\n\\n return return_string\",\n \"def serialize(self):\\n return {\\n \\\"first_name\\\" : self.first_name.capitalize(),\\n \\\"last_name\\\" : self.last_name.capitalize(),\\n \\\"name\\\" : self.first_name.capitalize() + ' ' + self.last_name.capitalize(),\\n \\\"user_id\\\" : self.id,\\n }\",\n \"def __str__(self):\\n return f'{self.mission} {self.category}: {self.title} / {self.created_at}'\",\n \"def serialize(self):\\n return {\\n 'user_id' : self.user_id,\\n 'conference_id' : self.conference_id,\\n }\",\n \"def serialize(self):\\n return {\\n 'user_id': self.user_id,\\n 'id': self.id,\\n 'meal_type': self.meal_type,\\n 'location_string': self.location_string,\\n 'meal_time': self.meal_time,\\n 'filled': self.filled\\n }\",\n \"def to_representation(self, value):\\n model = apps.get_model(getattr(settings, 'AUTH_USER_MODEL'))\\n try:\\n return str(model.objects.get(id=value.id))\\n except ObjectDoesNotExist:\\n raise Exception('User Id: {0} not found!'.format(value.id))\",\n \"def __str__(self):\\r\\n hobby_string = \\\"Hobby Name: \\\" + self.__name\\r\\n hobby_string += \\\"\\\\n Cover Photo: \\\" + self.__cover_photo\\r\\n hobby_string += \\\"\\\\n Projects: \\\\n\\\" + list_str_breaks(self.__projects)\\r\\n\\r\\n return hobby_string\",\n \"def __str__(self):\\r\\n to_string = \\\"ID: \\\" + str(self.dat_id) + \\\" --- CLASSIFICATION: \\\" + str(self.dat_party) + \\\" --- VOTED: \\\" + str(self.dat_votes)\\r\\n return to_string\",\n \"def get_gensec(self, obj):\\n if obj.gensec is None:\\n return None\\n serializer = UserProfileSerializer(obj.gensec)\\n return serializer.data\",\n \"def get_meeting_room_name(self, obj):\\n return obj.meeting_room.name\",\n \"def __str__(self):\\n return str(self.__student_name) + \\\" has grade \\\" + str(self.__grade_value) + \\\" at \\\" + str(self.__discipline_name)\",\n \"async def roominfo(self, ctx: Message):\\n\\t\\tawait self.send(\\n\\t\\t f\\\"Name: {self.room.name} • Description: {self.room.description} • ID: {self.room.id} • Member Count: {self.room.count} • Created at: {self.room.created_at} • Is Private?: {self.room.is_private}\\\"\\n\\t\\t)\",\n \"def __repr__(self):\\n\\n u = self\\n return f\\\"<User {u.id} {u.first_name} {u.last_name} {u.image_url}>\\\"\",\n \"def __str__(self):\\n return \\\"CLA obj [\\\" + self.marathonURL + \\\", \\\" + self.appid + \\\", \\\" + str(self.totalports) + \\\"]\\\"\",\n \"def __str__(self):\\n return self.user.get_full_name()\",\n \"def __repr__(self):\\n\\n return f'<User user_id={self.user_id} name={self.name}\\\\\\n email ={self.email} user_password={self.password} phone_num={self.phone_num}>'\",\n \"def __str__(self):\\n return \\\"%s %s %s %s\\\" % (self.assignment.course.code, self.assignment.code, self.student.username, self.sub_date)\",\n \"def get_classification(self):\\n try:\\n receiver = self.cleaned_data[\\\"customer\\\"]\\n classification = self.CLASSIFICATION_DICT[receiver]\\n except KeyError:\\n return \\\"------\\\"\\n except AttributeError:\\n return \\\"------\\\"\\n\\n return classification\",\n \"def to_string(self):\\n return \\\"User: {} Description: {} Ratings: {}\\\".format(self.id_user, self.description, self.ratings)\",\n \"def __str__(self):\\n return self.make_flat()\",\n \"def __repr__(self):\\n u = self\\n return f\\\"<User id={u.id}, first_name={u.first_name}, last_name={u.last_name}, image_url={u.image_url}>\\\"\",\n \"def _parse_classification(self, meeting_type):\\n if 'committee' in meeting_type:\\n return COMMITTEE\\n elif 'board' in meeting_type:\\n return BOARD\\n return NOT_CLASSIFIED\",\n \"def __str__(self) -> str:\\n\\n return self.user.get_full_name()\",\n \"def __repr__(self):\\n\\n return \\\"<Instructor instructor_id=%s name=%s>\\\" % (self.instructor_id, self.name)\",\n \"def __repr__(self):\\n\\n return \\\"<Rider id={}, ride_id={}, user_id={}>\\\".format(self.id, \\n self.ride_id, self.user_id)\",\n \"def __str__(self):\\n return str(self.user_id) + \\\": \\\" + \\\\\\n str(self.user_name) + \\\": \\\" + str(self.user_email)\",\n \"def getRole(self, desired=None):\\n return {\\\"roleName\\\":\\\"hasici\\\",\\n \\\"roleTitle\\\":\\\"Soptici\\\"}\",\n \"def __str__(self):\\n return self.skill\",\n \"def __repr__(self):\\r\\n return {'name':self.name, 'weight':self.organ_weight_grams, 'vital organ': self.vital_organ, 'organ system': self.organ_system, 'heart thickness': self.heart_thickness_cm, 'heart breadth': self.heart_breadth_cm, \\\"heart length\\\": self.heart_length_cm}\",\n \"def __str__(self):\\n return self.user.username + \\\"'s Profile\\\"\",\n \"def get_serializer_class(self):\\n profile = self.get_object()\\n\\n # Owner of the profile\\n if self.request.user == profile.user:\\n if profile.filled_out or self.request.data.get('filled_out'):\\n return self.serializer_class_filled_out\\n else:\\n return self.serializer_class_owner\\n # Staff or instructor is looking at profile\\n elif not self.request.user.is_anonymous and self.request.user.role_set.filter(\\n role__in=(Staff.ROLE_ID, Instructor.ROLE_ID),\\n program__programenrollment__user__profile=profile,\\n ).exists():\\n return self.serializer_class_staff\\n # Profile is public\\n elif profile.account_privacy == Profile.PUBLIC:\\n return self.serializer_class_limited\\n # Profile is public to mm verified users only\\n elif profile.account_privacy == Profile.PUBLIC_TO_MM:\\n return self.serializer_class_limited\\n # this should never happen, but just in case\\n return self.serializer_class_limited\",\n \"def __repr__(self):\\n\\n return f\\\"\\\"\\\"<User user_id={self.user_id} fname={self.fname}\\n lname={self.lname} email={self.email} phone={self.phone}\\n password={self.password}>\\\"\\\"\\\"\",\n \"def see_associated_classes(self, username: str, token: str) -> List[Dict[str, object]]:\\n\\n # Validate user first\\n if not self.validate(username=username, token=token, check_privilege='student'):\\n raise RuntimeError(\\\"User not verified!\\\")\\n\\n # Get UID from user's username\\n uid = self.get_uid(username=username)\\n\\n # Query database for courses associated with this UID\\n cursor = self._db_connection.cursor()\\n cursor.execute(\\n '''\\n SELECT \\n courses.course_id,\\n courses.course_abbreviation,\\n courses.course_name,\\n courses.instructor_id, \\n courses.time,\\n courses.seats \\n FROM \\n courses \\n INNER JOIN \\n enrollment_records \\n ON \\n courses.course_id = enrollment_records.course_id \\n WHERE \\n enrollment_records.uid = ?\\n ;\\n ''', (uid,))\\n\\n db_results = cursor.fetchall()\\n\\n if db_results is None:\\n print(\\\"No associated courses found!\\\")\\n return []\\n\\n # Build information dicts for every course this user is enrolled in\\n courses = []\\n for result in db_results:\\n # Get the instructor's username (we don't want to be giving UIDs)\\n instructor_name = self.get_username(result[3])\\n\\n # Get the number of students enrolled in this course already\\n cursor.execute('''SELECT COUNT(*) FROM enrollment_records WHERE course_id = ?;''', (result[0],))\\n students_enrolled = cursor.fetchone()[0]\\n if students_enrolled is None:\\n students_enrolled = 0\\n\\n # Build a course dict from the data\\n courses.append({\\n \\\"course_abbreviation\\\": result[1],\\n \\\"course_name\\\": result[2],\\n \\\"instructor\\\": instructor_name,\\n \\\"time\\\": result[4],\\n \\\"students_enrolled\\\": students_enrolled,\\n \\\"capacity\\\": result[5],\\n })\\n\\n return courses\",\n \"def __str__(self):\\n # Use 'Unknown' if the course instance does not have a term\\n if self.course_instance.term:\\n term = self.course_instance.term.verbose_name()\\n else:\\n term = 'Unknown'\\n\\n exam_unicode = '{term} {number} {type} for {course}'.format(\\n term=term,\\n number=self.get_exam_number_display(),\\n type=self.get_exam_type_display(),\\n course=self.course_instance.course)\\n if self.instructors:\\n instructors = ', '.join([i.last_name for i in self.instructors])\\n return '{}, taught by {}'.format(exam_unicode, instructors)\\n else:\\n return '{} (Instructors Unknown)'.format(exam_unicode)\",\n \"def __str__(self):\\n\\t\\treturn self.full_name\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6388747","0.58620846","0.5832608","0.55203956","0.5508624","0.5427314","0.54227597","0.5291813","0.5283396","0.52249587","0.5194744","0.5179897","0.51505965","0.51442033","0.5131981","0.5128399","0.51204616","0.5106739","0.5105534","0.5094171","0.50742364","0.50669646","0.5043601","0.5028339","0.5016841","0.50076425","0.49862003","0.49831268","0.49831268","0.49831268","0.49831268","0.49831268","0.49824718","0.49667874","0.49567732","0.49552903","0.49519673","0.4931547","0.48981163","0.48969883","0.48914385","0.48554498","0.48513678","0.48475787","0.4845702","0.48338148","0.48305285","0.4826325","0.4826325","0.4826325","0.4826325","0.4816431","0.48088866","0.4799722","0.47904223","0.4774771","0.47744256","0.47714505","0.47698033","0.47675323","0.47674307","0.4756731","0.4756722","0.47562808","0.47562808","0.4755673","0.47524932","0.47379234","0.47375134","0.47356355","0.4728254","0.47237048","0.47155547","0.4715532","0.47140008","0.47135884","0.47093135","0.46963793","0.4694504","0.46944067","0.4691369","0.46912125","0.46903557","0.4680932","0.46762115","0.46725923","0.46621612","0.46618545","0.46571562","0.46567348","0.46560395","0.46510637","0.46467516","0.46454844","0.46422255","0.4640192","0.46392065","0.46375233","0.4633251","0.4630444"],"string":"[\n \"0.6388747\",\n \"0.58620846\",\n \"0.5832608\",\n \"0.55203956\",\n \"0.5508624\",\n \"0.5427314\",\n \"0.54227597\",\n \"0.5291813\",\n \"0.5283396\",\n \"0.52249587\",\n \"0.5194744\",\n \"0.5179897\",\n \"0.51505965\",\n \"0.51442033\",\n \"0.5131981\",\n \"0.5128399\",\n \"0.51204616\",\n \"0.5106739\",\n \"0.5105534\",\n \"0.5094171\",\n \"0.50742364\",\n \"0.50669646\",\n \"0.5043601\",\n \"0.5028339\",\n \"0.5016841\",\n \"0.50076425\",\n \"0.49862003\",\n \"0.49831268\",\n \"0.49831268\",\n \"0.49831268\",\n \"0.49831268\",\n \"0.49831268\",\n \"0.49824718\",\n \"0.49667874\",\n \"0.49567732\",\n \"0.49552903\",\n \"0.49519673\",\n \"0.4931547\",\n \"0.48981163\",\n \"0.48969883\",\n \"0.48914385\",\n \"0.48554498\",\n \"0.48513678\",\n \"0.48475787\",\n \"0.4845702\",\n \"0.48338148\",\n \"0.48305285\",\n \"0.4826325\",\n \"0.4826325\",\n \"0.4826325\",\n \"0.4826325\",\n \"0.4816431\",\n \"0.48088866\",\n \"0.4799722\",\n \"0.47904223\",\n \"0.4774771\",\n \"0.47744256\",\n \"0.47714505\",\n \"0.47698033\",\n \"0.47675323\",\n \"0.47674307\",\n \"0.4756731\",\n \"0.4756722\",\n \"0.47562808\",\n \"0.47562808\",\n \"0.4755673\",\n \"0.47524932\",\n \"0.47379234\",\n \"0.47375134\",\n \"0.47356355\",\n \"0.4728254\",\n \"0.47237048\",\n \"0.47155547\",\n \"0.4715532\",\n \"0.47140008\",\n \"0.47135884\",\n \"0.47093135\",\n \"0.46963793\",\n \"0.4694504\",\n \"0.46944067\",\n \"0.4691369\",\n \"0.46912125\",\n \"0.46903557\",\n \"0.4680932\",\n \"0.46762115\",\n \"0.46725923\",\n \"0.46621612\",\n \"0.46618545\",\n \"0.46571562\",\n \"0.46567348\",\n \"0.46560395\",\n \"0.46510637\",\n \"0.46467516\",\n \"0.46454844\",\n \"0.46422255\",\n \"0.4640192\",\n \"0.46392065\",\n \"0.46375233\",\n \"0.4633251\",\n \"0.4630444\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5878091"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":10494,"cells":{"query":{"kind":"string","value":"Classroom, Classroom > bool Returns True if first room have bigger capacity then second room"},"document":{"kind":"string","value":"def is_larger(self, room2):\n return self.capacity > room2.capacity"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __gt__(self, other: Card) -> bool:\n return not self.__le__(other)","def pareto_better(self, other: \"EvalItem\") -> bool:\n return self.size <= other.size and other.result <= self.result","def __gt__(self, other):\n return self.weight() > other.weight()","def __gt__(self, other):\n if other.num_of_certified_applications > self.num_of_certified_applications:\n return True\n elif other.num_of_certified_applications < self.num_of_certified_applications:\n return False\n elif other.name < self.name:\n return True\n else:\n return False","def __gt__(self, other):\n student1 = self.calculate_total()\n student2 = other.calculate_total()\n\n if student1 > student2:\n return True\n else:\n return False","def __gt__(self, other):\n return self.abs2phy.__gt__(other)","def __gt__(self, other):\n return self.abs2phy.__gt__(other)","def __gt__(self, other):\n return self.weight > other.weight","def __ge__(self, other: Card) -> bool:\n return not self.__lt__(other)","def __gt__(self, other):\n if other.groupnumber > self.groupnumber:\n return True\n else:\n return False","def __gt__(self, other):\n if self.head_vertex <= other.head_vertex:\n return False\n elif self.tail_vertex <= other.tail_vertex:\n return False\n elif self.weight <= other.weight:\n return False\n return True","def __gt__(self, other):\n if self.head_vertex <= other.head_vertex:\n return False\n elif self.tail_vertex <= other.tail_vertex:\n return False\n elif self.weight <= other.weight:\n return False\n return True","def __gt__(self, vs) -> bool:\n return vs <= self","def save(self, force_insert=False, force_update=False, using=None,\n\t\t\t update_fields=None):\n\t\tif (self.capacity - self.occupied_sits) < 0:\n\t\t\traise ValueError(\"all sits in this classroom are occupied try other classes\")\n\t\telse:\n\t\t\tsuper(ClassRoom, self).save()","def has_vacancy(self):\n return len(self.occupants) < self.capacity","def __gt__(self, other):\n return self.estimated_cost > other.estimated_cost","def __ge__(self, other):\n return int(self.rank) >= int(other.rank)","def is_balanced(self,delta=0.030):\n mincell = self.get_min_cell_voltage()\n maxcell = self.get_max_cell_voltage()\n if abs(maxcell-mincell) > delta:\n return False\n else:\n return True","def __gt__(self,other):\n self_bounds = self.Bounds\n ndim = self.InferSpatialDimension()\n\n if isinstance(other,Mesh):\n other_bounds = other.Bounds\n mins = (self_bounds[0,:] < other_bounds[0,:]).all()\n maxs = (self_bounds[1,:] > other_bounds[1,:]).all()\n return mins and maxs\n elif isinstance(other,np.ndarray):\n # Otherwise check if an element is within a given bounds\n assert other.shape == (2,ndim)\n mins = (self_bounds[0,:] < other[0,:]).all()\n maxs = (self_bounds[1,:] > other[1,:]).all()\n return mins and maxs\n else:\n raise ValueError(\"Cannot compare mesh with {}\".format(type(other)))","def is_full(self) -> bool:\n\n if self._current_pax + 1 <= self._capacity:\n\n # aircraft currently has reached the maximum capacity of passengers\n return False\n\n return True","def __gt__(self, other):\n return int(self.rank) > int(other.rank)","def __gt__(self, other):\n if self.i1 > other.i1:\n return True\n elif self.i1 == other.i1:\n if self.i2 > other.i2:\n return True\n elif self.i2 == other.i2 and self.axial > other.axial:\n return True\n return False","def __le__(self, other: Card) -> bool:\n return compare_map[self.number] <= compare_map[other.number]","def __gt__(self,other):\n if isinstance(other, RegularPoly):\n return(self.vert_count > other.vert_count)\n else:\n raise NotImplementedError('Incorrect data type')","def _is_full(self):\n if self.allocated_spaces == self.capacity:\n return True\n elif self.allocated_spaces < self.capacity:\n return False","def __gt__(self, other):\n return self.x ** 2 + self.y ** 2 > other.x ** 2 + other.y ** 2","def __gt__(self, other):\n return self.eval_score < other.eval_score","def __gt__(self, other):\n return self.__ge__(other) and self.__ne__(other)","def __gt__(self, transposon):\n return self.score > transposon.score","def __gt__(self,other):\r\n\t\tsorted_self = sorted(self.vector, reverse=True) #sort both lists in descending order\r\n\t\tsorted_other = sorted(other, reverse=True) \r\n\t\tcmpflag = False\r\n\t\tfor li1, li2 in zip(sorted_self, sorted_other):\r\n\t\t\tif(li1 > li2):\r\n\t\t\t\tcmpflag = True\r\n\t\treturn cmpflag","def ram_condition(min_gb=3):\n return get_free_gb() < min_gb","def __gt__(self, other):\n return self >= other and not self <= other","def __ge__(self, other):\n result = False\n if isinstance(other, Shape) and (self.area >= other.area):\n result = True\n return result","def __gt__(self, other):\n result = False\n if isinstance(other, Shape):\n result = not self.__le__(other)\n return result","def fits(x, y):\n return y.memory <= x.memory and y.cores <= x.cores and y.disk <= x.disk","def __gt__(self, other):\n return self >= other and self != other","def __gt__(self, other):\n return self >= other and self != other","def __gt__(self, other):\n return True if self._compare(other) > 0 else False","def __gt__(self, other):\n return other._is_subpolyhedron(self) and not self._is_subpolyhedron(other)","def addClassroom(classroomName, capacity,location):\n for classroom in classroomEntities:\n if classroom[\"classroomName\"] == classroomName:\n print(\"Two classrooms can not have same name\")\n return False\n\n if classroomEntities==[]:\n lastSavedIdNumber = \"0\"\n else:\n lastSavedId=classroomEntities[-1][\"classroomId\"] #update classroomId as first element in classroomEntities list\n lastSavedIdNumber=lastSavedId[2:]\n numberOfDigitsInID = 3\n if lastSavedIdNumber == \"9\" * len(lastSavedIdNumber):\n numberOfDigitsInID = len(lastSavedIdNumber) + 1\n classroomId=\"CR\"+str(int(lastSavedIdNumber)+1).rjust(numberOfDigitsInID,\"0\")\n\n # add the new Classroom\n newClassroom = {}\n newClassroom[\"classroomId\"] = classroomId\n newClassroom[\"classroomName\"] = classroomName\n newClassroom[\"capacity\"] = capacity\n newClassroom[\"location\"] = location\n classroomEntities.append(newClassroom)\n print(f\"Class Room is added into the system, Class Room id is {classroomId}.\")\n return True","def __gt__(self, other):\n return not (self <= other)","def __gt__(self, other):\n if isinstance(other, Hand):\n return self.hands_list > other.hands_list","def __gt__(self, other: 'LTL'):\n gt = self >= other\n neq = self != other\n return gt and neq","def is_crossing_len2(self, gp: GriddedPerm) -> bool:\n return (\n len(gp) == 2\n and gp.occupies(self.first_cell)\n and gp.occupies(self.second_cell)\n )","def __eq__(self, other: \"Availability\") -> bool:\n return all(\n [\n getattr(self, attribute, None) == getattr(other, attribute, None)\n for attribute in [\"person\", \"room\", \"start\", \"end\"]\n ]\n )","def __gt__(self, other):\n group = self.group\n if not isinstance(other, group.dtype):\n raise TypeError(\"only FreeGroup elements of same FreeGroup can \"\n \"be compared\")\n return not self <= other","def __gt__(self, other):\n return self.element() > other.element()","def __gt__(self, other):\n return not self <= other","def __gt__(self, other):\n return (self.__class__.__name__, self._values()) > (other.__class__.__name__, other._values())","def __gt__(self, hand2):\n # TODO: Implement\n if self.type > hand2.type:\n return True\n elif self.type < hand2.type:\n return False\n elif self.type == hand2.type:\n # NOTE: This ignores the case in which both hands have the same type\n # and rank. I think this is okay for now.\n return self.rank > hand2.rank","def __ge__(self,f2):\n return self > f2 or self == f2","def check_for_end_of_game(self):\n return self.player_1.score + self.player_2.score >= self.number_of_cells","def __ge__(self, other) -> bool:\n if isinstance(other, int) or isinstance(other, float):\n return self.balance >= other\n else:\n raise TypeError","def contains(self, other: \"Availability\") -> bool:\n return self.start <= other.start and self.end >= other.end","def __gt__(self, seq):\n return not self.__le__(seq)","def __gt__(self, other: 'MaxNode') -> bool:\n if self.priority == other.priority:\n return self.value < other.value\n return self.priority < other.priority","def __gt__(self, other):\n return other < self","def __gt__(self, other):\n return self.__cmp__(other) > 0","def __gt__(self, other): \n self.numerator=self.numerator*other.denominator\n other.numerator=self.denominator*other.numerator\n if(self.numerator>other.numerator):\n return True\n else:\n return False","def __le__(self, other):\n result = False\n if isinstance(other, Shape) and (self.area <= other.area):\n result = True\n return result","def __gt__(self, other):\n return self.head_vertex > other.head_vertex and self.tail_vertex > other.tail_vertex","def __gt__(self, other: 'MinNode') -> bool:\n if self.priority == other.priority:\n return self.value > other.value\n return self.priority > other.priority","def comparison(self, other):\n comparison = 0\n if self.races > other.races:\n comparison += 1\n elif self.races < other.races:\n comparison -= 1\n if self.wins > other.wins:\n comparison += 1\n elif self.wins < other.wins:\n comparison -= 1\n if len(self.drivers_championships_years) > len(other.drivers_championships_years):\n comparison += 1\n elif len(self.drivers_championships_years) < len(other.drivers_championships_years):\n comparison -= 1\n if len(self.constructors_championships_years) > len(other.constructors_championships_years):\n comparison += 1\n elif len(self.constructors_championships_years) < len(other.constructors_championships_years):\n comparison -= 1\n return comparison","def __lt__(self, other) -> bool:\r\n if SCHEDULING_TYPE == 'SJF':\r\n return self.job_size < other.job_size\r\n elif SCHEDULING_TYPE == 'Priority':\r\n return self.priority < other.priority\r\n elif SCHEDULING_TYPE == 'FIFO':\r\n return self.job_id < other.job_id","def __gt__(self, other):\n try:\n return self.length2 > other.length2\n except AttributeError:\n return assert_unorderable(self, other)","def __ge__(self, other):\n # self >= other\n return self.runtime.greater_than_equal(self, other)","def _capacity_rule(self, prod_name, r, cap, m, t):\n prod = getattr(m, prod_name)\n # note that a negative capacity means a CONSUMPTION capacity instead of PRODUCTION\n if cap > 0:\n return prod[r, t] <= cap\n else:\n return prod[r, t] >= cap","def status(self):\n return self.value > self.initial_value/2 \\\n and self.bag > 0 \\\n and self.balance > 1","def higher_floor(person_1, person_2):\n return person_1 > person_2","def __cmp__(self, other_org=None):\n if (self.dies or self.fitness==None):\n return -1 # It has died, it must be worse than anything.\n else:\n if (self.fitness > other_org.fitness):\n return -1\n elif (self.fitness < other_org.fitness):\n return 1\n else:\n return 0","def __ge__(self,other):\r\n\t\tif(self.checkUnorderedEq(other)): \r\n\t\t\treturn True\r\n\t\treturn self.__gt__(other)","def __le__(self, other):\n return int(self.rank) <= int(other.rank)","def __gt__(self, other: Schema) -> bool:\n return set(self.items()) > set(other.items())","def is_free(self) -> tuple:\n if self.running_procs >= self.procs_no:\n return (False, None)\n if self.gpus:\n for gpu in self.gpus:\n if self.gpu_running_procs[gpu] < self.per_gpu[gpu]:\n return (True, gpu)\n return (False, None)\n return (True, None)","def __ge__(self, other):\n return self.element() >= other.element()","def bornoff(self, board):\n res = False\n if (self.player):\n if (reduce(lambda x, y: x+y, board.p1vec) < reduce(lambda x, y: x+y, self.board.p1vec)):\n res = True\n else:\n if (reduce(lambda x, y: x+y, board.p2vec) < reduce(lambda x, y: x+y, self.board.p2vec)):\n res = True\n return res","def __ge__(self, other):\n try:\n return self.length2 >= other.length2\n except AttributeError:\n return assert_unorderable(self, other)","def modifyClassroom(classroomId, classroomName, capacity,location):\n for classroom in classroomEntities:\n if classroom[\"classroomId\"] == classroomId:\n selectedClassroom = classroom\n selectedClassroom[\"classroomName\"] = classroomName\n selectedClassroom[\"capacity\"] = capacity\n selectedClassroom[\"location\"] = location\n return True\n return False","def is_spare(self):\n if self.is_strike():\n return False\n\n return (self.first_ball + self.second_ball) == 10","def __ge__(self, other):\n return self.abs2phy.__ge__(other)","def __ge__(self, other):\n return self.abs2phy.__ge__(other)","def __gt__(self, other):\n if (self.master.__class__.__name__ == 'OneDimGrid') or (issubclass(self.master.__class__, OneDimGrid)):\n return self._gt_1d(other=other)\n if (self.master.__class__.__name__ == 'Grid') or (issubclass(self.master.__class__, Grid)):\n return self._gt_2d(other=other)","def is_free(self) -> bool:\n return self.places < self.total","def __le__(self, other):\n if self.assumptions >= other.assumptions and self.guarantees <= other.guarantees:\n return True\n else:\n return False","def __ge__(self, other):\n\t\treturn self.__gt__(other) or self.__eq__(other)","def isComrade(self, other): # are the pieces comrades ?\r\n \r\n if self.name == other.name: \r\n return True\r\n else:\r\n return False","def __gt__(self, Other):\n return not self <= Other","def is_full(self) -> bool:\r\n return self.size == self.capacity","def is_longer(dna1, dna2):\n return len(dna1)> len(dna2)","def __gt__(self, other):\n return self.greaterThan(other)","def __gt__(self, other):\n\n if self.count == other.count:\n return self.word < other.count\n return self.count > other.count","def __ge__(self, other):\n return greater_equal(self, other)","def __gt__(self, other):\n return self._metric_value > other.metric_value()","def __ge__(self, other):\n if self.head_vertex < other.head_vertex:\n return False\n elif self.tail_vertex < other.tail_vertex:\n return False\n elif self.weight < other.weight:\n return False\n return True","def __ge__(self, other):\n if self.head_vertex < other.head_vertex:\n return False\n elif self.tail_vertex < other.tail_vertex:\n return False\n elif self.weight < other.weight:\n return False\n return True","def is_full(self):\r\n if self.size == self.capacity:\r\n return True\r\n return False","def all_gt(self, other):\n return self.x > other.x and self.y > other.y","def isFull(self) -> bool:\n return (self.rear + 1) % self.capacity == self.front","def fits_into(self, other) -> bool:\n return other.width > self.width and other.height > self.height","def __ge__(self, other):\n return other <= self"],"string":"[\n \"def __gt__(self, other: Card) -> bool:\\n return not self.__le__(other)\",\n \"def pareto_better(self, other: \\\"EvalItem\\\") -> bool:\\n return self.size <= other.size and other.result <= self.result\",\n \"def __gt__(self, other):\\n return self.weight() > other.weight()\",\n \"def __gt__(self, other):\\n if other.num_of_certified_applications > self.num_of_certified_applications:\\n return True\\n elif other.num_of_certified_applications < self.num_of_certified_applications:\\n return False\\n elif other.name < self.name:\\n return True\\n else:\\n return False\",\n \"def __gt__(self, other):\\n student1 = self.calculate_total()\\n student2 = other.calculate_total()\\n\\n if student1 > student2:\\n return True\\n else:\\n return False\",\n \"def __gt__(self, other):\\n return self.abs2phy.__gt__(other)\",\n \"def __gt__(self, other):\\n return self.abs2phy.__gt__(other)\",\n \"def __gt__(self, other):\\n return self.weight > other.weight\",\n \"def __ge__(self, other: Card) -> bool:\\n return not self.__lt__(other)\",\n \"def __gt__(self, other):\\n if other.groupnumber > self.groupnumber:\\n return True\\n else:\\n return False\",\n \"def __gt__(self, other):\\n if self.head_vertex <= other.head_vertex:\\n return False\\n elif self.tail_vertex <= other.tail_vertex:\\n return False\\n elif self.weight <= other.weight:\\n return False\\n return True\",\n \"def __gt__(self, other):\\n if self.head_vertex <= other.head_vertex:\\n return False\\n elif self.tail_vertex <= other.tail_vertex:\\n return False\\n elif self.weight <= other.weight:\\n return False\\n return True\",\n \"def __gt__(self, vs) -> bool:\\n return vs <= self\",\n \"def save(self, force_insert=False, force_update=False, using=None,\\n\\t\\t\\t update_fields=None):\\n\\t\\tif (self.capacity - self.occupied_sits) < 0:\\n\\t\\t\\traise ValueError(\\\"all sits in this classroom are occupied try other classes\\\")\\n\\t\\telse:\\n\\t\\t\\tsuper(ClassRoom, self).save()\",\n \"def has_vacancy(self):\\n return len(self.occupants) < self.capacity\",\n \"def __gt__(self, other):\\n return self.estimated_cost > other.estimated_cost\",\n \"def __ge__(self, other):\\n return int(self.rank) >= int(other.rank)\",\n \"def is_balanced(self,delta=0.030):\\n mincell = self.get_min_cell_voltage()\\n maxcell = self.get_max_cell_voltage()\\n if abs(maxcell-mincell) > delta:\\n return False\\n else:\\n return True\",\n \"def __gt__(self,other):\\n self_bounds = self.Bounds\\n ndim = self.InferSpatialDimension()\\n\\n if isinstance(other,Mesh):\\n other_bounds = other.Bounds\\n mins = (self_bounds[0,:] < other_bounds[0,:]).all()\\n maxs = (self_bounds[1,:] > other_bounds[1,:]).all()\\n return mins and maxs\\n elif isinstance(other,np.ndarray):\\n # Otherwise check if an element is within a given bounds\\n assert other.shape == (2,ndim)\\n mins = (self_bounds[0,:] < other[0,:]).all()\\n maxs = (self_bounds[1,:] > other[1,:]).all()\\n return mins and maxs\\n else:\\n raise ValueError(\\\"Cannot compare mesh with {}\\\".format(type(other)))\",\n \"def is_full(self) -> bool:\\n\\n if self._current_pax + 1 <= self._capacity:\\n\\n # aircraft currently has reached the maximum capacity of passengers\\n return False\\n\\n return True\",\n \"def __gt__(self, other):\\n return int(self.rank) > int(other.rank)\",\n \"def __gt__(self, other):\\n if self.i1 > other.i1:\\n return True\\n elif self.i1 == other.i1:\\n if self.i2 > other.i2:\\n return True\\n elif self.i2 == other.i2 and self.axial > other.axial:\\n return True\\n return False\",\n \"def __le__(self, other: Card) -> bool:\\n return compare_map[self.number] <= compare_map[other.number]\",\n \"def __gt__(self,other):\\n if isinstance(other, RegularPoly):\\n return(self.vert_count > other.vert_count)\\n else:\\n raise NotImplementedError('Incorrect data type')\",\n \"def _is_full(self):\\n if self.allocated_spaces == self.capacity:\\n return True\\n elif self.allocated_spaces < self.capacity:\\n return False\",\n \"def __gt__(self, other):\\n return self.x ** 2 + self.y ** 2 > other.x ** 2 + other.y ** 2\",\n \"def __gt__(self, other):\\n return self.eval_score < other.eval_score\",\n \"def __gt__(self, other):\\n return self.__ge__(other) and self.__ne__(other)\",\n \"def __gt__(self, transposon):\\n return self.score > transposon.score\",\n \"def __gt__(self,other):\\r\\n\\t\\tsorted_self = sorted(self.vector, reverse=True) #sort both lists in descending order\\r\\n\\t\\tsorted_other = sorted(other, reverse=True) \\r\\n\\t\\tcmpflag = False\\r\\n\\t\\tfor li1, li2 in zip(sorted_self, sorted_other):\\r\\n\\t\\t\\tif(li1 > li2):\\r\\n\\t\\t\\t\\tcmpflag = True\\r\\n\\t\\treturn cmpflag\",\n \"def ram_condition(min_gb=3):\\n return get_free_gb() < min_gb\",\n \"def __gt__(self, other):\\n return self >= other and not self <= other\",\n \"def __ge__(self, other):\\n result = False\\n if isinstance(other, Shape) and (self.area >= other.area):\\n result = True\\n return result\",\n \"def __gt__(self, other):\\n result = False\\n if isinstance(other, Shape):\\n result = not self.__le__(other)\\n return result\",\n \"def fits(x, y):\\n return y.memory <= x.memory and y.cores <= x.cores and y.disk <= x.disk\",\n \"def __gt__(self, other):\\n return self >= other and self != other\",\n \"def __gt__(self, other):\\n return self >= other and self != other\",\n \"def __gt__(self, other):\\n return True if self._compare(other) > 0 else False\",\n \"def __gt__(self, other):\\n return other._is_subpolyhedron(self) and not self._is_subpolyhedron(other)\",\n \"def addClassroom(classroomName, capacity,location):\\n for classroom in classroomEntities:\\n if classroom[\\\"classroomName\\\"] == classroomName:\\n print(\\\"Two classrooms can not have same name\\\")\\n return False\\n\\n if classroomEntities==[]:\\n lastSavedIdNumber = \\\"0\\\"\\n else:\\n lastSavedId=classroomEntities[-1][\\\"classroomId\\\"] #update classroomId as first element in classroomEntities list\\n lastSavedIdNumber=lastSavedId[2:]\\n numberOfDigitsInID = 3\\n if lastSavedIdNumber == \\\"9\\\" * len(lastSavedIdNumber):\\n numberOfDigitsInID = len(lastSavedIdNumber) + 1\\n classroomId=\\\"CR\\\"+str(int(lastSavedIdNumber)+1).rjust(numberOfDigitsInID,\\\"0\\\")\\n\\n # add the new Classroom\\n newClassroom = {}\\n newClassroom[\\\"classroomId\\\"] = classroomId\\n newClassroom[\\\"classroomName\\\"] = classroomName\\n newClassroom[\\\"capacity\\\"] = capacity\\n newClassroom[\\\"location\\\"] = location\\n classroomEntities.append(newClassroom)\\n print(f\\\"Class Room is added into the system, Class Room id is {classroomId}.\\\")\\n return True\",\n \"def __gt__(self, other):\\n return not (self <= other)\",\n \"def __gt__(self, other):\\n if isinstance(other, Hand):\\n return self.hands_list > other.hands_list\",\n \"def __gt__(self, other: 'LTL'):\\n gt = self >= other\\n neq = self != other\\n return gt and neq\",\n \"def is_crossing_len2(self, gp: GriddedPerm) -> bool:\\n return (\\n len(gp) == 2\\n and gp.occupies(self.first_cell)\\n and gp.occupies(self.second_cell)\\n )\",\n \"def __eq__(self, other: \\\"Availability\\\") -> bool:\\n return all(\\n [\\n getattr(self, attribute, None) == getattr(other, attribute, None)\\n for attribute in [\\\"person\\\", \\\"room\\\", \\\"start\\\", \\\"end\\\"]\\n ]\\n )\",\n \"def __gt__(self, other):\\n group = self.group\\n if not isinstance(other, group.dtype):\\n raise TypeError(\\\"only FreeGroup elements of same FreeGroup can \\\"\\n \\\"be compared\\\")\\n return not self <= other\",\n \"def __gt__(self, other):\\n return self.element() > other.element()\",\n \"def __gt__(self, other):\\n return not self <= other\",\n \"def __gt__(self, other):\\n return (self.__class__.__name__, self._values()) > (other.__class__.__name__, other._values())\",\n \"def __gt__(self, hand2):\\n # TODO: Implement\\n if self.type > hand2.type:\\n return True\\n elif self.type < hand2.type:\\n return False\\n elif self.type == hand2.type:\\n # NOTE: This ignores the case in which both hands have the same type\\n # and rank. I think this is okay for now.\\n return self.rank > hand2.rank\",\n \"def __ge__(self,f2):\\n return self > f2 or self == f2\",\n \"def check_for_end_of_game(self):\\n return self.player_1.score + self.player_2.score >= self.number_of_cells\",\n \"def __ge__(self, other) -> bool:\\n if isinstance(other, int) or isinstance(other, float):\\n return self.balance >= other\\n else:\\n raise TypeError\",\n \"def contains(self, other: \\\"Availability\\\") -> bool:\\n return self.start <= other.start and self.end >= other.end\",\n \"def __gt__(self, seq):\\n return not self.__le__(seq)\",\n \"def __gt__(self, other: 'MaxNode') -> bool:\\n if self.priority == other.priority:\\n return self.value < other.value\\n return self.priority < other.priority\",\n \"def __gt__(self, other):\\n return other < self\",\n \"def __gt__(self, other):\\n return self.__cmp__(other) > 0\",\n \"def __gt__(self, other): \\n self.numerator=self.numerator*other.denominator\\n other.numerator=self.denominator*other.numerator\\n if(self.numerator>other.numerator):\\n return True\\n else:\\n return False\",\n \"def __le__(self, other):\\n result = False\\n if isinstance(other, Shape) and (self.area <= other.area):\\n result = True\\n return result\",\n \"def __gt__(self, other):\\n return self.head_vertex > other.head_vertex and self.tail_vertex > other.tail_vertex\",\n \"def __gt__(self, other: 'MinNode') -> bool:\\n if self.priority == other.priority:\\n return self.value > other.value\\n return self.priority > other.priority\",\n \"def comparison(self, other):\\n comparison = 0\\n if self.races > other.races:\\n comparison += 1\\n elif self.races < other.races:\\n comparison -= 1\\n if self.wins > other.wins:\\n comparison += 1\\n elif self.wins < other.wins:\\n comparison -= 1\\n if len(self.drivers_championships_years) > len(other.drivers_championships_years):\\n comparison += 1\\n elif len(self.drivers_championships_years) < len(other.drivers_championships_years):\\n comparison -= 1\\n if len(self.constructors_championships_years) > len(other.constructors_championships_years):\\n comparison += 1\\n elif len(self.constructors_championships_years) < len(other.constructors_championships_years):\\n comparison -= 1\\n return comparison\",\n \"def __lt__(self, other) -> bool:\\r\\n if SCHEDULING_TYPE == 'SJF':\\r\\n return self.job_size < other.job_size\\r\\n elif SCHEDULING_TYPE == 'Priority':\\r\\n return self.priority < other.priority\\r\\n elif SCHEDULING_TYPE == 'FIFO':\\r\\n return self.job_id < other.job_id\",\n \"def __gt__(self, other):\\n try:\\n return self.length2 > other.length2\\n except AttributeError:\\n return assert_unorderable(self, other)\",\n \"def __ge__(self, other):\\n # self >= other\\n return self.runtime.greater_than_equal(self, other)\",\n \"def _capacity_rule(self, prod_name, r, cap, m, t):\\n prod = getattr(m, prod_name)\\n # note that a negative capacity means a CONSUMPTION capacity instead of PRODUCTION\\n if cap > 0:\\n return prod[r, t] <= cap\\n else:\\n return prod[r, t] >= cap\",\n \"def status(self):\\n return self.value > self.initial_value/2 \\\\\\n and self.bag > 0 \\\\\\n and self.balance > 1\",\n \"def higher_floor(person_1, person_2):\\n return person_1 > person_2\",\n \"def __cmp__(self, other_org=None):\\n if (self.dies or self.fitness==None):\\n return -1 # It has died, it must be worse than anything.\\n else:\\n if (self.fitness > other_org.fitness):\\n return -1\\n elif (self.fitness < other_org.fitness):\\n return 1\\n else:\\n return 0\",\n \"def __ge__(self,other):\\r\\n\\t\\tif(self.checkUnorderedEq(other)): \\r\\n\\t\\t\\treturn True\\r\\n\\t\\treturn self.__gt__(other)\",\n \"def __le__(self, other):\\n return int(self.rank) <= int(other.rank)\",\n \"def __gt__(self, other: Schema) -> bool:\\n return set(self.items()) > set(other.items())\",\n \"def is_free(self) -> tuple:\\n if self.running_procs >= self.procs_no:\\n return (False, None)\\n if self.gpus:\\n for gpu in self.gpus:\\n if self.gpu_running_procs[gpu] < self.per_gpu[gpu]:\\n return (True, gpu)\\n return (False, None)\\n return (True, None)\",\n \"def __ge__(self, other):\\n return self.element() >= other.element()\",\n \"def bornoff(self, board):\\n res = False\\n if (self.player):\\n if (reduce(lambda x, y: x+y, board.p1vec) < reduce(lambda x, y: x+y, self.board.p1vec)):\\n res = True\\n else:\\n if (reduce(lambda x, y: x+y, board.p2vec) < reduce(lambda x, y: x+y, self.board.p2vec)):\\n res = True\\n return res\",\n \"def __ge__(self, other):\\n try:\\n return self.length2 >= other.length2\\n except AttributeError:\\n return assert_unorderable(self, other)\",\n \"def modifyClassroom(classroomId, classroomName, capacity,location):\\n for classroom in classroomEntities:\\n if classroom[\\\"classroomId\\\"] == classroomId:\\n selectedClassroom = classroom\\n selectedClassroom[\\\"classroomName\\\"] = classroomName\\n selectedClassroom[\\\"capacity\\\"] = capacity\\n selectedClassroom[\\\"location\\\"] = location\\n return True\\n return False\",\n \"def is_spare(self):\\n if self.is_strike():\\n return False\\n\\n return (self.first_ball + self.second_ball) == 10\",\n \"def __ge__(self, other):\\n return self.abs2phy.__ge__(other)\",\n \"def __ge__(self, other):\\n return self.abs2phy.__ge__(other)\",\n \"def __gt__(self, other):\\n if (self.master.__class__.__name__ == 'OneDimGrid') or (issubclass(self.master.__class__, OneDimGrid)):\\n return self._gt_1d(other=other)\\n if (self.master.__class__.__name__ == 'Grid') or (issubclass(self.master.__class__, Grid)):\\n return self._gt_2d(other=other)\",\n \"def is_free(self) -> bool:\\n return self.places < self.total\",\n \"def __le__(self, other):\\n if self.assumptions >= other.assumptions and self.guarantees <= other.guarantees:\\n return True\\n else:\\n return False\",\n \"def __ge__(self, other):\\n\\t\\treturn self.__gt__(other) or self.__eq__(other)\",\n \"def isComrade(self, other): # are the pieces comrades ?\\r\\n \\r\\n if self.name == other.name: \\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def __gt__(self, Other):\\n return not self <= Other\",\n \"def is_full(self) -> bool:\\r\\n return self.size == self.capacity\",\n \"def is_longer(dna1, dna2):\\n return len(dna1)> len(dna2)\",\n \"def __gt__(self, other):\\n return self.greaterThan(other)\",\n \"def __gt__(self, other):\\n\\n if self.count == other.count:\\n return self.word < other.count\\n return self.count > other.count\",\n \"def __ge__(self, other):\\n return greater_equal(self, other)\",\n \"def __gt__(self, other):\\n return self._metric_value > other.metric_value()\",\n \"def __ge__(self, other):\\n if self.head_vertex < other.head_vertex:\\n return False\\n elif self.tail_vertex < other.tail_vertex:\\n return False\\n elif self.weight < other.weight:\\n return False\\n return True\",\n \"def __ge__(self, other):\\n if self.head_vertex < other.head_vertex:\\n return False\\n elif self.tail_vertex < other.tail_vertex:\\n return False\\n elif self.weight < other.weight:\\n return False\\n return True\",\n \"def is_full(self):\\r\\n if self.size == self.capacity:\\r\\n return True\\r\\n return False\",\n \"def all_gt(self, other):\\n return self.x > other.x and self.y > other.y\",\n \"def isFull(self) -> bool:\\n return (self.rear + 1) % self.capacity == self.front\",\n \"def fits_into(self, other) -> bool:\\n return other.width > self.width and other.height > self.height\",\n \"def __ge__(self, other):\\n return other <= self\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61225253","0.5890521","0.5887941","0.58851635","0.5883985","0.5871","0.5871","0.58323383","0.57970667","0.57674","0.57477105","0.57477105","0.5667831","0.5658871","0.56532055","0.5647148","0.56317246","0.56295174","0.5624304","0.55907315","0.5584328","0.55796695","0.5568212","0.5559307","0.5554279","0.5547663","0.55410206","0.5536703","0.55292314","0.55155945","0.5513142","0.55116236","0.5505302","0.5495359","0.5490565","0.5475783","0.5475783","0.5467595","0.546505","0.54637384","0.5448317","0.5441457","0.5434644","0.543251","0.5427815","0.5414046","0.54133964","0.5392386","0.5389289","0.5387799","0.53811795","0.53709406","0.5366617","0.53635955","0.5352685","0.53480977","0.5341817","0.53386927","0.53334516","0.53330564","0.5332588","0.5331114","0.53276837","0.53257346","0.5314312","0.5305744","0.5301424","0.5292401","0.52816725","0.5276992","0.52728045","0.5270637","0.5270251","0.526854","0.526448","0.5264259","0.52571476","0.5256792","0.5248227","0.52433264","0.52433264","0.52431905","0.5241665","0.52410465","0.5240623","0.52386045","0.5234632","0.5222469","0.52214926","0.52153933","0.5215187","0.52095175","0.5199621","0.51987404","0.51987404","0.5196477","0.5192063","0.51899815","0.5183828","0.5170958"],"string":"[\n \"0.61225253\",\n \"0.5890521\",\n \"0.5887941\",\n \"0.58851635\",\n \"0.5883985\",\n \"0.5871\",\n \"0.5871\",\n \"0.58323383\",\n \"0.57970667\",\n \"0.57674\",\n \"0.57477105\",\n \"0.57477105\",\n \"0.5667831\",\n \"0.5658871\",\n \"0.56532055\",\n \"0.5647148\",\n \"0.56317246\",\n \"0.56295174\",\n \"0.5624304\",\n \"0.55907315\",\n \"0.5584328\",\n \"0.55796695\",\n \"0.5568212\",\n \"0.5559307\",\n \"0.5554279\",\n \"0.5547663\",\n \"0.55410206\",\n \"0.5536703\",\n \"0.55292314\",\n \"0.55155945\",\n \"0.5513142\",\n \"0.55116236\",\n \"0.5505302\",\n \"0.5495359\",\n \"0.5490565\",\n \"0.5475783\",\n \"0.5475783\",\n \"0.5467595\",\n \"0.546505\",\n \"0.54637384\",\n \"0.5448317\",\n \"0.5441457\",\n \"0.5434644\",\n \"0.543251\",\n \"0.5427815\",\n \"0.5414046\",\n \"0.54133964\",\n \"0.5392386\",\n \"0.5389289\",\n \"0.5387799\",\n \"0.53811795\",\n \"0.53709406\",\n \"0.5366617\",\n \"0.53635955\",\n \"0.5352685\",\n \"0.53480977\",\n \"0.5341817\",\n \"0.53386927\",\n \"0.53334516\",\n \"0.53330564\",\n \"0.5332588\",\n \"0.5331114\",\n \"0.53276837\",\n \"0.53257346\",\n \"0.5314312\",\n \"0.5305744\",\n \"0.5301424\",\n \"0.5292401\",\n \"0.52816725\",\n \"0.5276992\",\n \"0.52728045\",\n \"0.5270637\",\n \"0.5270251\",\n \"0.526854\",\n \"0.526448\",\n \"0.5264259\",\n \"0.52571476\",\n \"0.5256792\",\n \"0.5248227\",\n \"0.52433264\",\n \"0.52433264\",\n \"0.52431905\",\n \"0.5241665\",\n \"0.52410465\",\n \"0.5240623\",\n \"0.52386045\",\n \"0.5234632\",\n \"0.5222469\",\n \"0.52214926\",\n \"0.52153933\",\n \"0.5215187\",\n \"0.52095175\",\n \"0.5199621\",\n \"0.51987404\",\n \"0.51987404\",\n \"0.5196477\",\n \"0.5192063\",\n \"0.51899815\",\n \"0.5183828\",\n \"0.5170958\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73677325"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":10495,"cells":{"query":{"kind":"string","value":"Classroom, Classroom > list Returns the equipment in first room which is missing in second"},"document":{"kind":"string","value":"def equipment_differences(self, room2):\n return sorted(list(set(self.equipment).difference(room2.equipment)))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def check_rooms(self, exclude=[]):\n stmt = Session.query(Lesson.room, Lesson.day, Lesson.order,\n Lesson.schedule_id)\n stmt = stmt.group_by(Lesson.room, Lesson.order, Lesson.day, Lesson.schedule_id)\n stmt = stmt.having(func.count(Lesson.room)>1)\n stmt = stmt.filter(not_(Lesson.room.in_(exclude)))\n stmt = stmt.subquery()\n q = Session.query(Lesson).join((stmt, and_(\n Lesson.room == stmt.c.room,\n Lesson.day == stmt.c.day,\n Lesson.order == stmt.c.order,\n Lesson.schedule_id == stmt.c.schedule_id)))\n q = q.order_by(Lesson.day, Lesson.order, Lesson.room)\n\n conflicts = q.all()\n if len(conflicts) == 0:\n return []\n rooms = [[conflicts.pop(0), conflicts.pop(0)]]\n for c in conflicts:\n prev = rooms[-1][-1]\n if c.room == prev.room and c.day == prev.day and c.order == \\\n prev.order and c.schedule_id == prev.schedule_id:\n rooms[-1].append(c)\n else:\n rooms.append([c])\n return rooms","def check_for_unguarded_rooms(museum):\r\n\tempty_rooms = []\r\n\r\n\tfor row_idx in range(len(museum)):\t\r\n\t\t\r\n\t\tfor item_idx in range(len(museum[row_idx])): #Go back and fix this to be enumerate instead\r\n\t\t\t\r\n\t\t\tif museum[row_idx][item_idx] == \"0\":\r\n\t\t\t\tempty_rooms.append([row_idx, item_idx])\r\n\r\n\t# for row_idx, row_value in enumerate(museum):\r\n\t# \tfor item_idx, item_value in enumerate(row):\r\n\t# \t\tif item_value == \" \":\r\n\t# \t\t\tprint(item)\r\n\t# \t\t\tempty_rooms.append([row_idx, item_idx]) # need index\r\n\r\n\tif not empty_rooms:\r\n\t\tprint(\"true\")\r\n\t\r\n\telse:\r\n\t\tprint(\"false\")\r\n\r\n\t\tfor room in empty_rooms:\r\n\t\t\tprint(str(room[0]) + \" \" + str(room[1]))","def check_room(rooms):\n free_rooms = []\n booked_rooms = [] \n for element in rooms:\n if element['booked'] == False:\n free_rooms.append(element)\n else:\n booked_rooms.append(element)\n return free_rooms, booked_rooms","def captain_room(room_list):\n captain_room = '' \n #store the list in total_rooms\n total_rooms = room_list \n #get the unique rooms without repetition of any room\n unique_rooms_num = set(total_rooms) \n #Remove the unique room from the list of total rooms\n for n in unique_rooms_num:\n total_rooms.remove(n) \n without_captain_room = total_rooms\n #The original total room list does not contain captain room number anymore\n #check by print(total_rooms)\n\n #Now, Compare the unique room number: that contains captain number with\n #list without_captain_room\n for i in unique_rooms_num:\n if i not in without_captain_room: \n captain_room = i\n \n return captain_room","def findUnoccupied( board, occupation):\n return [ j for j in xrange(len(board.positions))\n if not occupation.has_key(j) ]","def get_room_list():\n room_list = []\n # 0\n room = Room(\n \"Patio. You are in a patio, it is surrounded by four long walls.\\n\\\n The south wall has a metal door.\",\n north = None,\n east = None,\n south = 2,\n west = None\n )\n room_list.append(room)\n # 1\n room = Room(\n \"Bedroom. You are in a bedroom, there is nothing uncommon.\\n\\\n The door lead to east\",\n north = None,\n east = 2,\n south = None,\n west = None\n )\n room_list.append(room)\n # 2\n room = Room(\n \"Kitchen. You are in a kitchen, there is some porridge on the oven.\\n\\\n There are three doors, north, west, south\",\n north = 0,\n east = None,\n south = 4,\n west = 1\n )\n room_list.append(room)\n # 3\n room = Room(\n \"Tv room. You are in the tv room, there is an old tv set, \\n\\\n seems like it hasn't being used for years.\\n\\\n The door lead to east\",\n north = None,\n east = 4,\n south = None,\n west = None\n )\n room_list.append(room)\n # 4\n room = Room(\n \"Dinning room. You are in a dinning room, there is a big round table.\\n\\\n There are three doors, north, west, south\",\n north = 2,\n east = None,\n south = 6,\n west = 3\n )\n room_list.append(room)\n # 5\n room = Room(\n \"Master bedroom. You are in the master bedroom, there are many religious things all over.\\n\\\n The door lead to east\",\n north = None,\n east = 6,\n south = None,\n west = None\n )\n room_list.append(room)\n # 6\n room = Room(\n \"Living room. You are in the living room, you can see the exit door to the south.\\n\\\n There are three doors, north, west, south\",\n north = 4,\n east = None,\n south = 7,\n west = 5\n )\n room_list.append(room)\n return room_list","def rooms_opposite(self, room):\n if room in self.adjacencies:\n room_side = self.adjacencies[room][0].self_edge_index\n other_side = 0 if room_side == 2 else 2\n return self.adjacencies.filter(lambda obj, info: isinstance(obj, Room) and info.self_edge_index == other_side)","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n if len(rooms)==0:\n return rooms\n n, m = len(rooms), len(rooms[0])\n for i in range(n):\n for j in range(m):\n if rooms[i][j] == 0:\n q= [(i,j,0)]\n while q:\n ci, cj , d = q.pop(0)\n for ni, nj in [(ci+1,cj),(ci-1,cj),(ci,cj+1),(ci,cj-1)]:\n if 0<=ni<n and 0<=nj<m and rooms[ni][nj]!=-1:\n if rooms[ni][nj]>d+1:\n rooms[ni][nj] = d+1\n q.append((ni,nj,d+1))\n return rooms","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n def get_gates(rooms):\n res = []\n M, N = len(rooms), len(rooms[0])\n for i in range(M):\n for j in range(N):\n if rooms[i][j] == 0:\n res.append((i, j))\n return res\n \n que = [(i, j, 0) for i, j in get_gates(rooms)]\n #seen = set()\n deltas = [[0, 1], [0, -1], [-1, 0], [1, 0]]\n R, C = len(rooms), len(rooms[0])\n INF = 2**31 - 1\n while que:\n i, j, distance = que.pop(0)\n for dx, dy in deltas:\n x, y = i + dx, j + dy\n if 0 <= x < R and 0 <= y < C and rooms[x][y] == INF:\n rooms[x][y] = distance + 1\n que.append((x, y, distance + 1))","def find_all_available_rooms(self) -> webelement:\n\n available_rooms = list()\n room_listing_section = self.__get_room_listing_section()\n location_div_list = room_listing_section.find_elements(\n By.XPATH,\n \".//div[contains(@class, 'room_listing_bg')]\"\n )\n for location_div in location_div_list:\n house_name = location_div.find_element(\n By.XPATH,\n \".//div[1]/h2[@class='room_data_headline']\"\n ).text\n room_list_table = location_div.find_element(\n By.XPATH,\n \".//table[contains(@class, 'room_data_table')]\"\n )\n room_tr_list = room_list_table.find_elements(By.TAG_NAME, \"tr\")\n room_tr_list = room_tr_list[1:]\n for room_tr in room_tr_list:\n room_type = room_tr.find_element(By.XPATH, \".//td[1]\").text\n number_of_persons = room_tr.find_element(By.XPATH, \".//td[2]\").text\n free_at = room_tr.find_element(By.XPATH, \".//td[3]\").text\n free_at = re.sub(r'^([^\\s]*)\\s+', r'\\1, ', free_at)\n price_euro = room_tr.find_element(By.XPATH, \".//td[4]\").text\n size_square_meter = room_tr.find_element(By.XPATH, \".//td[5]\").text\n floor = room_tr.find_element(By.XPATH, \".//td[6]\").text\n selection_radios = room_tr.find_elements(By.XPATH, \".//td[7]/input[@type='radio']\")\n if len(selection_radios) > 0:\n radio_value = selection_radios[0].get_attribute(\"value\")\n available_rooms.append(\n RoomInfo(\n house_name,\n room_type,\n number_of_persons,\n free_at,\n price_euro,\n size_square_meter,\n floor,\n radio_value\n )\n )\n\n return available_rooms","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n rows = len(rooms)\n if rows == 0:\n return\n cols = len(rooms[0])\n GATE = 0\n EMPTY = pow(2, 31) - 1\n DIRECTIONS = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n q = deque([])\n for i in range(rows):\n for j in range(cols):\n if rooms[i][j] == GATE:\n q.append((i, j))\n while q:\n x, y = q.popleft()\n for idx, idy in DIRECTIONS:\n if x + idx < 0 or x + idx >= rows or y + idy < 0 or y + idy >= cols or rooms[x + idx][y + idy] != EMPTY:\n continue\n rooms[x + idx][y + idy] = rooms[x][y] + 1\n q.append((x + idx, y + idy))","def possible_rooms(self):\r\n return self.rooms","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n offsets = [[0,1],[1,0],[0,-1],[-1,0]]\n size = [len(rooms), len(rooms[0])]\n q = []\n for i in range(len(rooms)):\n for j in range(len(rooms[i])):\n if rooms[i][j] == 0:\n q.append([i,j])\n while len(q) != 0:\n cur = q.pop(0)\n for i in offsets:\n x = cur[0]+i[0]\n y = cur[1]+i[1]\n if x >= size[0] or x<0 or y>=size[1] or y<0 or rooms[x][y] != 2147483647:\n continue\n rooms[x][y] = rooms[cur[0]][cur[1]]+1\n q.append([x,y])","def get_equipment_from_inventory(self):\n return [x for x in self.inventory if x.is_equip()]","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n if not rooms or not rooms[0]:\n return \n \n queue = deque([])\n for i in range(len(rooms)):\n for j in range(len(rooms[i])):\n if rooms[i][j] == 0:\n queue.append((i,j, 0))\n \n visited = set()\n while queue:\n i, j, distance = queue.popleft()\n \n if not (0 <= i < len(rooms) and 0 <= j < len(rooms[0])):\n continue\n \n if rooms[i][j] == -1:\n continue\n \n if (i, j) in visited:\n continue\n \n visited.add((i, j))\n if rooms[i][j] != 0:\n rooms[i][j] = distance\n \n for offset in OFFSETS:\n queue.append((i + offset[0], j + offset[1], distance + 1))","def find_missing_pos_in_motif_otherclass(motifs, motname_li,dict_class,current_class):\n motifs_def=[]\n n=0\n for motname in motname_li:\n found=[]\n found_ranges=[]\n not_found=[]\n for e in motifs:\n if e[0]==motname:\n if not e[2]:\n not_found.append(e[1])\n else:\n motpos= e[1] + current_class.lower() + \" = \" + e[4] +dict_class.lower()\n found.append(motpos)\n found_ranges.append(e[3])\n \n num_nf=len(not_found)\n ranges_all=\",\".join(found_ranges)\n if num_nf ==0:\n motifs_def.append([motname,\" ; \".join(found),(ranges_all)])\n elif num_nf ==3:\n motifs_def.append([motname,\"Motif not found\",\"None\"])\n else:\n motifs_def.append([motname,(\" ; \".join(found) + \" (\" + \" , \".join(not_found) + \" not found)\"),(ranges_all)])\n n+=1\n return motifs_def","def getNotMyCamps(self):\n r = []\n for p in self.__camps:\n if(p.getOwner() != 1):\n r.append(p)\n return r","def get_room_names(soup: bs4.BeautifulSoup) -> Iterable[str]:\n return set(x.string for x in soup.Lecture.find_all(\"RaumBez\"))","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n lenm = len(rooms)\n lenn = len(rooms[0])\n \n queue = []\n visited = set()\n \n direction = [(0,1),(1,0),(0,-1),(-1,0)]\n \n for i in range(lenm):\n for j in range(lenn):\n if rooms[i][j] == 0:\n queue.append(((i,j),0))\n visited.add((i,j))\n while queue:\n n = len(queue)\n for _ in range(n):\n (a,b),val = queue.pop(0)\n if rooms[a][b] != -1:\n rooms[a][b] = val\n for x,y in direction:\n i = a+x\n j = b+y\n if i <0 or i>=lenm or j<0 or j>=lenn or rooms[i][j] == -1:\n continue\n if (i,j) not in visited:\n visited.add((i,j))\n queue.append(((i,j),val+1))\n \n \n \n \n return rooms","def __repr__(self):\n return \"Classroom('{}', {}, {})\".format(self.number, self.capacity,\n str(self.equipment))","def wallsAndGates(self, rooms: List[List[int]]) -> None:\r\n if not rooms:\r\n return rooms\r\n \r\n ind_0s = []\r\n len_row = len(rooms)\r\n len_col = len(rooms[0])\r\n for i in range(len_row):\r\n for j in range(len_col):\r\n if rooms[i][j] == 0:\r\n ind_0s.append((i,j))\r\n que = ind_0s\r\n while que:\r\n i,j = que.pop()\r\n neighbors = [(i,j-1), (i-1,j), (i,j+1), (i+1,j)]\r\n if rooms[i][j] == 0:\r\n parent_distance = 0\r\n else:\r\n parent_distance = rooms[i][j]\r\n for x, y in neighbors:\r\n if x>=0 and x<len_row and y>=0 and y<len_col and rooms[x][y]!=-1 and rooms[x][y] and \\\r\n parent_distance+1 < rooms[x][y]:\r\n que.append((x,y))","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n ## bfs:\n queue= []\n for r in range(len(rooms)):\n for c in range(len(rooms[0])):\n if rooms[r][c]==0:\n queue.append((r,c, 0)) \n \n while queue:\n r,c, l= queue.pop(0)\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\n if new_r>=0 and new_c>=0 and new_r<len(rooms) and \\\n new_c<len(rooms[0]) and rooms[new_r][new_c]==2**31 -1:\n rooms[new_r][new_c]=l+1\n queue.append((new_r, new_c, l+1))\n return rooms","def _find_homeless_mps(self):\n mps = Person.objects.filter(\n active=True,\n house__name=HOUSE_OF_COMMONS,\n constituency=None,\n )\n\n self.stdout('MPs with missing constituency:')\n for mp in mps:\n self.stdout(f' [{mp.parliamentdotuk}] {mp.name} has no constituency')","def _find_memberless_constituencies(self):\n constituencies = Constituency.objects.filter(\n end=None, # Constituency currently exists/is not historical\n mp=None,\n )\n\n self.stdout('Constituencies with missing MP:')\n for constituency in constituencies:\n self.stdout(f'[{constituency.parliamentdotuk}] {constituency.name} {constituency.start}')","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n # start with the gate and search the empty cells it can reach\n # then we take the smallest one\n if not rooms:\n return\n\n m, n = len(rooms), len(rooms[0])\n \n queue = []\n for i in range(m):\n for j in range(n):\n if rooms[i][j] == 0:\n queue.append((i, j))\n\n\n for x, y in queue:\n dist = rooms[x][y] + 1\n\n for dx, dy in ((-1, 0), (1, 0), (0, 1), (0, -1)):\n new_x, new_y = x+dx, y+dy\n if 0 <= new_x < m and 0 <= new_y < n and rooms[new_x][new_y] == 2147483647:\n rooms[new_x][new_y] = dist\n queue.append((new_x, new_y))","def get_partidos_espera_equipos_no_jugando_list(fase):\n\tpartidos_espera_list = get_partidos_espera_list(fase)\n\tpartidos_jugando_list = get_partidos_jugando_list(fase)\n\tequipos_jugando = []\n\tfor partido_jugando in partidos_jugando_list:\n\t\tequipos_jugando.append(partido_jugando.equipo_local)\n\t\tequipos_jugando.append(partido_jugando.equipo_visitante)\n\tpartidos_espera_equipos_no_jugando_list = partidos_espera_list.exclude(equipo_local__in=equipos_jugando) \\\n\t\t.exclude(equipo_visitante__in=equipos_jugando)\n\treturn partidos_espera_equipos_no_jugando_list","def get_item_bedrooms(self, soup: BeautifulSoup) -> None:\n try:\n bedrooms = (\n soup.find(\"div\", class_=\"_kqh46o\")\n .find_all(\"span\", class_=\"_3hmsj\")[1]\n .get_text()\n )\n try:\n bedrooms = re.findall(\"[0-9]+\", bedrooms)[0]\n studio = 0\n except IndexError:\n bedrooms = 1\n studio = 1\n except (AttributeError, IndexError):\n studio = None\n bedrooms = None\n self.__collected_dic[\"studio\"].append(studio)\n self.__collected_dic[\"bedrooms\"].append(bedrooms)","def required_slots(tracker: Tracker) -> List[Text]:\n print(\"required_slots(tracker: Tracker)\")\n return [\"name\",\"roomcount\",\"roomtype\"]","def find_missing_pos_in_motif(motifs, motname_li):\n motifs_def=[]\n n=0\n for motname in motname_li:\n found=[]\n found_ranges=[]\n not_found=[]\n for e in motifs:\n if e[0]==motname:\n if not e[2]:\n not_found.append(e[1])\n else:\n found.append(e[1])\n found_ranges.append(e[3])\n \n num_nf=len(not_found)\n ranges_all=\",\".join(found_ranges)\n if num_nf ==0:\n motifs_def.append([motname,\" , \".join(found),(ranges_all)])\n elif num_nf ==3:\n motifs_def.append([motname,\"Motif not found\",\"None\"])\n else:\n motifs_def.append([motname,(\" , \".join(not_found)+\" not found\"),(ranges_all)])\n n+=1\n return motifs_def","def availableSquares(self):\n List2=[]\n for item in self.all:\n if item.retrieve()==\"\":\n List2.append(item.name())\n return List2","def amenities(self):\n G, mapping = self.network()\n waste = []\n resources = []\n intmed_products = []\n\n for nd in G:\n # if nd[0] != \"r\":\n if not isinstance(nd, int):\n if not G.in_edges(nd):\n resources.append(nd)\n elif not G.out_edges(nd):\n if nd != self.commodity:\n waste.append(nd)\n else:\n intmed_products.append(nd)\n\n return waste, resources, intmed_products","def wallsAndGates(self, rooms: List[List[int]]) -> None:\r\n if not rooms or not rooms[0]:\r\n return\r\n \r\n \r\n m, n = len(rooms), len(rooms[0])\r\n q = deque([])\r\n for i in range(m):\r\n for j in range(n):\r\n if rooms[i][j] == 0:\r\n # 把所有为0坐标一次加入队列\r\n q.append((i,j))\r\n \r\n self.BFS(rooms, q)\r\n return","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n if not rooms or not rooms[0]:\n return\n m, n = len(rooms), len(rooms[0])\n INF = 2147483647\n q = []\n for i in range(m):\n for j in range(n):\n if rooms[i][j] == 0:\n q.append((i, j))\n # bfs\n while q:\n newq = []\n for i, j in q:\n for u, v in [(i-1,j), (i,j+1), (i+1,j), (i,j-1)]:\n if 0 <= u < m and 0 <= v < n and rooms[u][v] == INF:\n rooms[u][v] = rooms[i][j] + 1\n newq.append((u, v))\n q = newq","def excluded_combos(list_1: list[str], list_2: list[str]) -> list[tuple[str, str]]:\n all_combos: list[tuple[str, str]] = []\n for item_1 in list_1:\n for item_2 in list_2:\n all_combos.append((item_1, item_2))\n return [item for item in all_combos if item not in set(representative_combos(list_1, list_2))]","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n queue = deque()\n for i in range(len(rooms)):\n for j in range(len(rooms[0])):\n if rooms[i][j] == 0:\n queue.append((i, j, 0))\n\n while queue:\n i, j, val = queue.popleft()\n if i - 1 >= 0 and rooms[i - 1][j] != -1:\n if val + 1 < rooms[i - 1][j]:\n rooms[i - 1][j] = val + 1\n queue.append((i - 1, j, val + 1))\n if i + 1 < len(rooms) and rooms[i + 1][j] != -1:\n if val + 1 < rooms[i + 1][j]:\n rooms[i + 1][j] = val + 1\n queue.append((i + 1, j, val + 1))\n if j - 1 >= 0 and rooms[i][j - 1] != -1:\n if val + 1 < rooms[i][j - 1]:\n rooms[i][j - 1] = val + 1\n queue.append((i, j - 1, val + 1))\n if j + 1 < len(rooms[0]) and rooms[i][j + 1] != -1:\n if val + 1 < rooms[i][j + 1]:\n rooms[i][j + 1] = val + 1\n queue.append((i, j + 1, val + 1))","def all_clean(room):\r\n\r\n for row in room:\r\n for cell in row:\r\n if cell == \"dirt\":\r\n return False\r\n\r\n return True","def union(cls, availabilities: List[\"Availability\"]) -> List[\"Availability\"]:\n availabilities = list(availabilities)\n if not availabilities:\n return []\n\n availabilities = sorted(availabilities, key=lambda a: a.start)\n result = [availabilities[0]]\n availabilities = availabilities[1:]\n\n for avail in availabilities:\n if avail.overlaps(result[-1], False):\n result[-1] = result[-1].merge_with(avail)\n else:\n result.append(avail)\n\n return result","def compare_battery(self, battery1, battery2, batterieschild):\r\n not_assigned = []\r\n \r\n for index in range(len(battery1.houses)):\r\n if battery1.houses[index] not in battery2.houses:\r\n not_assigned.append(batterieschild.houses[index])\r\n \r\n return not_assigned","def unallocated_spaces(self):\n unallocated_offices = 0\n for office in self.offices:\n unallocated_offices += self.offices[\n office]['room'].unallocated_spaces\n unallocated_living = 0\n for living in self.living_spaces:\n unallocated_living += self.living_spaces[\n living]['room'].unallocated_spaces\n\n return [unallocated_offices, unallocated_living]","def miss_station(all_stations,stations):\n\tdiff = len(all_stations)-len(stations)\n k=0\n i=0\n miss_stations = ['']*diff\n a = all_stations[:]\n a.sort()\n s = stations[:]\n s.sort()\n while i < len(stations):\n while a[i] != s[i]:\n miss_stations[k]=a[i]\n del a[i]\n k+=1\n i+=1\n\treturn miss_stations","def exclude_other_class_items(_items, class_name):\n\n class_skills = class_skill_names(class_name)\n other_skill_names = list(set(all_class_skill_names()) - set(class_skills)) + class_attributes(Classes.DEMON_HUNTER)\n\n def match_invert_skills(item):\n \"\"\" filter items based on if they match a class skill \"\"\"\n text = item.text\n\n if any([skill in text for skill in other_skill_names]):\n if any([skill in text for skill in class_skills]): # double check\n print('found a wizard skill', [skill for skill in class_skills if skill in text])\n print(item)\n return True\n return False\n return True\n\n return list(filter(match_invert_skills, _items))\n\n # def match_invert_skills(_item):\n # \"\"\" filter items based on if they match a class skill \"\"\"\n # text = _item.text\n #\n # if any([skill in text for skill in other_skill_names]):\n #\n # if any([skill in text for skill in class_skills]): # double check\n # print('found aa wizard skill', [skill for skill in class_skills if skill in text])\n # print(_item)\n # return True\n # return False\n #\n # print('lolll')\n # return True\n #\n # print(other_skill_names)\n # to_return = []\n # for item in _items:\n # if match_invert_skills(item):\n # to_return.append(item)\n #\n #\n # return to_return","def unique_rows(self):\n return list(set([coord[0] for coord in self.landscape]))","def GetRoomIndex( data) :\n labels = ['etage', 'roomID']\n columns = data.columns\n\n result =[ l for l in labels if l in columns ]\n if not result : raise RuntimeError( 'No tagging possible for a room' )\n return result","def missing_seat_ids(taken_seats):\n all_seats = set(range(min(taken_seats), max(taken_seats) + 1))\n return(set(taken_seats).symmetric_difference(all_seats))","def find_usable_exits(room, stuff):\n usable = []\n for exit in room['exits']:\n if exit.get(\"hidden\", False):\n continue\n if \"required_key\" in exit:\n if exit[\"required_key\"] in stuff:\n usable.append(exit)\n continue\n usable.append(exit)\n return usable","def createFriendlyEmpireList(self):\n friends = []\n for shipID, myShip in self.myGalaxy.ships.iteritems():\n if shipID not in self.targets and myShip.empireID not in friends:\n friends.append(myShip.empireID)\n return friends","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n if rooms==[]: return\n xcord=len(rooms)\n ycord=len(rooms[0])\n indexstack=[(i,j) for i in range(len(rooms)) for j in range(len(rooms[0])) if rooms[i][j] == 0]\n direction=[(0,1),(1,0),(0,-1),(-1,0)]\n gatenum=1\n while indexstack != []:\n newindex=[]\n for item in indexstack:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if 0<=xpoint <len(rooms) and 0<=ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=gatenum\n newindex.append((xpoint,ypoint))\n indexstack=newindex\n gatenum+=1\n ''''\n for item in index_0:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=1\n index_1.append((xpoint,ypoint))\n for item in index_1:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=2\n index_2.append((xpoint,ypoint))\n for item in index_2:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=3\n index_3.append((xpoint,ypoint))\n for item in index_3:\n for mapdir in direction:\n xpoint=item[0]+mapdir[0]\n ypoint=item[1]+mapdir[1]\n if xpoint <=len(rooms) and ypoint<=len(rooms[0]):\n if rooms[xpoint][ypoint]==pow(2,31)-1:\n rooms[xpoint][ypoint]=4\n #index_3.append((xpoint,ypoint))'''","def no_oversuscribed_sessions(prefs, caps):\n out = []\n for room, cap in caps.items():\n # if room capacity > num students, go to next room \n # since this one is safely undersuscribed\n if cap >= len(prefs):\n continue\n # if a room contains N students, then in every group of N+1 students \n # there must be a student not in that session\n stud_combos = combos(prefs, cap+1)\n for group in stud_combos:\n out.append([('%s_%s' % (stud, room), False) for stud in group])\n return out","def get_missing_seat_ids(boarding_passes: list) -> set:\n seat_ids = {get_seat_id(boarding_pass) for boarding_pass in boarding_passes}\n all_seat_ids = set(range(min(seat_ids), max(seat_ids) + 1))\n return all_seat_ids - seat_ids","def getRoster(self, room):\n if room not in self.rooms.keys():\n return None\n return self.rooms[room].keys()","def get_free_games(self) -> List[Game]:","def possible_items(self):\n available_items = self.floors[self.lift_floor]\n single_items = [(i,) for i in available_items]\n double_items = [i for i in combinations(available_items, 2)]\n return single_items + double_items","def filter(full_poi_list, type_of_poi):\n pois = []\n if type_of_poi == \"all\":\n for i in full_poi_list:\n entry = i[0]\n pois.append(entry)\n if type_of_poi == \"gym\":\n for i in full_poi_list:\n if i[1] == 2:\n entry = i[0]\n pois.append(entry)\n return pois","def __str__(self):\n return 'Classroom {} has a capacity of {} persons and ' \\\n 'has the following equipment: {}.'.format(\n self.number, str(self.capacity), ', '.join(self.equipment))","def get_rooms(self):\n rooms = []\n for i in self.rooms:\n rooms.append(self.rooms[i])\n\n return rooms","def visit_equipment(self, equipment):","def fleets(self):\n\t\treturn [fleet for fleet in self.galaxy.fleets.values() if 'ouid' in fleet.data and fleet.ouid == self.star_id]","def easy_solve_room(self):\n have_res=False\n res=None\n if self.opt_ct==self.gsq_ct:\n if not self.sqs:\n #no sqs, but all reqs; just fill in the reqs!\n have_res=True\n sgs=[]\n for gsq in self.gatesqs:\n if self.isopt(gsq):\n sg=(gsq,'skip',(),(), gsq)\n sgs.append(sg)\n res=all_permutations(sgs)\n elif len(self.gatesqs)==0:\n if self.sqs:\n res=[]\n have_res=True\n else:\n res=[]\n have_res=True\n print 'should never get here!'\n #if not, then break down the subrooms and return their res.\n elif self.opt_ct==0:\n if self.req_ct%2!=0:\n res=[]\n have_res=True\n #dont create internal alleys!\n else:\n for sq in self.sqs:\n neighbors=getopendvs(self.rows,sq)\n if len(neighbors)<2:\n res=[]\n have_res=True\n #~ print 'bad room! has internal alleys at !',sq\n #~ print self\n return have_res,res","def __get_homes_not_on_intersections(x_intercepts: list, y_intercepts: list, homes: list) -> set:\n return {(x, y) for x, y in homes if x not in x_intercepts or y not in y_intercepts}","def getCaseDisp():\r\n liste = []\r\n for i in range(3):\r\n for j in range(3):\r\n if Grille[i][j] == 0:\r\n liste.append([i,j])\r\n return liste","def wallsAndGates(self, rooms: List[List[int]]) -> None:\n if rooms == []:\n return\n \n row = len(rooms)\n column = len(rooms[0])\n visited = [[False for i in range(column)] for j in range(row)]\n def valid(row_index, column_index):\n if row_index < row and row_index >= 0 and column_index< column and column_index >= 0:\n return True\n return False\n \n \n def bfs_traverse(row_index, column_index, distance):\n if valid(row_index, column_index) == False or rooms[row_index][column_index] < distance:\n return\n else:\n # if rooms[row_index] [column_index] != -1 and rooms[row_index] [column_index] != 0:\n\n rooms[row_index][column_index] = distance\n \n bfs_traverse(row_index+1, column_index, distance+1)\n\n bfs_traverse(row_index, column_index +1 , distance+1)\n\n bfs_traverse(row_index-1, column_index, distance+1)\n\n bfs_traverse(row_index, column_index-1, distance+1)\n \n \n for row_index in range(row):\n for column_index in range(column):\n if rooms[row_index][column_index] == 0:\n bfs_traverse(row_index, column_index, 0)","def get_room_ids(self):\n if not self.setup():\n return []\n for room in self.homestatus.rooms:\n self.room_ids.append(room)\n return self.room_ids","def callNurse():\n triageRoom.append(waitingRoom.pop(0))\n #sort(triageRoom,key=patient.triageNumer)","def excluded(cls):\n return []","def print_chromosomes(self):\n count = 0\n while count < len(self.chromo_list):\n #Gets the list at counter\n chromo_list = self.chromo_list[count]\n if type(chromo_list) is ListType:\n \n len_list = len(chromo_list)\n if len_list > 1:\n print \"CONFLICT!!\"\n #Gets the tuple of (Day,Room)\n day_room = self.get_room_day_numbers(count)\n itor = 0\n if chromo_list is not None:\n for chromosomes in chromo_list:\n itor = itor + 1\n #Get course ID to work with\n CourseID = chromosomes._class.get_course_classid()\n #Use CourseInstance to store prof, course, period, room in\n CourseInstance = ClassInstance.objects.get(pk=CourseID)\n\n\n curr_course_class = chromosomes._class\n print \"Day: \" + str(day_room[0])\n print \"Hour: \" + str(count%self.day_length+1)\n print \"Room: \" + str(day_room[1])\n # Period = Period(idPeriod = itor, period = str(count%self.day_length+1), StartDate = day_room[0], EndDate = day_room[0], InstructionBegins = day_room[0], InstructionEnds = day_room[0]) \n ProfID = curr_course_class.get_professor_id()\n Professor = Lecturer.objects.get(pk=ProfID)\n ClassID = curr_course_class.get_course_id()\n Course = Class.objects.get(pk=ClassID)\n CourseInstance.idLecturer = Professor\n CourseInstance.idClass = Course\n CourseInstance.save()\n chromosomes.print_chromo()\n print \"\\n\\n\"\n \n count += 1","def get_disjoint_genes(self, other):\n innovs = {g.innov_num for g in other.link_genes}\n if not innovs:\n return []\n max_innov = max(innovs)\n return [g for g in other.link_genes\n if g.innov_num < max_innov and g.innov_num not in innovs]","def all_rooms(self):\n pass","def all_two_qubit_gates(qc):\n res = []\n for g in qc:\n if len(g[1]) == 2:\n res.append((g[1][0].index, g[1][1].index))\n return res","def _inactiveplayers():\n\n rosters = _activerosters()\n dbrosters = _eidset() # players not in rosters scrape but in db.\n notactive = dbrosters.difference(rosters)\n return notactive","def test_enumerating_no_protomers(self):\n\n mol = Molecule.from_smiles(\"CC\")\n\n assert mol.enumerate_protomers() == []","def test_enumerating_no_protomers(self):\n\n mol = Molecule.from_smiles(\"CC\")\n\n assert mol.enumerate_protomers() == []","def players_with_decks(players):\n return [p for p in players if len(p.deck)]","def getTrainingProgramsParticipated(self)->list:\n returnList = []\n for i in range(0,randint(1,20)):\n randumTrainingProgmId = randint(0,49)\n if randumTrainingProgmId not in returnList:\n returnList.append(randumTrainingProgmId)\n\n return returnList","def get_all_equipped(self):\n\t\t\n\t\treturn (self.get_main_hand_equipped(), None, self.get_armor_equipped(), None, None)","def irreducible_components( self ):\n return tuple([self])","def initialise_room():\n rooms =[] \n for i in range (1,5):\n for x in range (1,4):\n if x == 2: #Double rooms\n room = {'number': i*100+x, 'sort': 'dual', 'booked': False}\n rooms.append(room)\n elif x == 3: #Suite\n room = {'number': i*100+x, 'sort': 'suite', 'booked': False}\n rooms.append(room) \n else: #Individual rooms\n room = {'number': i*100+x, 'sort': 'indiv', 'booked': False}\n rooms.append(room) \n return rooms","def filter_occupied(board_state):\n my_list = [\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"]\n for i in range(0, 9):\n if board_state[i] != \" \":\n my_list.remove(str(i+1))\n return my_list","def equipments(self):\n selection = Equipment.objects.filter(responsible__location_id=self.object.id)\n return {\n 'selection': selection,\n 'count': selection.count()\n }","def available_combinations(self):\n result = []\n\n for i in range(3):\n for j in range(3):\n if self.board[i][j] == 0:\n result.append((i, j))\n\n return result","def find_empty_cells(gr):\n l = list()\n for i in range(0,9):\n for j in range(0,9):\n if(gr[i][j] == 0):\n l.append([i, j])\n return l","def print_room(room):\r\n\r\n for row in room:\r\n for cell in row:\r\n if cell == \"obstacle\":\r\n print(\"O\", end=\"\")\r\n elif cell == \"robot\":\r\n print(\"R\", end=\"\")\r\n elif cell == \"empty\":\r\n print(\" \", end=\"\")\r\n elif cell == \"dirt\":\r\n print(\"*\", end=\"\")\r\n\r\n print()","def delete_gkeeper(alist):\n\n res = [player for player in alist if player[2] != ['Por']]\n\n return res","def info_equipment_get():\n equipment = _equipment_by_group()\n return equipment, 200","def get_living_spaces(self):\n cursor = self.cur()\n cursor.execute('SELECT {col1}, {col2} FROM {tn} WHERE {cn}=\"living_space\"'.format(\n tn=\"room\", cn=\"room_type\", col1=\"name\", col2=\"no_of_members\"))\n living_spaces = cursor.fetchall()\n return living_spaces","def GetFailingStudents(self):\n slist = self.StudentList\n dlist = self.DisciplineList\n glist = self.GradeList\n failing_students = []\n for studentID in slist.IDs:\n glist.SetQueryOptions(FilterAttribute=\"StudentID\", FilterValue=studentID, StrictFilter=True, OrderAttribute=\"ID\", Descending=False)\n disc_sums = {}\n disc_count = {}\n for gradeID in glist.QueryIDs:\n if glist[gradeID].DisciplineID not in disc_sums:\n disc_sums[glist[gradeID].DisciplineID] = glist[gradeID].Value\n disc_count[glist[gradeID].DisciplineID] = 1\n else:\n disc_sums[glist[gradeID].DisciplineID] += glist[gradeID].Value\n disc_count[glist[gradeID].DisciplineID] += 1\n if len(disc_sums) == 0:\n continue\n failing_disciplines = []\n for discID in disc_sums:\n disc_sums[discID] /= disc_count[discID]\n if disc_sums[discID] < 5:\n failing_disciplines.append(discID)\n if len(failing_disciplines) == 0:\n continue\n result = [slist[studentID], []]\n for discID in failing_disciplines:\n result[1].append((dlist[discID], disc_sums[discID]))\n failing_students.append(result)\n return failing_students","def available_sets(session, player):\n excluded_sets = set(session.taken.keys())\n for grouping in session.exclusives:\n if player.sets.intersection(grouping):\n excluded_sets.update(grouping)\n return [s for s in session.sets if s not in excluded_sets]","def get_invalid(cls, instance):\n\n others = [i for i in list(instance.context) if\n i is not instance and\n set(cls.families) & get_families(i)]\n if not others:\n return []\n\n other_ids = defaultdict(list)\n for other in others:\n for _id, members in get_instance_node_ids(other).items():\n other_ids[_id].extend(members)\n\n # Take only the ids with more than one member\n invalid = list()\n ids = get_instance_node_ids(instance)\n for _id, members in ids.iteritems():\n if _id in other_ids:\n cls.log.error(\"ID found on multiple nodes: '%s'\" % members)\n cls.log.debug(\"Clashes with: %s\" % (other_ids[_id],))\n invalid.extend(members)\n\n return invalid","def _filter_empty(lst):\n return [cell for cell in lst if cell is not Sudoku.EMPTY_CELL]","def check_equipped(self):\n equipped_str = \"\"\n for body_part, item in self.equipped.items():\n if item is None:\n equipped_str += f\"On {body_part} slot you have equipped nothing\"\n else:\n equipped_str += f\"On {body_part} slot you have equipped {item}\"\n return equipped_str","def missing_bus_indices(net):\n check_results = {}\n bus_indices = set(net.bus.index)\n element_bus_names = {\"ext_grid\": [\"bus\"], \"load\": [\"bus\"], \"gen\": [\"bus\"], \"sgen\": [\"bus\"],\n \"trafo\": [\"lv_bus\", \"hv_bus\"], \"trafo3w\": [\"lv_bus\", \"mv_bus\", \"hv_bus\"],\n \"switch\": [\"bus\", \"element\"], \"line\": [\"from_bus\", \"to_bus\"]}\n for element in element_bus_names.keys():\n element_check = []\n for i, row in net[element].iterrows():\n for bus_name in element_bus_names[element]:\n if row[bus_name] not in bus_indices:\n if not ((element == \"switch\") and (bus_name == \"element\") and (row.et in ['l', 't', 't3'])):\n element_check.append((i, bus_name, row[bus_name]))\n if element_check:\n check_results[element] = element_check\n\n if check_results:\n return check_results","def addClassroom(classroomName, capacity,location):\n for classroom in classroomEntities:\n if classroom[\"classroomName\"] == classroomName:\n print(\"Two classrooms can not have same name\")\n return False\n\n if classroomEntities==[]:\n lastSavedIdNumber = \"0\"\n else:\n lastSavedId=classroomEntities[-1][\"classroomId\"] #update classroomId as first element in classroomEntities list\n lastSavedIdNumber=lastSavedId[2:]\n numberOfDigitsInID = 3\n if lastSavedIdNumber == \"9\" * len(lastSavedIdNumber):\n numberOfDigitsInID = len(lastSavedIdNumber) + 1\n classroomId=\"CR\"+str(int(lastSavedIdNumber)+1).rjust(numberOfDigitsInID,\"0\")\n\n # add the new Classroom\n newClassroom = {}\n newClassroom[\"classroomId\"] = classroomId\n newClassroom[\"classroomName\"] = classroomName\n newClassroom[\"capacity\"] = capacity\n newClassroom[\"location\"] = location\n classroomEntities.append(newClassroom)\n print(f\"Class Room is added into the system, Class Room id is {classroomId}.\")\n return True","def all_equipment(self):\n\t\tself.db = DB()\n\t\tactivity_all = self.db.select_all_from(\"equipment\")\n\t\ttmpl = lookup.get_template(\"equipment.html\")\n\t\treturn (tmpl.render(equipment=activity_all))","def getAvailableTimeslots(self, allTimeslots) -> [Timeslot]:\r\n # List with all Timeslots any of the Teachers is not available at.\r\n notAvailableTimeslotsTeachers = flatMap(lambda t: t.not_available_timeslots, self.teachers)\r\n # notAvailableTimeslotsTeachers = [item for sublist in map(lambda t: t.not_available_timeslots, self.teachers) for item in sublist]\r\n # If Lesson can only take place on forenoon, create list with all afternoon timeslots.\r\n if self.course.only_forenoon:\r\n notAvailableTimeslotsForenoon = list(filter(lambda t: t.number not in Timeslot.getForenoonTimeslotNumbers(), allTimeslots))\r\n else:\r\n notAvailableTimeslotsForenoon = []\r\n\r\n timeslots = [x for x in allTimeslots if x not in (notAvailableTimeslotsTeachers + notAvailableTimeslotsForenoon)]\r\n if self.available_timeslots: # If list is not empty. Else no restrictions.\r\n timeslots = [x for x in timeslots if x in self.available_timeslots]\r\n\r\n return timeslots","def get_unassigned_devices_for_model(model_number: str, manufacturer: str) -> list:\n\n conn = database_connect()\n if(conn is None):\n return None\n cur = conn.cursor()\n\n try:\n # SQL statement and execute\n sql = \"\"\"SELECT Device.deviceID\n FROM Device\n WHERE Device.manufacturer = %s AND Device.modelNumber = %s AND Device.IssuedTo IS NULL\"\"\"\n cur.execute(sql, (manufacturer, model_number))\n\n # Attempt to fetch all rows\n result = cur.fetchall()\n\n if result == None:\n cur.close()\n conn.close()\n return []\n\n unissued = []\n for row in result:\n unissued.append(\n row[0]\n )\n\n cur.close()\n conn.close()\n return unissued\n except Exception as e:\n print(\"nnn\")\n print(e)\n # If nothing was returned, return empty list\n cur.close()\n conn.close()\n return []\n\n\n # TODO Dummy Data - Change to be useful!\n # Return each device of this model that has not been issued\n # Each \"row\" has: [ device_id ]\n # device_unissued = [123656, 123132, 51413, 8765]\n #\n # return device_unissued","def getOccupied(self):\n occupiedList = []\n for spot in self.parkingSpots:\n if spot.status == 'occupied':\n occupiedList.append(spot)\n return occupiedList","def get_occupants(self):\n return [x.get_occupant_type() for x in self.huts]","def non_mcnugget():\n nugget = [0, 6, 9, 20]\n mcnugget = set([6, 9, 20])\n\n while True:\n mcnugget = set([m+n for m in mcnugget for n in nugget])\n\n for m in mcnugget:\n found = all([m+j in mcnugget for j in range(6)])\n if found:\n return [k for k in range(1, m) if k not in mcnugget]","def map_room_list():\n for room in map_rooms:\n print(f\"{room}: \")\n for description in map_rooms[room]:\n print(f\"{description} - {map_rooms[room][description]}\")","def check_comm(instance):\n\n comm = instance.__dict__.get(\"commodity\")\n\n accounted_comm = set()\n\n for c in comm:\n\n for r in instance.reactions:\n r_dict = r.__dict__\n\n for label, species in r_dict.items():\n\n if instance.__dict__.get(\"recombination\") == Recomb_1:\n product = r_dict.get(\"left2\")\n\n else:\n product = r_dict.get(\"right2\")\n\n if product == c:\n accounted_comm.add(c)\n\n if set(comm) == accounted_comm:\n return True\n else:\n print(\"Commodity:\", set(comm))\n print(\"Commodity products made:\", accounted_comm)\n return False","def find_unmapped_categories(\n self,\n ) -> tuple[set[\"Category\"], set[\"Category\"]]:\n cats_a: set[Category] = set()\n cats_b: set[Category] = set()\n for rule in self.rules:\n cats_a.update(rule.factors_categories_a.keys())\n cats_b.update(rule.factors_categories_b.keys())\n\n cats_missing_a = set(self.categorization_a.values()) - cats_a\n cats_missing_b = set(self.categorization_b.values()) - cats_b\n return cats_missing_a, cats_missing_b"],"string":"[\n \"def check_rooms(self, exclude=[]):\\n stmt = Session.query(Lesson.room, Lesson.day, Lesson.order,\\n Lesson.schedule_id)\\n stmt = stmt.group_by(Lesson.room, Lesson.order, Lesson.day, Lesson.schedule_id)\\n stmt = stmt.having(func.count(Lesson.room)>1)\\n stmt = stmt.filter(not_(Lesson.room.in_(exclude)))\\n stmt = stmt.subquery()\\n q = Session.query(Lesson).join((stmt, and_(\\n Lesson.room == stmt.c.room,\\n Lesson.day == stmt.c.day,\\n Lesson.order == stmt.c.order,\\n Lesson.schedule_id == stmt.c.schedule_id)))\\n q = q.order_by(Lesson.day, Lesson.order, Lesson.room)\\n\\n conflicts = q.all()\\n if len(conflicts) == 0:\\n return []\\n rooms = [[conflicts.pop(0), conflicts.pop(0)]]\\n for c in conflicts:\\n prev = rooms[-1][-1]\\n if c.room == prev.room and c.day == prev.day and c.order == \\\\\\n prev.order and c.schedule_id == prev.schedule_id:\\n rooms[-1].append(c)\\n else:\\n rooms.append([c])\\n return rooms\",\n \"def check_for_unguarded_rooms(museum):\\r\\n\\tempty_rooms = []\\r\\n\\r\\n\\tfor row_idx in range(len(museum)):\\t\\r\\n\\t\\t\\r\\n\\t\\tfor item_idx in range(len(museum[row_idx])): #Go back and fix this to be enumerate instead\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tif museum[row_idx][item_idx] == \\\"0\\\":\\r\\n\\t\\t\\t\\tempty_rooms.append([row_idx, item_idx])\\r\\n\\r\\n\\t# for row_idx, row_value in enumerate(museum):\\r\\n\\t# \\tfor item_idx, item_value in enumerate(row):\\r\\n\\t# \\t\\tif item_value == \\\" \\\":\\r\\n\\t# \\t\\t\\tprint(item)\\r\\n\\t# \\t\\t\\tempty_rooms.append([row_idx, item_idx]) # need index\\r\\n\\r\\n\\tif not empty_rooms:\\r\\n\\t\\tprint(\\\"true\\\")\\r\\n\\t\\r\\n\\telse:\\r\\n\\t\\tprint(\\\"false\\\")\\r\\n\\r\\n\\t\\tfor room in empty_rooms:\\r\\n\\t\\t\\tprint(str(room[0]) + \\\" \\\" + str(room[1]))\",\n \"def check_room(rooms):\\n free_rooms = []\\n booked_rooms = [] \\n for element in rooms:\\n if element['booked'] == False:\\n free_rooms.append(element)\\n else:\\n booked_rooms.append(element)\\n return free_rooms, booked_rooms\",\n \"def captain_room(room_list):\\n captain_room = '' \\n #store the list in total_rooms\\n total_rooms = room_list \\n #get the unique rooms without repetition of any room\\n unique_rooms_num = set(total_rooms) \\n #Remove the unique room from the list of total rooms\\n for n in unique_rooms_num:\\n total_rooms.remove(n) \\n without_captain_room = total_rooms\\n #The original total room list does not contain captain room number anymore\\n #check by print(total_rooms)\\n\\n #Now, Compare the unique room number: that contains captain number with\\n #list without_captain_room\\n for i in unique_rooms_num:\\n if i not in without_captain_room: \\n captain_room = i\\n \\n return captain_room\",\n \"def findUnoccupied( board, occupation):\\n return [ j for j in xrange(len(board.positions))\\n if not occupation.has_key(j) ]\",\n \"def get_room_list():\\n room_list = []\\n # 0\\n room = Room(\\n \\\"Patio. You are in a patio, it is surrounded by four long walls.\\\\n\\\\\\n The south wall has a metal door.\\\",\\n north = None,\\n east = None,\\n south = 2,\\n west = None\\n )\\n room_list.append(room)\\n # 1\\n room = Room(\\n \\\"Bedroom. You are in a bedroom, there is nothing uncommon.\\\\n\\\\\\n The door lead to east\\\",\\n north = None,\\n east = 2,\\n south = None,\\n west = None\\n )\\n room_list.append(room)\\n # 2\\n room = Room(\\n \\\"Kitchen. You are in a kitchen, there is some porridge on the oven.\\\\n\\\\\\n There are three doors, north, west, south\\\",\\n north = 0,\\n east = None,\\n south = 4,\\n west = 1\\n )\\n room_list.append(room)\\n # 3\\n room = Room(\\n \\\"Tv room. You are in the tv room, there is an old tv set, \\\\n\\\\\\n seems like it hasn't being used for years.\\\\n\\\\\\n The door lead to east\\\",\\n north = None,\\n east = 4,\\n south = None,\\n west = None\\n )\\n room_list.append(room)\\n # 4\\n room = Room(\\n \\\"Dinning room. You are in a dinning room, there is a big round table.\\\\n\\\\\\n There are three doors, north, west, south\\\",\\n north = 2,\\n east = None,\\n south = 6,\\n west = 3\\n )\\n room_list.append(room)\\n # 5\\n room = Room(\\n \\\"Master bedroom. You are in the master bedroom, there are many religious things all over.\\\\n\\\\\\n The door lead to east\\\",\\n north = None,\\n east = 6,\\n south = None,\\n west = None\\n )\\n room_list.append(room)\\n # 6\\n room = Room(\\n \\\"Living room. You are in the living room, you can see the exit door to the south.\\\\n\\\\\\n There are three doors, north, west, south\\\",\\n north = 4,\\n east = None,\\n south = 7,\\n west = 5\\n )\\n room_list.append(room)\\n return room_list\",\n \"def rooms_opposite(self, room):\\n if room in self.adjacencies:\\n room_side = self.adjacencies[room][0].self_edge_index\\n other_side = 0 if room_side == 2 else 2\\n return self.adjacencies.filter(lambda obj, info: isinstance(obj, Room) and info.self_edge_index == other_side)\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n if len(rooms)==0:\\n return rooms\\n n, m = len(rooms), len(rooms[0])\\n for i in range(n):\\n for j in range(m):\\n if rooms[i][j] == 0:\\n q= [(i,j,0)]\\n while q:\\n ci, cj , d = q.pop(0)\\n for ni, nj in [(ci+1,cj),(ci-1,cj),(ci,cj+1),(ci,cj-1)]:\\n if 0<=ni<n and 0<=nj<m and rooms[ni][nj]!=-1:\\n if rooms[ni][nj]>d+1:\\n rooms[ni][nj] = d+1\\n q.append((ni,nj,d+1))\\n return rooms\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n def get_gates(rooms):\\n res = []\\n M, N = len(rooms), len(rooms[0])\\n for i in range(M):\\n for j in range(N):\\n if rooms[i][j] == 0:\\n res.append((i, j))\\n return res\\n \\n que = [(i, j, 0) for i, j in get_gates(rooms)]\\n #seen = set()\\n deltas = [[0, 1], [0, -1], [-1, 0], [1, 0]]\\n R, C = len(rooms), len(rooms[0])\\n INF = 2**31 - 1\\n while que:\\n i, j, distance = que.pop(0)\\n for dx, dy in deltas:\\n x, y = i + dx, j + dy\\n if 0 <= x < R and 0 <= y < C and rooms[x][y] == INF:\\n rooms[x][y] = distance + 1\\n que.append((x, y, distance + 1))\",\n \"def find_all_available_rooms(self) -> webelement:\\n\\n available_rooms = list()\\n room_listing_section = self.__get_room_listing_section()\\n location_div_list = room_listing_section.find_elements(\\n By.XPATH,\\n \\\".//div[contains(@class, 'room_listing_bg')]\\\"\\n )\\n for location_div in location_div_list:\\n house_name = location_div.find_element(\\n By.XPATH,\\n \\\".//div[1]/h2[@class='room_data_headline']\\\"\\n ).text\\n room_list_table = location_div.find_element(\\n By.XPATH,\\n \\\".//table[contains(@class, 'room_data_table')]\\\"\\n )\\n room_tr_list = room_list_table.find_elements(By.TAG_NAME, \\\"tr\\\")\\n room_tr_list = room_tr_list[1:]\\n for room_tr in room_tr_list:\\n room_type = room_tr.find_element(By.XPATH, \\\".//td[1]\\\").text\\n number_of_persons = room_tr.find_element(By.XPATH, \\\".//td[2]\\\").text\\n free_at = room_tr.find_element(By.XPATH, \\\".//td[3]\\\").text\\n free_at = re.sub(r'^([^\\\\s]*)\\\\s+', r'\\\\1, ', free_at)\\n price_euro = room_tr.find_element(By.XPATH, \\\".//td[4]\\\").text\\n size_square_meter = room_tr.find_element(By.XPATH, \\\".//td[5]\\\").text\\n floor = room_tr.find_element(By.XPATH, \\\".//td[6]\\\").text\\n selection_radios = room_tr.find_elements(By.XPATH, \\\".//td[7]/input[@type='radio']\\\")\\n if len(selection_radios) > 0:\\n radio_value = selection_radios[0].get_attribute(\\\"value\\\")\\n available_rooms.append(\\n RoomInfo(\\n house_name,\\n room_type,\\n number_of_persons,\\n free_at,\\n price_euro,\\n size_square_meter,\\n floor,\\n radio_value\\n )\\n )\\n\\n return available_rooms\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n rows = len(rooms)\\n if rows == 0:\\n return\\n cols = len(rooms[0])\\n GATE = 0\\n EMPTY = pow(2, 31) - 1\\n DIRECTIONS = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n q = deque([])\\n for i in range(rows):\\n for j in range(cols):\\n if rooms[i][j] == GATE:\\n q.append((i, j))\\n while q:\\n x, y = q.popleft()\\n for idx, idy in DIRECTIONS:\\n if x + idx < 0 or x + idx >= rows or y + idy < 0 or y + idy >= cols or rooms[x + idx][y + idy] != EMPTY:\\n continue\\n rooms[x + idx][y + idy] = rooms[x][y] + 1\\n q.append((x + idx, y + idy))\",\n \"def possible_rooms(self):\\r\\n return self.rooms\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n offsets = [[0,1],[1,0],[0,-1],[-1,0]]\\n size = [len(rooms), len(rooms[0])]\\n q = []\\n for i in range(len(rooms)):\\n for j in range(len(rooms[i])):\\n if rooms[i][j] == 0:\\n q.append([i,j])\\n while len(q) != 0:\\n cur = q.pop(0)\\n for i in offsets:\\n x = cur[0]+i[0]\\n y = cur[1]+i[1]\\n if x >= size[0] or x<0 or y>=size[1] or y<0 or rooms[x][y] != 2147483647:\\n continue\\n rooms[x][y] = rooms[cur[0]][cur[1]]+1\\n q.append([x,y])\",\n \"def get_equipment_from_inventory(self):\\n return [x for x in self.inventory if x.is_equip()]\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n if not rooms or not rooms[0]:\\n return \\n \\n queue = deque([])\\n for i in range(len(rooms)):\\n for j in range(len(rooms[i])):\\n if rooms[i][j] == 0:\\n queue.append((i,j, 0))\\n \\n visited = set()\\n while queue:\\n i, j, distance = queue.popleft()\\n \\n if not (0 <= i < len(rooms) and 0 <= j < len(rooms[0])):\\n continue\\n \\n if rooms[i][j] == -1:\\n continue\\n \\n if (i, j) in visited:\\n continue\\n \\n visited.add((i, j))\\n if rooms[i][j] != 0:\\n rooms[i][j] = distance\\n \\n for offset in OFFSETS:\\n queue.append((i + offset[0], j + offset[1], distance + 1))\",\n \"def find_missing_pos_in_motif_otherclass(motifs, motname_li,dict_class,current_class):\\n motifs_def=[]\\n n=0\\n for motname in motname_li:\\n found=[]\\n found_ranges=[]\\n not_found=[]\\n for e in motifs:\\n if e[0]==motname:\\n if not e[2]:\\n not_found.append(e[1])\\n else:\\n motpos= e[1] + current_class.lower() + \\\" = \\\" + e[4] +dict_class.lower()\\n found.append(motpos)\\n found_ranges.append(e[3])\\n \\n num_nf=len(not_found)\\n ranges_all=\\\",\\\".join(found_ranges)\\n if num_nf ==0:\\n motifs_def.append([motname,\\\" ; \\\".join(found),(ranges_all)])\\n elif num_nf ==3:\\n motifs_def.append([motname,\\\"Motif not found\\\",\\\"None\\\"])\\n else:\\n motifs_def.append([motname,(\\\" ; \\\".join(found) + \\\" (\\\" + \\\" , \\\".join(not_found) + \\\" not found)\\\"),(ranges_all)])\\n n+=1\\n return motifs_def\",\n \"def getNotMyCamps(self):\\n r = []\\n for p in self.__camps:\\n if(p.getOwner() != 1):\\n r.append(p)\\n return r\",\n \"def get_room_names(soup: bs4.BeautifulSoup) -> Iterable[str]:\\n return set(x.string for x in soup.Lecture.find_all(\\\"RaumBez\\\"))\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n lenm = len(rooms)\\n lenn = len(rooms[0])\\n \\n queue = []\\n visited = set()\\n \\n direction = [(0,1),(1,0),(0,-1),(-1,0)]\\n \\n for i in range(lenm):\\n for j in range(lenn):\\n if rooms[i][j] == 0:\\n queue.append(((i,j),0))\\n visited.add((i,j))\\n while queue:\\n n = len(queue)\\n for _ in range(n):\\n (a,b),val = queue.pop(0)\\n if rooms[a][b] != -1:\\n rooms[a][b] = val\\n for x,y in direction:\\n i = a+x\\n j = b+y\\n if i <0 or i>=lenm or j<0 or j>=lenn or rooms[i][j] == -1:\\n continue\\n if (i,j) not in visited:\\n visited.add((i,j))\\n queue.append(((i,j),val+1))\\n \\n \\n \\n \\n return rooms\",\n \"def __repr__(self):\\n return \\\"Classroom('{}', {}, {})\\\".format(self.number, self.capacity,\\n str(self.equipment))\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\r\\n if not rooms:\\r\\n return rooms\\r\\n \\r\\n ind_0s = []\\r\\n len_row = len(rooms)\\r\\n len_col = len(rooms[0])\\r\\n for i in range(len_row):\\r\\n for j in range(len_col):\\r\\n if rooms[i][j] == 0:\\r\\n ind_0s.append((i,j))\\r\\n que = ind_0s\\r\\n while que:\\r\\n i,j = que.pop()\\r\\n neighbors = [(i,j-1), (i-1,j), (i,j+1), (i+1,j)]\\r\\n if rooms[i][j] == 0:\\r\\n parent_distance = 0\\r\\n else:\\r\\n parent_distance = rooms[i][j]\\r\\n for x, y in neighbors:\\r\\n if x>=0 and x<len_row and y>=0 and y<len_col and rooms[x][y]!=-1 and rooms[x][y] and \\\\\\r\\n parent_distance+1 < rooms[x][y]:\\r\\n que.append((x,y))\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n ## bfs:\\n queue= []\\n for r in range(len(rooms)):\\n for c in range(len(rooms[0])):\\n if rooms[r][c]==0:\\n queue.append((r,c, 0)) \\n \\n while queue:\\n r,c, l= queue.pop(0)\\n for new_r, new_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:\\n if new_r>=0 and new_c>=0 and new_r<len(rooms) and \\\\\\n new_c<len(rooms[0]) and rooms[new_r][new_c]==2**31 -1:\\n rooms[new_r][new_c]=l+1\\n queue.append((new_r, new_c, l+1))\\n return rooms\",\n \"def _find_homeless_mps(self):\\n mps = Person.objects.filter(\\n active=True,\\n house__name=HOUSE_OF_COMMONS,\\n constituency=None,\\n )\\n\\n self.stdout('MPs with missing constituency:')\\n for mp in mps:\\n self.stdout(f' [{mp.parliamentdotuk}] {mp.name} has no constituency')\",\n \"def _find_memberless_constituencies(self):\\n constituencies = Constituency.objects.filter(\\n end=None, # Constituency currently exists/is not historical\\n mp=None,\\n )\\n\\n self.stdout('Constituencies with missing MP:')\\n for constituency in constituencies:\\n self.stdout(f'[{constituency.parliamentdotuk}] {constituency.name} {constituency.start}')\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n # start with the gate and search the empty cells it can reach\\n # then we take the smallest one\\n if not rooms:\\n return\\n\\n m, n = len(rooms), len(rooms[0])\\n \\n queue = []\\n for i in range(m):\\n for j in range(n):\\n if rooms[i][j] == 0:\\n queue.append((i, j))\\n\\n\\n for x, y in queue:\\n dist = rooms[x][y] + 1\\n\\n for dx, dy in ((-1, 0), (1, 0), (0, 1), (0, -1)):\\n new_x, new_y = x+dx, y+dy\\n if 0 <= new_x < m and 0 <= new_y < n and rooms[new_x][new_y] == 2147483647:\\n rooms[new_x][new_y] = dist\\n queue.append((new_x, new_y))\",\n \"def get_partidos_espera_equipos_no_jugando_list(fase):\\n\\tpartidos_espera_list = get_partidos_espera_list(fase)\\n\\tpartidos_jugando_list = get_partidos_jugando_list(fase)\\n\\tequipos_jugando = []\\n\\tfor partido_jugando in partidos_jugando_list:\\n\\t\\tequipos_jugando.append(partido_jugando.equipo_local)\\n\\t\\tequipos_jugando.append(partido_jugando.equipo_visitante)\\n\\tpartidos_espera_equipos_no_jugando_list = partidos_espera_list.exclude(equipo_local__in=equipos_jugando) \\\\\\n\\t\\t.exclude(equipo_visitante__in=equipos_jugando)\\n\\treturn partidos_espera_equipos_no_jugando_list\",\n \"def get_item_bedrooms(self, soup: BeautifulSoup) -> None:\\n try:\\n bedrooms = (\\n soup.find(\\\"div\\\", class_=\\\"_kqh46o\\\")\\n .find_all(\\\"span\\\", class_=\\\"_3hmsj\\\")[1]\\n .get_text()\\n )\\n try:\\n bedrooms = re.findall(\\\"[0-9]+\\\", bedrooms)[0]\\n studio = 0\\n except IndexError:\\n bedrooms = 1\\n studio = 1\\n except (AttributeError, IndexError):\\n studio = None\\n bedrooms = None\\n self.__collected_dic[\\\"studio\\\"].append(studio)\\n self.__collected_dic[\\\"bedrooms\\\"].append(bedrooms)\",\n \"def required_slots(tracker: Tracker) -> List[Text]:\\n print(\\\"required_slots(tracker: Tracker)\\\")\\n return [\\\"name\\\",\\\"roomcount\\\",\\\"roomtype\\\"]\",\n \"def find_missing_pos_in_motif(motifs, motname_li):\\n motifs_def=[]\\n n=0\\n for motname in motname_li:\\n found=[]\\n found_ranges=[]\\n not_found=[]\\n for e in motifs:\\n if e[0]==motname:\\n if not e[2]:\\n not_found.append(e[1])\\n else:\\n found.append(e[1])\\n found_ranges.append(e[3])\\n \\n num_nf=len(not_found)\\n ranges_all=\\\",\\\".join(found_ranges)\\n if num_nf ==0:\\n motifs_def.append([motname,\\\" , \\\".join(found),(ranges_all)])\\n elif num_nf ==3:\\n motifs_def.append([motname,\\\"Motif not found\\\",\\\"None\\\"])\\n else:\\n motifs_def.append([motname,(\\\" , \\\".join(not_found)+\\\" not found\\\"),(ranges_all)])\\n n+=1\\n return motifs_def\",\n \"def availableSquares(self):\\n List2=[]\\n for item in self.all:\\n if item.retrieve()==\\\"\\\":\\n List2.append(item.name())\\n return List2\",\n \"def amenities(self):\\n G, mapping = self.network()\\n waste = []\\n resources = []\\n intmed_products = []\\n\\n for nd in G:\\n # if nd[0] != \\\"r\\\":\\n if not isinstance(nd, int):\\n if not G.in_edges(nd):\\n resources.append(nd)\\n elif not G.out_edges(nd):\\n if nd != self.commodity:\\n waste.append(nd)\\n else:\\n intmed_products.append(nd)\\n\\n return waste, resources, intmed_products\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\r\\n if not rooms or not rooms[0]:\\r\\n return\\r\\n \\r\\n \\r\\n m, n = len(rooms), len(rooms[0])\\r\\n q = deque([])\\r\\n for i in range(m):\\r\\n for j in range(n):\\r\\n if rooms[i][j] == 0:\\r\\n # 把所有为0坐标一次加入队列\\r\\n q.append((i,j))\\r\\n \\r\\n self.BFS(rooms, q)\\r\\n return\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n if not rooms or not rooms[0]:\\n return\\n m, n = len(rooms), len(rooms[0])\\n INF = 2147483647\\n q = []\\n for i in range(m):\\n for j in range(n):\\n if rooms[i][j] == 0:\\n q.append((i, j))\\n # bfs\\n while q:\\n newq = []\\n for i, j in q:\\n for u, v in [(i-1,j), (i,j+1), (i+1,j), (i,j-1)]:\\n if 0 <= u < m and 0 <= v < n and rooms[u][v] == INF:\\n rooms[u][v] = rooms[i][j] + 1\\n newq.append((u, v))\\n q = newq\",\n \"def excluded_combos(list_1: list[str], list_2: list[str]) -> list[tuple[str, str]]:\\n all_combos: list[tuple[str, str]] = []\\n for item_1 in list_1:\\n for item_2 in list_2:\\n all_combos.append((item_1, item_2))\\n return [item for item in all_combos if item not in set(representative_combos(list_1, list_2))]\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n queue = deque()\\n for i in range(len(rooms)):\\n for j in range(len(rooms[0])):\\n if rooms[i][j] == 0:\\n queue.append((i, j, 0))\\n\\n while queue:\\n i, j, val = queue.popleft()\\n if i - 1 >= 0 and rooms[i - 1][j] != -1:\\n if val + 1 < rooms[i - 1][j]:\\n rooms[i - 1][j] = val + 1\\n queue.append((i - 1, j, val + 1))\\n if i + 1 < len(rooms) and rooms[i + 1][j] != -1:\\n if val + 1 < rooms[i + 1][j]:\\n rooms[i + 1][j] = val + 1\\n queue.append((i + 1, j, val + 1))\\n if j - 1 >= 0 and rooms[i][j - 1] != -1:\\n if val + 1 < rooms[i][j - 1]:\\n rooms[i][j - 1] = val + 1\\n queue.append((i, j - 1, val + 1))\\n if j + 1 < len(rooms[0]) and rooms[i][j + 1] != -1:\\n if val + 1 < rooms[i][j + 1]:\\n rooms[i][j + 1] = val + 1\\n queue.append((i, j + 1, val + 1))\",\n \"def all_clean(room):\\r\\n\\r\\n for row in room:\\r\\n for cell in row:\\r\\n if cell == \\\"dirt\\\":\\r\\n return False\\r\\n\\r\\n return True\",\n \"def union(cls, availabilities: List[\\\"Availability\\\"]) -> List[\\\"Availability\\\"]:\\n availabilities = list(availabilities)\\n if not availabilities:\\n return []\\n\\n availabilities = sorted(availabilities, key=lambda a: a.start)\\n result = [availabilities[0]]\\n availabilities = availabilities[1:]\\n\\n for avail in availabilities:\\n if avail.overlaps(result[-1], False):\\n result[-1] = result[-1].merge_with(avail)\\n else:\\n result.append(avail)\\n\\n return result\",\n \"def compare_battery(self, battery1, battery2, batterieschild):\\r\\n not_assigned = []\\r\\n \\r\\n for index in range(len(battery1.houses)):\\r\\n if battery1.houses[index] not in battery2.houses:\\r\\n not_assigned.append(batterieschild.houses[index])\\r\\n \\r\\n return not_assigned\",\n \"def unallocated_spaces(self):\\n unallocated_offices = 0\\n for office in self.offices:\\n unallocated_offices += self.offices[\\n office]['room'].unallocated_spaces\\n unallocated_living = 0\\n for living in self.living_spaces:\\n unallocated_living += self.living_spaces[\\n living]['room'].unallocated_spaces\\n\\n return [unallocated_offices, unallocated_living]\",\n \"def miss_station(all_stations,stations):\\n\\tdiff = len(all_stations)-len(stations)\\n k=0\\n i=0\\n miss_stations = ['']*diff\\n a = all_stations[:]\\n a.sort()\\n s = stations[:]\\n s.sort()\\n while i < len(stations):\\n while a[i] != s[i]:\\n miss_stations[k]=a[i]\\n del a[i]\\n k+=1\\n i+=1\\n\\treturn miss_stations\",\n \"def exclude_other_class_items(_items, class_name):\\n\\n class_skills = class_skill_names(class_name)\\n other_skill_names = list(set(all_class_skill_names()) - set(class_skills)) + class_attributes(Classes.DEMON_HUNTER)\\n\\n def match_invert_skills(item):\\n \\\"\\\"\\\" filter items based on if they match a class skill \\\"\\\"\\\"\\n text = item.text\\n\\n if any([skill in text for skill in other_skill_names]):\\n if any([skill in text for skill in class_skills]): # double check\\n print('found a wizard skill', [skill for skill in class_skills if skill in text])\\n print(item)\\n return True\\n return False\\n return True\\n\\n return list(filter(match_invert_skills, _items))\\n\\n # def match_invert_skills(_item):\\n # \\\"\\\"\\\" filter items based on if they match a class skill \\\"\\\"\\\"\\n # text = _item.text\\n #\\n # if any([skill in text for skill in other_skill_names]):\\n #\\n # if any([skill in text for skill in class_skills]): # double check\\n # print('found aa wizard skill', [skill for skill in class_skills if skill in text])\\n # print(_item)\\n # return True\\n # return False\\n #\\n # print('lolll')\\n # return True\\n #\\n # print(other_skill_names)\\n # to_return = []\\n # for item in _items:\\n # if match_invert_skills(item):\\n # to_return.append(item)\\n #\\n #\\n # return to_return\",\n \"def unique_rows(self):\\n return list(set([coord[0] for coord in self.landscape]))\",\n \"def GetRoomIndex( data) :\\n labels = ['etage', 'roomID']\\n columns = data.columns\\n\\n result =[ l for l in labels if l in columns ]\\n if not result : raise RuntimeError( 'No tagging possible for a room' )\\n return result\",\n \"def missing_seat_ids(taken_seats):\\n all_seats = set(range(min(taken_seats), max(taken_seats) + 1))\\n return(set(taken_seats).symmetric_difference(all_seats))\",\n \"def find_usable_exits(room, stuff):\\n usable = []\\n for exit in room['exits']:\\n if exit.get(\\\"hidden\\\", False):\\n continue\\n if \\\"required_key\\\" in exit:\\n if exit[\\\"required_key\\\"] in stuff:\\n usable.append(exit)\\n continue\\n usable.append(exit)\\n return usable\",\n \"def createFriendlyEmpireList(self):\\n friends = []\\n for shipID, myShip in self.myGalaxy.ships.iteritems():\\n if shipID not in self.targets and myShip.empireID not in friends:\\n friends.append(myShip.empireID)\\n return friends\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n if rooms==[]: return\\n xcord=len(rooms)\\n ycord=len(rooms[0])\\n indexstack=[(i,j) for i in range(len(rooms)) for j in range(len(rooms[0])) if rooms[i][j] == 0]\\n direction=[(0,1),(1,0),(0,-1),(-1,0)]\\n gatenum=1\\n while indexstack != []:\\n newindex=[]\\n for item in indexstack:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if 0<=xpoint <len(rooms) and 0<=ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=gatenum\\n newindex.append((xpoint,ypoint))\\n indexstack=newindex\\n gatenum+=1\\n ''''\\n for item in index_0:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=1\\n index_1.append((xpoint,ypoint))\\n for item in index_1:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=2\\n index_2.append((xpoint,ypoint))\\n for item in index_2:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <len(rooms) and ypoint<len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=3\\n index_3.append((xpoint,ypoint))\\n for item in index_3:\\n for mapdir in direction:\\n xpoint=item[0]+mapdir[0]\\n ypoint=item[1]+mapdir[1]\\n if xpoint <=len(rooms) and ypoint<=len(rooms[0]):\\n if rooms[xpoint][ypoint]==pow(2,31)-1:\\n rooms[xpoint][ypoint]=4\\n #index_3.append((xpoint,ypoint))'''\",\n \"def no_oversuscribed_sessions(prefs, caps):\\n out = []\\n for room, cap in caps.items():\\n # if room capacity > num students, go to next room \\n # since this one is safely undersuscribed\\n if cap >= len(prefs):\\n continue\\n # if a room contains N students, then in every group of N+1 students \\n # there must be a student not in that session\\n stud_combos = combos(prefs, cap+1)\\n for group in stud_combos:\\n out.append([('%s_%s' % (stud, room), False) for stud in group])\\n return out\",\n \"def get_missing_seat_ids(boarding_passes: list) -> set:\\n seat_ids = {get_seat_id(boarding_pass) for boarding_pass in boarding_passes}\\n all_seat_ids = set(range(min(seat_ids), max(seat_ids) + 1))\\n return all_seat_ids - seat_ids\",\n \"def getRoster(self, room):\\n if room not in self.rooms.keys():\\n return None\\n return self.rooms[room].keys()\",\n \"def get_free_games(self) -> List[Game]:\",\n \"def possible_items(self):\\n available_items = self.floors[self.lift_floor]\\n single_items = [(i,) for i in available_items]\\n double_items = [i for i in combinations(available_items, 2)]\\n return single_items + double_items\",\n \"def filter(full_poi_list, type_of_poi):\\n pois = []\\n if type_of_poi == \\\"all\\\":\\n for i in full_poi_list:\\n entry = i[0]\\n pois.append(entry)\\n if type_of_poi == \\\"gym\\\":\\n for i in full_poi_list:\\n if i[1] == 2:\\n entry = i[0]\\n pois.append(entry)\\n return pois\",\n \"def __str__(self):\\n return 'Classroom {} has a capacity of {} persons and ' \\\\\\n 'has the following equipment: {}.'.format(\\n self.number, str(self.capacity), ', '.join(self.equipment))\",\n \"def get_rooms(self):\\n rooms = []\\n for i in self.rooms:\\n rooms.append(self.rooms[i])\\n\\n return rooms\",\n \"def visit_equipment(self, equipment):\",\n \"def fleets(self):\\n\\t\\treturn [fleet for fleet in self.galaxy.fleets.values() if 'ouid' in fleet.data and fleet.ouid == self.star_id]\",\n \"def easy_solve_room(self):\\n have_res=False\\n res=None\\n if self.opt_ct==self.gsq_ct:\\n if not self.sqs:\\n #no sqs, but all reqs; just fill in the reqs!\\n have_res=True\\n sgs=[]\\n for gsq in self.gatesqs:\\n if self.isopt(gsq):\\n sg=(gsq,'skip',(),(), gsq)\\n sgs.append(sg)\\n res=all_permutations(sgs)\\n elif len(self.gatesqs)==0:\\n if self.sqs:\\n res=[]\\n have_res=True\\n else:\\n res=[]\\n have_res=True\\n print 'should never get here!'\\n #if not, then break down the subrooms and return their res.\\n elif self.opt_ct==0:\\n if self.req_ct%2!=0:\\n res=[]\\n have_res=True\\n #dont create internal alleys!\\n else:\\n for sq in self.sqs:\\n neighbors=getopendvs(self.rows,sq)\\n if len(neighbors)<2:\\n res=[]\\n have_res=True\\n #~ print 'bad room! has internal alleys at !',sq\\n #~ print self\\n return have_res,res\",\n \"def __get_homes_not_on_intersections(x_intercepts: list, y_intercepts: list, homes: list) -> set:\\n return {(x, y) for x, y in homes if x not in x_intercepts or y not in y_intercepts}\",\n \"def getCaseDisp():\\r\\n liste = []\\r\\n for i in range(3):\\r\\n for j in range(3):\\r\\n if Grille[i][j] == 0:\\r\\n liste.append([i,j])\\r\\n return liste\",\n \"def wallsAndGates(self, rooms: List[List[int]]) -> None:\\n if rooms == []:\\n return\\n \\n row = len(rooms)\\n column = len(rooms[0])\\n visited = [[False for i in range(column)] for j in range(row)]\\n def valid(row_index, column_index):\\n if row_index < row and row_index >= 0 and column_index< column and column_index >= 0:\\n return True\\n return False\\n \\n \\n def bfs_traverse(row_index, column_index, distance):\\n if valid(row_index, column_index) == False or rooms[row_index][column_index] < distance:\\n return\\n else:\\n # if rooms[row_index] [column_index] != -1 and rooms[row_index] [column_index] != 0:\\n\\n rooms[row_index][column_index] = distance\\n \\n bfs_traverse(row_index+1, column_index, distance+1)\\n\\n bfs_traverse(row_index, column_index +1 , distance+1)\\n\\n bfs_traverse(row_index-1, column_index, distance+1)\\n\\n bfs_traverse(row_index, column_index-1, distance+1)\\n \\n \\n for row_index in range(row):\\n for column_index in range(column):\\n if rooms[row_index][column_index] == 0:\\n bfs_traverse(row_index, column_index, 0)\",\n \"def get_room_ids(self):\\n if not self.setup():\\n return []\\n for room in self.homestatus.rooms:\\n self.room_ids.append(room)\\n return self.room_ids\",\n \"def callNurse():\\n triageRoom.append(waitingRoom.pop(0))\\n #sort(triageRoom,key=patient.triageNumer)\",\n \"def excluded(cls):\\n return []\",\n \"def print_chromosomes(self):\\n count = 0\\n while count < len(self.chromo_list):\\n #Gets the list at counter\\n chromo_list = self.chromo_list[count]\\n if type(chromo_list) is ListType:\\n \\n len_list = len(chromo_list)\\n if len_list > 1:\\n print \\\"CONFLICT!!\\\"\\n #Gets the tuple of (Day,Room)\\n day_room = self.get_room_day_numbers(count)\\n itor = 0\\n if chromo_list is not None:\\n for chromosomes in chromo_list:\\n itor = itor + 1\\n #Get course ID to work with\\n CourseID = chromosomes._class.get_course_classid()\\n #Use CourseInstance to store prof, course, period, room in\\n CourseInstance = ClassInstance.objects.get(pk=CourseID)\\n\\n\\n curr_course_class = chromosomes._class\\n print \\\"Day: \\\" + str(day_room[0])\\n print \\\"Hour: \\\" + str(count%self.day_length+1)\\n print \\\"Room: \\\" + str(day_room[1])\\n # Period = Period(idPeriod = itor, period = str(count%self.day_length+1), StartDate = day_room[0], EndDate = day_room[0], InstructionBegins = day_room[0], InstructionEnds = day_room[0]) \\n ProfID = curr_course_class.get_professor_id()\\n Professor = Lecturer.objects.get(pk=ProfID)\\n ClassID = curr_course_class.get_course_id()\\n Course = Class.objects.get(pk=ClassID)\\n CourseInstance.idLecturer = Professor\\n CourseInstance.idClass = Course\\n CourseInstance.save()\\n chromosomes.print_chromo()\\n print \\\"\\\\n\\\\n\\\"\\n \\n count += 1\",\n \"def get_disjoint_genes(self, other):\\n innovs = {g.innov_num for g in other.link_genes}\\n if not innovs:\\n return []\\n max_innov = max(innovs)\\n return [g for g in other.link_genes\\n if g.innov_num < max_innov and g.innov_num not in innovs]\",\n \"def all_rooms(self):\\n pass\",\n \"def all_two_qubit_gates(qc):\\n res = []\\n for g in qc:\\n if len(g[1]) == 2:\\n res.append((g[1][0].index, g[1][1].index))\\n return res\",\n \"def _inactiveplayers():\\n\\n rosters = _activerosters()\\n dbrosters = _eidset() # players not in rosters scrape but in db.\\n notactive = dbrosters.difference(rosters)\\n return notactive\",\n \"def test_enumerating_no_protomers(self):\\n\\n mol = Molecule.from_smiles(\\\"CC\\\")\\n\\n assert mol.enumerate_protomers() == []\",\n \"def test_enumerating_no_protomers(self):\\n\\n mol = Molecule.from_smiles(\\\"CC\\\")\\n\\n assert mol.enumerate_protomers() == []\",\n \"def players_with_decks(players):\\n return [p for p in players if len(p.deck)]\",\n \"def getTrainingProgramsParticipated(self)->list:\\n returnList = []\\n for i in range(0,randint(1,20)):\\n randumTrainingProgmId = randint(0,49)\\n if randumTrainingProgmId not in returnList:\\n returnList.append(randumTrainingProgmId)\\n\\n return returnList\",\n \"def get_all_equipped(self):\\n\\t\\t\\n\\t\\treturn (self.get_main_hand_equipped(), None, self.get_armor_equipped(), None, None)\",\n \"def irreducible_components( self ):\\n return tuple([self])\",\n \"def initialise_room():\\n rooms =[] \\n for i in range (1,5):\\n for x in range (1,4):\\n if x == 2: #Double rooms\\n room = {'number': i*100+x, 'sort': 'dual', 'booked': False}\\n rooms.append(room)\\n elif x == 3: #Suite\\n room = {'number': i*100+x, 'sort': 'suite', 'booked': False}\\n rooms.append(room) \\n else: #Individual rooms\\n room = {'number': i*100+x, 'sort': 'indiv', 'booked': False}\\n rooms.append(room) \\n return rooms\",\n \"def filter_occupied(board_state):\\n my_list = [\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"5\\\", \\\"6\\\", \\\"7\\\", \\\"8\\\", \\\"9\\\"]\\n for i in range(0, 9):\\n if board_state[i] != \\\" \\\":\\n my_list.remove(str(i+1))\\n return my_list\",\n \"def equipments(self):\\n selection = Equipment.objects.filter(responsible__location_id=self.object.id)\\n return {\\n 'selection': selection,\\n 'count': selection.count()\\n }\",\n \"def available_combinations(self):\\n result = []\\n\\n for i in range(3):\\n for j in range(3):\\n if self.board[i][j] == 0:\\n result.append((i, j))\\n\\n return result\",\n \"def find_empty_cells(gr):\\n l = list()\\n for i in range(0,9):\\n for j in range(0,9):\\n if(gr[i][j] == 0):\\n l.append([i, j])\\n return l\",\n \"def print_room(room):\\r\\n\\r\\n for row in room:\\r\\n for cell in row:\\r\\n if cell == \\\"obstacle\\\":\\r\\n print(\\\"O\\\", end=\\\"\\\")\\r\\n elif cell == \\\"robot\\\":\\r\\n print(\\\"R\\\", end=\\\"\\\")\\r\\n elif cell == \\\"empty\\\":\\r\\n print(\\\" \\\", end=\\\"\\\")\\r\\n elif cell == \\\"dirt\\\":\\r\\n print(\\\"*\\\", end=\\\"\\\")\\r\\n\\r\\n print()\",\n \"def delete_gkeeper(alist):\\n\\n res = [player for player in alist if player[2] != ['Por']]\\n\\n return res\",\n \"def info_equipment_get():\\n equipment = _equipment_by_group()\\n return equipment, 200\",\n \"def get_living_spaces(self):\\n cursor = self.cur()\\n cursor.execute('SELECT {col1}, {col2} FROM {tn} WHERE {cn}=\\\"living_space\\\"'.format(\\n tn=\\\"room\\\", cn=\\\"room_type\\\", col1=\\\"name\\\", col2=\\\"no_of_members\\\"))\\n living_spaces = cursor.fetchall()\\n return living_spaces\",\n \"def GetFailingStudents(self):\\n slist = self.StudentList\\n dlist = self.DisciplineList\\n glist = self.GradeList\\n failing_students = []\\n for studentID in slist.IDs:\\n glist.SetQueryOptions(FilterAttribute=\\\"StudentID\\\", FilterValue=studentID, StrictFilter=True, OrderAttribute=\\\"ID\\\", Descending=False)\\n disc_sums = {}\\n disc_count = {}\\n for gradeID in glist.QueryIDs:\\n if glist[gradeID].DisciplineID not in disc_sums:\\n disc_sums[glist[gradeID].DisciplineID] = glist[gradeID].Value\\n disc_count[glist[gradeID].DisciplineID] = 1\\n else:\\n disc_sums[glist[gradeID].DisciplineID] += glist[gradeID].Value\\n disc_count[glist[gradeID].DisciplineID] += 1\\n if len(disc_sums) == 0:\\n continue\\n failing_disciplines = []\\n for discID in disc_sums:\\n disc_sums[discID] /= disc_count[discID]\\n if disc_sums[discID] < 5:\\n failing_disciplines.append(discID)\\n if len(failing_disciplines) == 0:\\n continue\\n result = [slist[studentID], []]\\n for discID in failing_disciplines:\\n result[1].append((dlist[discID], disc_sums[discID]))\\n failing_students.append(result)\\n return failing_students\",\n \"def available_sets(session, player):\\n excluded_sets = set(session.taken.keys())\\n for grouping in session.exclusives:\\n if player.sets.intersection(grouping):\\n excluded_sets.update(grouping)\\n return [s for s in session.sets if s not in excluded_sets]\",\n \"def get_invalid(cls, instance):\\n\\n others = [i for i in list(instance.context) if\\n i is not instance and\\n set(cls.families) & get_families(i)]\\n if not others:\\n return []\\n\\n other_ids = defaultdict(list)\\n for other in others:\\n for _id, members in get_instance_node_ids(other).items():\\n other_ids[_id].extend(members)\\n\\n # Take only the ids with more than one member\\n invalid = list()\\n ids = get_instance_node_ids(instance)\\n for _id, members in ids.iteritems():\\n if _id in other_ids:\\n cls.log.error(\\\"ID found on multiple nodes: '%s'\\\" % members)\\n cls.log.debug(\\\"Clashes with: %s\\\" % (other_ids[_id],))\\n invalid.extend(members)\\n\\n return invalid\",\n \"def _filter_empty(lst):\\n return [cell for cell in lst if cell is not Sudoku.EMPTY_CELL]\",\n \"def check_equipped(self):\\n equipped_str = \\\"\\\"\\n for body_part, item in self.equipped.items():\\n if item is None:\\n equipped_str += f\\\"On {body_part} slot you have equipped nothing\\\"\\n else:\\n equipped_str += f\\\"On {body_part} slot you have equipped {item}\\\"\\n return equipped_str\",\n \"def missing_bus_indices(net):\\n check_results = {}\\n bus_indices = set(net.bus.index)\\n element_bus_names = {\\\"ext_grid\\\": [\\\"bus\\\"], \\\"load\\\": [\\\"bus\\\"], \\\"gen\\\": [\\\"bus\\\"], \\\"sgen\\\": [\\\"bus\\\"],\\n \\\"trafo\\\": [\\\"lv_bus\\\", \\\"hv_bus\\\"], \\\"trafo3w\\\": [\\\"lv_bus\\\", \\\"mv_bus\\\", \\\"hv_bus\\\"],\\n \\\"switch\\\": [\\\"bus\\\", \\\"element\\\"], \\\"line\\\": [\\\"from_bus\\\", \\\"to_bus\\\"]}\\n for element in element_bus_names.keys():\\n element_check = []\\n for i, row in net[element].iterrows():\\n for bus_name in element_bus_names[element]:\\n if row[bus_name] not in bus_indices:\\n if not ((element == \\\"switch\\\") and (bus_name == \\\"element\\\") and (row.et in ['l', 't', 't3'])):\\n element_check.append((i, bus_name, row[bus_name]))\\n if element_check:\\n check_results[element] = element_check\\n\\n if check_results:\\n return check_results\",\n \"def addClassroom(classroomName, capacity,location):\\n for classroom in classroomEntities:\\n if classroom[\\\"classroomName\\\"] == classroomName:\\n print(\\\"Two classrooms can not have same name\\\")\\n return False\\n\\n if classroomEntities==[]:\\n lastSavedIdNumber = \\\"0\\\"\\n else:\\n lastSavedId=classroomEntities[-1][\\\"classroomId\\\"] #update classroomId as first element in classroomEntities list\\n lastSavedIdNumber=lastSavedId[2:]\\n numberOfDigitsInID = 3\\n if lastSavedIdNumber == \\\"9\\\" * len(lastSavedIdNumber):\\n numberOfDigitsInID = len(lastSavedIdNumber) + 1\\n classroomId=\\\"CR\\\"+str(int(lastSavedIdNumber)+1).rjust(numberOfDigitsInID,\\\"0\\\")\\n\\n # add the new Classroom\\n newClassroom = {}\\n newClassroom[\\\"classroomId\\\"] = classroomId\\n newClassroom[\\\"classroomName\\\"] = classroomName\\n newClassroom[\\\"capacity\\\"] = capacity\\n newClassroom[\\\"location\\\"] = location\\n classroomEntities.append(newClassroom)\\n print(f\\\"Class Room is added into the system, Class Room id is {classroomId}.\\\")\\n return True\",\n \"def all_equipment(self):\\n\\t\\tself.db = DB()\\n\\t\\tactivity_all = self.db.select_all_from(\\\"equipment\\\")\\n\\t\\ttmpl = lookup.get_template(\\\"equipment.html\\\")\\n\\t\\treturn (tmpl.render(equipment=activity_all))\",\n \"def getAvailableTimeslots(self, allTimeslots) -> [Timeslot]:\\r\\n # List with all Timeslots any of the Teachers is not available at.\\r\\n notAvailableTimeslotsTeachers = flatMap(lambda t: t.not_available_timeslots, self.teachers)\\r\\n # notAvailableTimeslotsTeachers = [item for sublist in map(lambda t: t.not_available_timeslots, self.teachers) for item in sublist]\\r\\n # If Lesson can only take place on forenoon, create list with all afternoon timeslots.\\r\\n if self.course.only_forenoon:\\r\\n notAvailableTimeslotsForenoon = list(filter(lambda t: t.number not in Timeslot.getForenoonTimeslotNumbers(), allTimeslots))\\r\\n else:\\r\\n notAvailableTimeslotsForenoon = []\\r\\n\\r\\n timeslots = [x for x in allTimeslots if x not in (notAvailableTimeslotsTeachers + notAvailableTimeslotsForenoon)]\\r\\n if self.available_timeslots: # If list is not empty. Else no restrictions.\\r\\n timeslots = [x for x in timeslots if x in self.available_timeslots]\\r\\n\\r\\n return timeslots\",\n \"def get_unassigned_devices_for_model(model_number: str, manufacturer: str) -> list:\\n\\n conn = database_connect()\\n if(conn is None):\\n return None\\n cur = conn.cursor()\\n\\n try:\\n # SQL statement and execute\\n sql = \\\"\\\"\\\"SELECT Device.deviceID\\n FROM Device\\n WHERE Device.manufacturer = %s AND Device.modelNumber = %s AND Device.IssuedTo IS NULL\\\"\\\"\\\"\\n cur.execute(sql, (manufacturer, model_number))\\n\\n # Attempt to fetch all rows\\n result = cur.fetchall()\\n\\n if result == None:\\n cur.close()\\n conn.close()\\n return []\\n\\n unissued = []\\n for row in result:\\n unissued.append(\\n row[0]\\n )\\n\\n cur.close()\\n conn.close()\\n return unissued\\n except Exception as e:\\n print(\\\"nnn\\\")\\n print(e)\\n # If nothing was returned, return empty list\\n cur.close()\\n conn.close()\\n return []\\n\\n\\n # TODO Dummy Data - Change to be useful!\\n # Return each device of this model that has not been issued\\n # Each \\\"row\\\" has: [ device_id ]\\n # device_unissued = [123656, 123132, 51413, 8765]\\n #\\n # return device_unissued\",\n \"def getOccupied(self):\\n occupiedList = []\\n for spot in self.parkingSpots:\\n if spot.status == 'occupied':\\n occupiedList.append(spot)\\n return occupiedList\",\n \"def get_occupants(self):\\n return [x.get_occupant_type() for x in self.huts]\",\n \"def non_mcnugget():\\n nugget = [0, 6, 9, 20]\\n mcnugget = set([6, 9, 20])\\n\\n while True:\\n mcnugget = set([m+n for m in mcnugget for n in nugget])\\n\\n for m in mcnugget:\\n found = all([m+j in mcnugget for j in range(6)])\\n if found:\\n return [k for k in range(1, m) if k not in mcnugget]\",\n \"def map_room_list():\\n for room in map_rooms:\\n print(f\\\"{room}: \\\")\\n for description in map_rooms[room]:\\n print(f\\\"{description} - {map_rooms[room][description]}\\\")\",\n \"def check_comm(instance):\\n\\n comm = instance.__dict__.get(\\\"commodity\\\")\\n\\n accounted_comm = set()\\n\\n for c in comm:\\n\\n for r in instance.reactions:\\n r_dict = r.__dict__\\n\\n for label, species in r_dict.items():\\n\\n if instance.__dict__.get(\\\"recombination\\\") == Recomb_1:\\n product = r_dict.get(\\\"left2\\\")\\n\\n else:\\n product = r_dict.get(\\\"right2\\\")\\n\\n if product == c:\\n accounted_comm.add(c)\\n\\n if set(comm) == accounted_comm:\\n return True\\n else:\\n print(\\\"Commodity:\\\", set(comm))\\n print(\\\"Commodity products made:\\\", accounted_comm)\\n return False\",\n \"def find_unmapped_categories(\\n self,\\n ) -> tuple[set[\\\"Category\\\"], set[\\\"Category\\\"]]:\\n cats_a: set[Category] = set()\\n cats_b: set[Category] = set()\\n for rule in self.rules:\\n cats_a.update(rule.factors_categories_a.keys())\\n cats_b.update(rule.factors_categories_b.keys())\\n\\n cats_missing_a = set(self.categorization_a.values()) - cats_a\\n cats_missing_b = set(self.categorization_b.values()) - cats_b\\n return cats_missing_a, cats_missing_b\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6358367","0.6313788","0.6150663","0.60647494","0.5886441","0.5728688","0.5633727","0.5608109","0.55511093","0.53285015","0.5248454","0.523609","0.5177248","0.5149604","0.51473695","0.5124947","0.5094668","0.50736094","0.50731784","0.50704306","0.50624216","0.50523317","0.50450975","0.50313354","0.50245416","0.501638","0.49762192","0.4965608","0.49499065","0.49391097","0.49362534","0.49212784","0.4911138","0.4904279","0.49028575","0.48961148","0.48866156","0.48822257","0.4878339","0.4877577","0.48710802","0.48678023","0.48502064","0.48430812","0.4840209","0.4839944","0.4819136","0.47927672","0.4762542","0.47591576","0.47438046","0.47428524","0.47185084","0.47173607","0.46958655","0.4690982","0.46893644","0.46818408","0.4669568","0.46590334","0.4656566","0.46529478","0.46529433","0.46486452","0.46452895","0.46407697","0.4638938","0.46331555","0.46235466","0.46211988","0.46211988","0.4613772","0.4613162","0.4608121","0.46050638","0.4594759","0.45917594","0.458718","0.45836213","0.45832458","0.45772523","0.45761016","0.45731592","0.4571392","0.45677727","0.45673355","0.45634356","0.4555014","0.4543822","0.45435753","0.45420957","0.45386007","0.45284668","0.45278856","0.45275074","0.45273757","0.45209414","0.4520451","0.45202154","0.45182958"],"string":"[\n \"0.6358367\",\n \"0.6313788\",\n \"0.6150663\",\n \"0.60647494\",\n \"0.5886441\",\n \"0.5728688\",\n \"0.5633727\",\n \"0.5608109\",\n \"0.55511093\",\n \"0.53285015\",\n \"0.5248454\",\n \"0.523609\",\n \"0.5177248\",\n \"0.5149604\",\n \"0.51473695\",\n \"0.5124947\",\n \"0.5094668\",\n \"0.50736094\",\n \"0.50731784\",\n \"0.50704306\",\n \"0.50624216\",\n \"0.50523317\",\n \"0.50450975\",\n \"0.50313354\",\n \"0.50245416\",\n \"0.501638\",\n \"0.49762192\",\n \"0.4965608\",\n \"0.49499065\",\n \"0.49391097\",\n \"0.49362534\",\n \"0.49212784\",\n \"0.4911138\",\n \"0.4904279\",\n \"0.49028575\",\n \"0.48961148\",\n \"0.48866156\",\n \"0.48822257\",\n \"0.4878339\",\n \"0.4877577\",\n \"0.48710802\",\n \"0.48678023\",\n \"0.48502064\",\n \"0.48430812\",\n \"0.4840209\",\n \"0.4839944\",\n \"0.4819136\",\n \"0.47927672\",\n \"0.4762542\",\n \"0.47591576\",\n \"0.47438046\",\n \"0.47428524\",\n \"0.47185084\",\n \"0.47173607\",\n \"0.46958655\",\n \"0.4690982\",\n \"0.46893644\",\n \"0.46818408\",\n \"0.4669568\",\n \"0.46590334\",\n \"0.4656566\",\n \"0.46529478\",\n \"0.46529433\",\n \"0.46486452\",\n \"0.46452895\",\n \"0.46407697\",\n \"0.4638938\",\n \"0.46331555\",\n \"0.46235466\",\n \"0.46211988\",\n \"0.46211988\",\n \"0.4613772\",\n \"0.4613162\",\n \"0.4608121\",\n \"0.46050638\",\n \"0.4594759\",\n \"0.45917594\",\n \"0.458718\",\n \"0.45836213\",\n \"0.45832458\",\n \"0.45772523\",\n \"0.45761016\",\n \"0.45731592\",\n \"0.4571392\",\n \"0.45677727\",\n \"0.45673355\",\n \"0.45634356\",\n \"0.4555014\",\n \"0.4543822\",\n \"0.45435753\",\n \"0.45420957\",\n \"0.45386007\",\n \"0.45284668\",\n \"0.45278856\",\n \"0.45275074\",\n \"0.45273757\",\n \"0.45209414\",\n \"0.4520451\",\n \"0.45202154\",\n \"0.45182958\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6854201"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":10496,"cells":{"query":{"kind":"string","value":"Returns beautiful representation for programmer"},"document":{"kind":"string","value":"def __repr__(self):\n return \"Classroom('{}', {}, {})\".format(self.number, self.capacity,\n str(self.equipment))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __str__(self):\n astr = '[\\n name: [ ' + self.name + ' ]\\n'\n astr += ' variables: [ '\n for var, init in self.variables:\n astr += '(' + var + ' := ' + init + '), '\n astr = astr[:-2] + ' ]\\n assumptions: [ '\n for assumption in self.assumptions:\n astr += assumption + ', '\n astr = astr[:-2] + ' ]\\n guarantees: [ '\n for guarantee in self.guarantees:\n astr += guarantee + ', '\n return astr[:-2] + ' ]\\n]'","def __str__(self):\n astr = ' variables:\\t[ '\n for var in self.variables:\n astr += str(var) + ', '\n astr = astr[:-2] + ' ]\\n assumptions :\\t[ '\n for assumption in self.assumptions.cnf:\n astr += assumption.formula + ', '\n astr = astr[:-2] + ' ]\\n guarantees :\\t[ '\n for guarantee in self.guarantees.cnf:\n astr += guarantee.formula + ', '\n # astr = astr[:-2] + ' ]\\n guarantees_unsat :\\t[ '\n # for guarantee in self.guarantees.cnf:\n # astr += guarantee.unsaturated + ', '\n return astr[:-2] + ' ]\\n'","def __str__(self):\n return self.__class__.__name__ + '\\n' + self.__class__.__doc__","def __str__(self):\n\t\treturn pprint.pformat({'servicename':self.servicename,'doc_lines':self.doc_lines,'sourcefile':self.sourcefile,'methods':self.methods})","def __str__(self):\n out = self.san\n if self.comment != \"\":\n out += \" {\" + self.comment.replace('\\n', ' ') + \"}\"\n if len(self.nags) > 0:\n for n in self.nags:\n out += \" \" + n\n for v in self.variations:\n out += \" (\" + str(v).strip(' ') + \")\"\n return out","def logic_program_form(self):\r\n return '% -------------------------------------\\n' +\\\r\n '% Structure ' + self.name + '\\n' +\\\r\n '% -------------------------------------\\n\\n'","def dump(self):\n outputs = [\"Code object : %s\" % self.name]\n outputs.append(\" Type : %s\" % self.object_type)\n for source_line in self.source:\n # Each line is a (line_number, code) pair\n outputs.append('%d: %s' % source_line)\n return \"\".join(outputs)","def __repr__(self) -> str:\n return_string = str()\n\n return_string += f\"Representation of dataset with {len(self.internal_types)} elements:\\n\"\n return_string += f\"List of categories:\\t{self.internal_types}\\n\"\n return_string += f\"First and last 5 features:\\n\"\n for i in range(5):\n return_string += f\"\\t{self.internal_data[i]}\\n\"\n return_string += f\"\\t...\\n\"\n for i in range(4, -1, -1):\n return_string += f\"\\t{self.internal_data[i]}\\n\"\n return_string += \"For more information, use debugger.\"\n\n return return_string","def __str__(self) -> str:\n\t\treturn \"{}{}; {}\".format(TAB, self.get_typestring(force_regen=True), self.get_description())","def __str__(self):\n sio = StringIO()\n # name:\n sio.write(self.name + \":\\n\")\n # Tags\n # - name: value\n for t, v in self.tags:\n sio.write('- ' + t + ': ' + v + '\\n')\n # Sets\n # a,b,d-f) w x r, w x r, [rest] work x rep\n sio.write(','.join(str(s.order) for s in self.sets) + ') ')\n sets = [str(s) for s in self.sets]\n sio.write(', '.join(sets) + '\\n')\n return sio.getvalue()","def __str__(self):\n return self.printable()","def __repr__(self) -> str:\n\t\trep_str: str\n\t\theader_char: str\n\t\tcode_name = codify(self.name)\n\n\t\t# Get header character, with nested nodes under their parent\n\t\tif self.nested:\n\t\t\theader_char = \"^\"\n\t\telse:\n\t\t\theader_char = \"-\"\n\n\t\t# Get the header, set as start of string\n\t\trep_str = get_header(code_name, header_char)\n\t\t# Add description\n\t\trep_str += self.__str__()\n\t\t# Add newlines\n\t\trep_str += get_line_padding(2)\n\n\t\t# Handle nested nodes\n\t\tif self.has_nodes():\n\t\t\t# Setup\n\t\t\tnested_nodes = self.get_nodes()\n\t\t\tnested_reps = \"\"\n\n\t\t\t# Start Nested Nodes table\n\t\t\trep_str += get_table_start((\n\t\t\t\t\"Nested Nodes\",\n\t\t\t\t\"Description\",\n\t\t\t))\n\n\t\t\t# Iterate over nested node names\n\t\t\tfor nested_node in nested_nodes:\n\t\t\t\t# Add to table\n\t\t\t\trep_str += get_table_line((codify(nested_node.name), str(nested_node)))\n\t\t\t\t# Store full node sections, will be added after table\n\t\t\t\tnested_reps += repr(nested_node)\n\n\t\t\t# End Nested Nodes Table\n\t\t\trep_str += get_table_end(1)\n\n\t\t\t# Add stored sections\n\t\t\trep_str += nested_reps\n\n\t\t# Handle SubNodes, should be present\n\t\tif self.has_subnodes():\n\t\t\t# Get header, different if nested\n\t\t\tif self.nested:\n\t\t\t\trep_str += get_header(\"{}'s SubNodes\".format(code_name), '\"')\n\t\t\telse:\n\t\t\t\trep_str += get_header(\"SubNodes\", \"^\")\n\n\t\t\t# Iterate over SubNodes\n\t\t\tfor curr_subnode in self.get_subnodes():\n\t\t\t\trep_str += repr(curr_subnode)\n\n\t\t\t# Add extra newline\n\t\t\trep_str += get_line_padding(1)\n\n\t\t# Add final newline\n\t\trep_str += get_line_padding(1)\n\t\t# Return\n\t\treturn rep_str","def _repr_(self):\n if self._is_identity:\n description = \"Identity map \"\n else:\n description = \"Automorphism \"\n if self._name is not None:\n description += self._name + \" \"\n description += \"of the {}\".format(self._fmodule)\n return description","def __str__(self) :\n if not self.parsed :\n return \"\"\n mybuffer = []\n mybuffer.append(\"IPP version : %s.%s\" % self.version)\n mybuffer.append(\"IPP operation Id : 0x%04x\" % self.operation_id)\n mybuffer.append(\"IPP request Id : 0x%08x\" % self.request_id)\n for attrtype in self.attributes_types :\n for attribute in getattr(self, \"_%s_attributes\" % attrtype) :\n if attribute :\n mybuffer.append(\"%s attributes :\" % attrtype.title())\n for (name, value) in attribute :\n mybuffer.append(\" %s : %s\" % (name, value))\n # if self.data :\n # mybuffer.append(\"IPP datas : %s\" % repr(self.data))\n return \"\\n\".join(mybuffer)","def __str__(self):\n return_string = self.name + \"\\n\" + str(self.traits)\n\n return return_string","def __str__(self) -> str:\n\n assert self.data is not None\n border = \"****************************************\"\n name_border = \"=\" * len(self.name)\n lines = [border, name_border, self.name, name_border]\n for spec in self.specs.values():\n lines.append(str(spec))\n lines.append(border)\n return os.linesep.join(lines)","def description():","def __str__(self):\n debug_str = \"%s ::=\" % str(self.head)\n for symbol in self.body:\n debug_str += \" %s\" % str(symbol)\n return debug_str","def toString():","def __str__(self):\n return \"<%s: %s>\" % (self.__class__, self.describe())","def __str__(self):\n out = str(self.tag_pairs)\n if self.comment:\n out += \"{\" + self.comment + \"} \"\n out += self.format_body()\n return out","def __str__(self):\n description = \"Object class Critter.\"\n description += \"\\nName: \" + self.name + \"\\nMood: \" + self.mood + \"\\nHunger: \" + str(self.hunger) + \"\\nBoredom: \" + str(self.boredom) + \"\\n\"\n return description","def __str__(self):\n context_print = \"EDB :\\n\"\n for fact_name, facts in self._facts.items():\n for f in facts:\n context_print += \" \" + str(f) + \".\\n\"\n\n context_print += \"\\nIDB :\\n\"\n for predicates in self._predicates.values():\n for predicate in predicates:\n context_print += \" \" + str(predicate) + \".\\n\"\n\n context_print += \"\\nMAPPING :\\n\"\n for rule_name, rules in self._rules.items():\n for r in rules:\n context_print += \" \" + str(r) + \".\\n\"\n\n context_print += \"\\nQUERY :\\n\"\n for q in self.queries:\n context_print += \" \" + str(q) + \".\\n\"\n\n return context_print","def __str__(self):\n s = \"--\\n\"\n for element in self:\n s += element.__str__() + \"\\n\"\n s += \"--\"\n \"\"\"\n # Uncomment if you want to see the internal structure\n s = \"\\n--\\n\"\n for i in xrange(self.size):\n s += \"%d [%s, %s]\\n\" % ( i, self.slot[i], self.data[i] )\n s += \"--\"\n \"\"\"\n return s","def __str__(self):\n if self.__description:\n return self.__description\n return repr(self)","def logic_program_form(self):\r\n return '% -------------------------------------\\n' +\\\r\n '% Theory ' + self.name + '\\n' +\\\r\n '% -------------------------------------\\n\\n' +\\\r\n GENERAL_AXIOMS","def __str__(self):\n if __debug__:\n description = ('CM' in debug.active)\n else:\n description = False\n return self.asstring(short=False, header=True, summary=True,\n description=description)","def __repr__(self) -> str:\n preprocessor_str = f\", Preprocessors: {self._pre}\"\n return f\"{type(self).__name__} {self.name}{preprocessor_str}\"","def __repr__(self):\n\n rep = \"\"\n rep += str(self.literal)+\"\\n\"\n rep += str(self.bindings)+\"\\n\"\n rep += str(self.facts)+\"\\n\"\n return (rep)","def __str__(self):\r\n return repr(self)","def pretty_str(self) -> str:\n ...","def __str__(self):\n\t\n\t\tresult = \"\"\n\t\tresult += \"Torsional Spring Specs: \\n\"\n\t\tresult += \"Shape Eq. Slope: {0}\\n\".format(str(self.shape_slope))\n\t\tresult += \"Z Thickness: {0}\\n\".format(str(self.z_thick))\n\t\tresult += \"In-Plane Thickness: {0}\\n\".format(str(self.thick))\n\t\tresult += \"Spiral Length: {0}\\n\".format(str(self.length))\n\n\t\treturn result","def __str__(self) -> str:\n if len(self.saliva_data) > 0:\n return \"\"\"{}\n Saliva Type(s): {}\n Saliva Sample Times: {}\n Structure: {}\n \"\"\".format(\n self.name, self.saliva_types, self.sample_times, self.structure\n )\n return \"\"\"{}\n Structure: {}\"\"\".format(\n self.name, self.structure\n )","def __str__(self):\n try:\n delim = ', ' if len(self) < 8 else ',\\n '\n s = delim.join('%s: %s' % (repr(k), repr(self[k])) for k in self.peys())\n return '{' + s + '}'\n except Exception:\n return dict.__repr__(self)","def __repr__(self):\n s = ''\n for attr in self.__dict__:\n val = pformat(self.__dict__[attr])[:1500]\n if len(val)>70:\n s+=f'\\n{attr}:\\n{val}\\n\\n'\n else:\n s += f'{attr}: {val}\\n'\n return s","def __str__(self):\n _str = \"Variables:\\n\"\n for variable in self.variables:\n _str += \" {}\\n\".format(str(variable))\n _str += \"\\nConstraints:\\n\"\n for constraint in self.constraints:\n _str += \" {}\\n\".format(str(constraint))\n return _str","def __str__(self):\n out = \"<\"\n out += str(type(self)).split(\"'\")[1].split(\".\")[-1]\n out += \" \" + str(self.name)\n out += \" id:\" + str(self.id)\n out += \" owner:\" + str(self.owner.id)\n\n if self.tags is not None and len(self.tags):\n out += \" Tags:\"\n for tag in self.tags:\n out += \" \" + str(tag)\n\n if self.is_built:\n out += \" built\"\n\n out += \">\"\n out += \"\\n\"\n _self = self\n\n # out += f\"def {self.name}(\"\n # out += \", \".join(f\"arg_{extract_tag(p)}\" for p in self.find_placeholders(\"input\"))\n # out += \"):\\n\"\n # for action in self.actions:\n # line = \" \"\n # if action.return_ids is not None:\n # if isinstance(action.return_ids, PlaceHolder):\n # tag = extract_tag(action.return_ids)\n # line += f\"_{tag} = \"\n # elif isinstance(action.return_ids, tuple):\n # line += (\n # \", \".join(\n # f\"_{extract_tag(o)}\" if isinstance(o, PlaceHolder) else str(o)\n # for o in action.return_ids\n # )\n # + \" = \"\n # )\n # else:\n # line += str(action.return_ids) + \" = \"\n # if action.target is not None:\n # line += f\"_{extract_tag(self.placeholders[action.target.value])}.\"\n # line += action.name + \"(\"\n # line += \", \".join(\n # f\"_{extract_tag(arg)}\" if isinstance(arg, PlaceHolder) else str(arg)\n # for arg in action.args\n # )\n # if action.kwargs:\n # line += \", \" + \", \".join(f\"{k}={w}\" for k, w in action.kwargs.items())\n # line += \")\\n\"\n # out += line\n\n # out += \" return \"\n # out += \", \".join(f\"_{extract_tag(p)}\" for p in self.find_placeholders(\"output\"))\n\n return out","def __str__(self):\n \n string = \"{}: {} ({}) - {}\".format(self.code, self.title, self.credit, self._term_name())\n return string","def __repr__(self):\n return pformat(vars(self))","def __str__(self):\n segments = []\n if self.comment:\n segments.append('\"%s\"' % self.comment)\n if self.sg:\n if self.dbow_words:\n segments.append('dbow+w') # also training words\n else:\n segments.append('dbow') # PV-DBOW (skip-gram-style)\n\n else: # PV-DM...\n if self.dm_concat:\n segments.append('dm/c') # ...with concatenative context layer\n else:\n if self.cbow_mean:\n segments.append('dm/m')\n else:\n segments.append('dm/s')\n segments.append('d%d' % self.docvecs.vector_size) # dimensions\n if self.negative:\n segments.append('n%d' % self.negative) # negative samples\n if self.hs:\n segments.append('hs')\n if not self.sg or (self.sg and self.dbow_words):\n segments.append('w%d' % self.window) # window size, when relevant\n if self.vocabulary.min_count > 1:\n segments.append('mc%d' % self.vocabulary.min_count)\n if self.vocabulary.sample > 0:\n segments.append('s%g' % self.vocabulary.sample)\n if self.workers > 1:\n segments.append('t%d' % self.workers)\n return '%s(%s)' % (self.__class__.__name__, ','.join(segments))","def __repr__(self):\n return self.pretty_print(self.__dict__)","def __str__(self):\n # define the prefix\n prefix = \"py_SEX2GOL: \"\n\n # compose the feedback\n big_str = \"{0:s} Setup:\\n\".format(prefix)\n big_str += \"{0:s} Input g/prism image: {0:s} \\n\".format(prefix, self.grisim)\n big_str += \"{0:s} Configuration file name: {0:s} \\n\".format(prefix, self.config)\n big_str += \"{0:s} Direct image: {0:s} \\n\".format(prefix, self.dirname)\n big_str += \"{0:s} G/Prism extension: {0:s} \\n\".format(prefix, self.grism_extinfo['axe_ext'])\n big_str += \"{0:s} Direct image extension: {0:s} \\n\".format(prefix, self.dirname_extinfo['axe_ext'])\n big_str += \"{0:s} Input catalog name: {0:s} \\n\".format(prefix, self.in_sex)\n big_str += \"{0:s} Output catalog name: {0:s} \".format(prefix, self.out_sex)\n\n # return the string\n return big_str","def __str__(self) -> str:\n\n sources_joined = \" \".join(self.sources)\n sources = f\"[SOURCES]\\n{sources_joined}\"\n\n sp_joined = \"\\n\".join(map(str, self.source_parameters))\n source_parameters = f\"[SOURCE-PARAMETERS]\\n{sp_joined}\"\n\n hints_joined = \"\\n\".join(map(str, self.hints))\n general = f\"[GENERAL]\\n{hints_joined}\"\n\n return \"\\n\".join([\n \"# Augustus extrinsic hints config file.\",\n (\"# Automatically generated by [augustus_optimiser]\"\n \"(https://github.com/darcyabjones/augustus_optimiser)\"),\n \"\",\n sources,\n \"\",\n source_parameters,\n \"\",\n general,\n ])","def __str__(self):\n output_dict = {\n 'first_name': self.first_name,\n 'last_name': self.last_name,\n 'year': self.year,\n 'major': self.major,\n 'academic_interests': self.academic_interests,\n 'post_grad_goal': self.post_grad_goal,\n 'software_experience': self.software_experience,\n 'hobbies': self.hobbies\n }\n return str(output_dict)","def code(self):\n t = ''\n for k, v in self.traits.iteritems():\n t += '{k}={v},'.format(k=k, v=v)\n\n return '{0}({1})'.format(self.__class__.__name__, t[:-1])","def __str__(self):\n _str = indent(self.name, color = self.color)\n _str += indent(\"-\"*len(self.name))\n _str += indent(\"( \" + self.movemement + \" - \"+ self.symbole + \" )\")\n _str += indent(\"Awareness: \" + str(self.awareness))\n for _iel in self.abilities:\n _str += indent(_iel)\n if self.description is not None:\n _str += indent(\"-\"*45 + \"\\n\")\n _str += indent(self.description)\n _str += indent(\"-\"*45 + \"\\n\")\n _str += indent(BOLD_BLACK + \" \"*15 + \"Combat Stats\" + RESET)\n _str += indent(\"-\"*45 + \"\\n\")\n _str += indent(BLUE + \" Horror\" + RESET + \" Toughness\"\\\n + RED + \" Combat\" + RESET)\n _str += indent(BLUE + \"Rating Damage \"\\\n + RED + \"Rating Damage\")\n _str += indent(BLUE + \" \" + str(self.horror_rating)\\\n + \" \"*8 + str(self.horror_damage) + RESET\\\n + \" \"*8 + str(self.toughness) + RED\\\n + \" \"*8 + str(self.combat_rating)\\\n + \" \"*8 + str(self.combat_damage) + RESET)\n _str += indent(\"-\"*45 + \"\\n\")\n return _str","def __str__(self):\n from nodepy.utils import array2strings\n\n c = array2strings(self.c,printzeros=True)\n A = array2strings(self.A)\n b = array2strings(self.b,printzeros=True)\n lenmax, colmax = _get_column_widths([A,b,c])\n\n s=self.name+'\\n'+self.info+'\\n'\n for i in range(len(self)):\n s+=c[i].ljust(colmax+1)+'|'\n for j in range(len(self)):\n s+=A[i,j].ljust(colmax+1)\n s=s.rstrip()+'\\n'\n s+='_'*(colmax+1)+'|'+('_'*(colmax+1)*len(self))+'\\n'\n s+= ' '*(colmax+1)+'|'\n for j in range(len(self)):\n s+=b[j].ljust(colmax+1)\n return s.rstrip()","def __str__(self):\n print_info = f\"\\nStudent ID: {self._id}, Name: {self._name}, \" \\\n f\"Year: {self._year} \\nPhone: {str(self._phone)}, \" \\\n f\"Address: {str(self._address)} \" \\\n f\"\\nClasses: {str(self._classes)}\" \\\n f\"\\nBirth Date: {self._date}\"\n return print_info","def __str__(self):\n return repr(self)","def __repr__(self):\n modulename = str(type(self).__module__)\n\n ichars = len(str(int(self.max())))\n slen = ichars + casas\n fstr = \"{{:>{}.{}g}}\".format(slen, casas)\n\n if modulename == \"__main__\":\n s = str(type(self).__name__)\n else:\n s = modulename + '.' + str(type(self).__name__)\n\n s += '(['\n s += ', '.join([fstr.format(x) for x in self.elem])\n s += '])'\n\n return s","def __str__(self):\n if len(self.label) > 0:\n descr = [\"'%s', target='%s' [%s]\" % (self.label, self.target.name, self.target.body_type)]\n else:\n descr = [\"target='%s' [%s]\" % (self.target.name, self.target.body_type)]\n if self.baseline:\n descr[0] += ', initial baseline offset=%f' % (self.baseline.poly[-1],)\n if self.beam:\n descr[0] += ', beam height=%f' % (self.beam.height,)\n for scan_ind, scan in enumerate(self.scans):\n descr.append('%4d: %s' % (scan_ind, str(scan)))\n return '\\n'.join(descr)","def __str__(self):\n string = super().__str__()\n string += \"\\n\" + str(self.get_dict())\n return string","def __repr__(self):\r\n s = 'Words:\\n' + str(self.words) + '\\n\\n'\r\n s += 'Word lengths:\\n' + str(self.wordlengths) + '\\n\\n'\r\n s += 'Stems:\\n' + str(self.stems) + '\\n\\n'\r\n s += 'Sentence lengths:\\n' + str(self.sentencelengths) + '\\n\\n'\r\n s += 'Gerunds:\\n' + str(self.gerund)\r\n return s","def __repr__(self):\n format_string = self.__class__.__name__ + '('\n for t in self.transforms:\n format_string += f'\\n {t}'\n format_string += '\\n)'\n return format_string","def __str__(self) -> str:\n model_str = [\"\\nModel info:\\n\", \" Unimodal encoder:\\n\"]\n\n for modality in range(self.num_modalities):\n model_str.append(f\" ({modality + 1}) {self.unimodal_encoder[modality]}\")\n\n model_str.append(\"\\n\\n Unimodal decoder:\\n\")\n for modality in range(self.num_modalities):\n model_str.append(f\" ({modality + 1}) {self.unimodal_decoder[modality]}\")\n\n if self.multimodal_decoder is not None:\n model_str.append(\"\\n\\n Multimodal decoder:\\n\")\n model_str.append(f\" {self.multimodal_decoder}\")\n\n return \"\".join(model_str)","def __str__(self):\n class_name_str = str(self.__class__.__name__) + \": (\"\n head_str = str(self.head_vertex) + \", \"\n tail_str = str(self.tail_vertex) + \", \"\n weight_str = str(self.weight) + \")\"\n attributes_str = head_str + tail_str + weight_str\n str_rep = class_name_str + attributes_str\n return str_rep","def __str__(self):\n class_name_str = str(self.__class__.__name__) + \": (\"\n head_str = str(self.head_vertex) + \", \"\n tail_str = str(self.tail_vertex) + \", \"\n weight_str = str(self.weight) + \")\"\n attributes_str = head_str + tail_str + weight_str\n str_rep = class_name_str + attributes_str\n return str_rep","def __str__(self):\n \n result = '<' + self._name + ', ' + str(self._id) + ', ' + self._age + ', ' \n for elem in self._direct:\n result += elem.getID() + ', '\n result += self._fitness + ', ' + self._immune + '>'\n\n return result","def __str__(self):\n return self.make_flat()","def __repr__(self):\n return ''.join(f'\\ncompany: {self.company_name}\\nsize: {self.company_size}\\ncompany_founded: '\n f'{self.company_founded}\\ncompany_industry: {self.company_industry}\\ncompany_sector: '\n f'{self.company_sector}\\ncompany_type: {self.company_type}\\ncompany_rating: '\n f'{self.company_rating}\\ncompany_competitors: {self.company_competitors}\\ncompany_revenue: '\n f'{self.company_revenue}\\ncompany_headquarters: {self.company_headquarters}')","def __str__(self):\n\n desc = self.description\n if desc is not None:\n return str(desc)\n\n desc = self.debugDescription\n if desc is not None:\n return str(desc)\n\n return repr(self)","def description(self):","def __str__(self):\n reprStr = 'Help Mario build Iron Man suit!'+'\\n' +'To make the ' + self._name + ',you need:'+'\\n'\n for part in self._supplies:\n reprStr = reprStr + str(part.getCount()) + ' ' + part.getData() + '\\n'\n return reprStr","def __repr__(self) -> str:\n\t\treturn \"- {}\\n{}\\n\".format(self.name, self.__str__())","def __repr__(self):\n return u\"(\" + str(self) + \", \" + str(dict(self)) + u')'","def __repr__(self) -> str:\n return \"a bunch of OLD values\"","def __repr__(self) -> str:\n return f\"<Doc[{self.desc}]>\"","def __str__(self):\n return self.getBooksString() + \"\\n\" + self.getPatronsString()","def __str__(self):\n to_print = '{} : {}\\n'.format('Name'.ljust(34),self.name)\n to_print = to_print + '{} : {}\\n'.format('Name'.ljust(34),self.pathloss.name)\n to_print = to_print + '{} : {}\\n'.format('Number of samples'.ljust(34),self.nsamples)\n to_print = to_print + '{} : {}\\n'.format('Sensor model'.ljust(34),self.sensor_model.name)\n to_print = to_print + '{} : {}\\n'.format('Motion model'.ljust(34),self.motion_model.name)\n return to_print","def __str__(self):\n result = ''\n result += '+---+\\n'\n for i in range(3):\n result += '|' + self[i*3] + self[i*3+1] + self[i*3+2] + '|\\n'\n result += '+---+'\n return result","def __str__(self):\n description = \"-------- %s --------\" % (self.name)\n description += \"\\nnmax = %i\" % (self.nmax)\n description += \"\\nnslots = %i\" % (self.nslots)\n description += \"\\nbonus_power = %i\" % (self.bonus_power)\n description += \"\\nbonus_initiative = %.1f\" % (self.bonus_initiative)\n description += \"\\nneeds_drive = %i\" % (self.needs_drive)\n description += \"\\nis_mobile = %i\" % (self.is_mobile)\n description += \"\\n----- Default Parts -----\"\n for i in range(len(self.default_parts)):\n description += \"\\n%i) %s\" % (i + 1, self.default_parts[i].name)\n return description","def __str__(self):\n st=\"\"\n for g in self:\n st+=g.fasta()\n st+=\"\\n\"\n return st","def _repr_(self):\n desc = ''\n if self.n_vertices()==0:\n desc += 'The empty polyhedron'\n else:\n desc += 'A ' + repr(self.dim()) + '-dimensional polyhedron'\n desc += ' in '\n if self.field()==QQ: desc += 'QQ'\n else: desc += 'RDF'\n desc += '^' + repr(self.ambient_dim()) \n\n if self.n_vertices()>0:\n desc += ' defined as the convex hull of ' \n desc += repr(self.n_vertices())\n if self.n_vertices()==1: desc += ' vertex'\n else: desc += ' vertices'\n \n if self.n_rays()>0:\n if self.n_lines()>0: desc += \", \"\n else: desc += \" and \"\n desc += repr(self.n_rays())\n if self.n_rays()==1: desc += ' ray'\n else: desc += ' rays'\n \n if self.n_lines()>0:\n if self.n_rays()>0: desc += \", \"\n else: desc += \" and \"\n desc += repr(self.n_lines())\n if self.n_lines()==1: desc +=' line'\n else: desc +=' lines'\n\n return desc + \".\\n\";","def __str__(self):\n return \"*** MAKE_JWST_SPEC_PREVIEWS ERROR: \"+repr(self.value)","def __repr__(self):\n string_representation = self.__str__().replace(\"{\", \"(\").replace(\n \"}\", \")\").replace(\":\", \"=\")\n return f\"{type(self).__name__}{string_representation}\"","def __str__(self):\n l = [\"MARKING DUMP BEGIN\\n\"]\n for place_name, place_type in self.place_types.items():\n l.append(place_name)\n l.append(\" \\t\")\n l.append(str(place_type.info.type))\n l.append(\" \\tonesafe\") if place_type.info.one_safe else l.append(\"\")\n l.append(\"\\n\")\n l.append(\"MARKING DUMP END\\n\")\n return \"\".join(l)","def pprint(self):\n # just here for defining the interface; work is done in subclasses\n pass","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self) -> str:","def __str__(self): # pragma: no cover\n return self.display()","def __repr__(self):\n return self.description","def toString(self):\n\t\ts = \"A %s titled '%s':\\n\\n\" % (self.getSpecString(), self.getName())\n\t\ts += \"It's summary reads: %s\\n\\n\" % (self.getDescription())\n\t\ts += \"~~\\n%s\\n~~\" % (self.getAllItemsStr())\n\t\treturn s","def __repr__(self):\n doc_string = \"# %s class description:\\n%s\\n# Instance attributes:\\n\" % (self.__class__, self.__doc__)\n # write each argument with its value\n properties = dir(self)\n for elem in properties:\n if not elem.startswith(\"_\"):\n doc_string += \"\\t%s:%s\\n\" % (elem, self.__getattribute__(elem))\n return doc_string","def __str__(self) -> str:\n if self.decorator is None:\n decorator_str = \"\"\n elif self.decorator:\n decorator_str = \"+\"\n else:\n decorator_str = \"-\"\n return \" \".join([\"The nilpotent orbit corresponding\",\n f\"to partition {self.my_diagram}{decorator_str}\",\n f\"in type {self.my_type.letter()} {self.lie_rank}\"])","def __repr__(self):\n\n\t\t# Preparing variables\n\t\tl_s_content = [\t\t# List containing the content to print\n\t\t\t\"> The structure object :\"\n\t\t]\n\n\t\t# PDB fields\n\t\tl_s_content.append(\"s_name : {}\".format(self.s_name))\n\n\t\t# Structural fields\n\t\tl_s_content.append(\"i_atom_count : {}\".format(self.i_atom_count))\n\t\tl_s_content.append(\"a_atoms : {}\".format(len(self.a_atoms)))\n\n\t\t# Grid fields\n\t\tl_s_content.append(\"b_loaded : {}\".format(self.b_loaded))\n\t\tl_s_content.append(\"a_grid : {}\".format(self.a_grid.size))\n\n\t\treturn \"\\n\".join(l_s_content)\t\t# Returns the content to show","def __str__(self):\n\n return (self._display_name + \"\\n\\t\" + self._description + \"\\n\")","def __str__(self):\n\n OptiObjFunc_str = \"\"\n if self.parent is None:\n OptiObjFunc_str += \"parent = None \" + linesep\n else:\n OptiObjFunc_str += (\n \"parent = \" + str(type(self.parent)) + \" object\" + linesep\n )\n OptiObjFunc_str += 'description = \"' + str(self.description) + '\"' + linesep\n if self._func[1] is None:\n OptiObjFunc_str += \"func = \" + str(self._func[1])\n else:\n OptiObjFunc_str += (\n \"func = \" + linesep + str(self._func[1]) + linesep + linesep\n )\n return OptiObjFunc_str","def __str__(self):\n return self._name+self._description","def __str__(self):\n s = []\n s.append('device %d' % self.ndevs_before)\n s.append('idcode 0x%08x' % self.idcode)\n s.append('irchain %s' % self.irchain_str())\n return ' '.join(s)","def __str__(self) -> str:\n return \"\".join([\"{\", \", \".join(map(str, self.__elements)), \"}\"])","def __str__(self):\n # Power/toughness, seen only if it's a creature\n pt = \"\"\n if \"power\" in self:\n pt = \"{0}/{1}\".format(self.power,\n self.toughness).replace(\"*\", \"\\*\")\n # Append loyalty to the end of oracle text if the creature is a\n # planeswalker\n if \"loyalty\" in self:\n self.oracle_text = \"{0}\\nStarting Loyalty: {1}\".format(\n self.oracle_text, self.loyalty)\n\n flavor = \"*{0}*\".format(\n self.flavor_text) if \"flavor_text\" in self else \"\"\n\n return \"**{0}** {1}\\n{2} {3}\\n{4}\\n{5}\\n\\n\".format(self.name,\n self.mana_cost,\n self.type_line,\n pt,\n self.oracle_text,\n flavor)","def __repr__(self):\n\n return '%s(%s)' % (self, self._format_entries(),)","def __repr__(self):\n return \"%s(%s)\" % (self.__class__.__name__, self.tokens())","def __repr__(self):\r\n # get and sort children\r\n folders = []\r\n programs = []\r\n for child in self.children:\r\n if child[0] is 'folder':\r\n folders.append(child)\r\n elif child[0] is 'program':\r\n programs.append(child)\r\n\r\n # initialize data\r\n folders.sort(key=lambda x: x[1])\r\n programs.sort(key=lambda x: x[1])\r\n out = str(self) + '\\n'\r\n\r\n # format folders\r\n for fold in folders:\r\n fold_obj = self[fold[2]]\r\n out += ' + ' + fold[1] + ': Folder(' + fold[2] + ')\\n'\r\n for line in repr(fold_obj).split('\\n')[1:]:\r\n if len(line) > 0:\r\n out += ' | ' + line + '\\n'\r\n out += ' -\\n'\r\n\r\n # format programs\r\n for prog in programs:\r\n out += ' ' + prog[1] + ': ' + self[prog[2]].__str__() + '\\n'\r\n\r\n return out","def __str__(self):\r\n return self.__repr__()","def __repr__(self):\n repr_parts = ['<', self.__class__.__name__]\n \n repr_parts.append(' month = ')\n repr_parts.append(repr(self.month))\n \n repr_parts.append(' day = ')\n repr_parts.append(repr(self.day))\n \n repr_parts.append(' name = ')\n repr_parts.append(repr(self.name))\n \n repr_parts.append(' color_code = ')\n repr_parts.append(repr(self.color_code))\n \n repr_parts.append('>')\n return ''.join(repr_parts)","def __repr__(self):\n\n if not self.output :\n return \"\"\n\n # if self.is_abstract:\n # result = \"\\n # Properties inherited from \" + self.class_name + \"\\n\"\n # if len(self.attributes) > 0:\n # for attribute_ in self.attributes:\n # result += repr(attribute_)\n # # else:\n # # result += \"\\n pass\"\n # result += \"\\n\"\n # result += \" # End of properties inherited from \" + self.class_name + \"\\n\"\n # return result.encode('ascii', 'ignore')\n\n # Not an abstract class, so output as a full class\n result = \"class \"\n result += self.class_name\n\n result += \"(Base): # class definition\\n\"\n\n result += \" __tablename__ = \\'\" + self.class_name.lower() + \"\\'\\n\\n\"\n result += \" id = Column(Integer, primary_key=True)\\n\"\n\n\n # If this class has a general class, then add a foreign key to it\n if self.general_class:\n #result += repr(self.general_class)\n result += \" \" + self.general_class_name.lower() + \"_id = \"\n result += \"Column('\" + self.general_class_name.lower() + \"_id', \"\n result += \"ForeignKey('\" + self.general_class_name.lower() + \".id'), nullable = True)\"\n\n if len(self.attributes) > 0:\n for attribute_ in self.attributes:\n result += repr(attribute_)\n # else:\n # result += \"\\n pass\"\n\n result += \"\\n\"\n\n return result.encode('ascii', 'ignore')","def __str__(self):\r\n to_print = (\"Name: \" + self.name + \", Age: \" +\r\n str(self.age) + \", Hobbys: \" + str(self.hobbys))\r\n return to_print","def __str__(self):\n\n result = \"n: \" + str(self.n) + \"\\n\"\n result += \"m: \" + str(self.m) + \"\\n\"\n result += \"ns: \" + str(self.ns) + \"\\n\"\n result += \"s0: \" + str(self.s0) + \"\\n\"\n result += \"goals: \" + str([self.goals[i] for i in range(self.ng)]) + \"\\n\"\n result += \"horizon: \" + str(self.horizon) + \"\\n\"\n result += \"gamma: \" + str(self.gamma) + \"\\n\\n\"\n\n result += \"S(s, a, s'):\\n%s\" % (str(np.array([self.S[i] \\\n for i in range(self.n * self.m * self.ns)]).reshape((self.n, self.m, self.ns)))) + \"\\n\\n\"\n\n result += \"T(s, a, s'):\\n%s\" % (str(np.array([self.T[i] \\\n for i in range(self.n * self.m * self.ns)]).reshape((self.n, self.m, self.ns)))) + \"\\n\\n\"\n\n result += \"R(s, a):\\n%s\" % (str(np.array([self.R[i] \\\n for i in range(self.n * self.m)]).reshape((self.n, self.m)))) + \"\\n\\n\"\n\n return result"],"string":"[\n \"def __str__(self):\\n astr = '[\\\\n name: [ ' + self.name + ' ]\\\\n'\\n astr += ' variables: [ '\\n for var, init in self.variables:\\n astr += '(' + var + ' := ' + init + '), '\\n astr = astr[:-2] + ' ]\\\\n assumptions: [ '\\n for assumption in self.assumptions:\\n astr += assumption + ', '\\n astr = astr[:-2] + ' ]\\\\n guarantees: [ '\\n for guarantee in self.guarantees:\\n astr += guarantee + ', '\\n return astr[:-2] + ' ]\\\\n]'\",\n \"def __str__(self):\\n astr = ' variables:\\\\t[ '\\n for var in self.variables:\\n astr += str(var) + ', '\\n astr = astr[:-2] + ' ]\\\\n assumptions :\\\\t[ '\\n for assumption in self.assumptions.cnf:\\n astr += assumption.formula + ', '\\n astr = astr[:-2] + ' ]\\\\n guarantees :\\\\t[ '\\n for guarantee in self.guarantees.cnf:\\n astr += guarantee.formula + ', '\\n # astr = astr[:-2] + ' ]\\\\n guarantees_unsat :\\\\t[ '\\n # for guarantee in self.guarantees.cnf:\\n # astr += guarantee.unsaturated + ', '\\n return astr[:-2] + ' ]\\\\n'\",\n \"def __str__(self):\\n return self.__class__.__name__ + '\\\\n' + self.__class__.__doc__\",\n \"def __str__(self):\\n\\t\\treturn pprint.pformat({'servicename':self.servicename,'doc_lines':self.doc_lines,'sourcefile':self.sourcefile,'methods':self.methods})\",\n \"def __str__(self):\\n out = self.san\\n if self.comment != \\\"\\\":\\n out += \\\" {\\\" + self.comment.replace('\\\\n', ' ') + \\\"}\\\"\\n if len(self.nags) > 0:\\n for n in self.nags:\\n out += \\\" \\\" + n\\n for v in self.variations:\\n out += \\\" (\\\" + str(v).strip(' ') + \\\")\\\"\\n return out\",\n \"def logic_program_form(self):\\r\\n return '% -------------------------------------\\\\n' +\\\\\\r\\n '% Structure ' + self.name + '\\\\n' +\\\\\\r\\n '% -------------------------------------\\\\n\\\\n'\",\n \"def dump(self):\\n outputs = [\\\"Code object : %s\\\" % self.name]\\n outputs.append(\\\" Type : %s\\\" % self.object_type)\\n for source_line in self.source:\\n # Each line is a (line_number, code) pair\\n outputs.append('%d: %s' % source_line)\\n return \\\"\\\".join(outputs)\",\n \"def __repr__(self) -> str:\\n return_string = str()\\n\\n return_string += f\\\"Representation of dataset with {len(self.internal_types)} elements:\\\\n\\\"\\n return_string += f\\\"List of categories:\\\\t{self.internal_types}\\\\n\\\"\\n return_string += f\\\"First and last 5 features:\\\\n\\\"\\n for i in range(5):\\n return_string += f\\\"\\\\t{self.internal_data[i]}\\\\n\\\"\\n return_string += f\\\"\\\\t...\\\\n\\\"\\n for i in range(4, -1, -1):\\n return_string += f\\\"\\\\t{self.internal_data[i]}\\\\n\\\"\\n return_string += \\\"For more information, use debugger.\\\"\\n\\n return return_string\",\n \"def __str__(self) -> str:\\n\\t\\treturn \\\"{}{}; {}\\\".format(TAB, self.get_typestring(force_regen=True), self.get_description())\",\n \"def __str__(self):\\n sio = StringIO()\\n # name:\\n sio.write(self.name + \\\":\\\\n\\\")\\n # Tags\\n # - name: value\\n for t, v in self.tags:\\n sio.write('- ' + t + ': ' + v + '\\\\n')\\n # Sets\\n # a,b,d-f) w x r, w x r, [rest] work x rep\\n sio.write(','.join(str(s.order) for s in self.sets) + ') ')\\n sets = [str(s) for s in self.sets]\\n sio.write(', '.join(sets) + '\\\\n')\\n return sio.getvalue()\",\n \"def __str__(self):\\n return self.printable()\",\n \"def __repr__(self) -> str:\\n\\t\\trep_str: str\\n\\t\\theader_char: str\\n\\t\\tcode_name = codify(self.name)\\n\\n\\t\\t# Get header character, with nested nodes under their parent\\n\\t\\tif self.nested:\\n\\t\\t\\theader_char = \\\"^\\\"\\n\\t\\telse:\\n\\t\\t\\theader_char = \\\"-\\\"\\n\\n\\t\\t# Get the header, set as start of string\\n\\t\\trep_str = get_header(code_name, header_char)\\n\\t\\t# Add description\\n\\t\\trep_str += self.__str__()\\n\\t\\t# Add newlines\\n\\t\\trep_str += get_line_padding(2)\\n\\n\\t\\t# Handle nested nodes\\n\\t\\tif self.has_nodes():\\n\\t\\t\\t# Setup\\n\\t\\t\\tnested_nodes = self.get_nodes()\\n\\t\\t\\tnested_reps = \\\"\\\"\\n\\n\\t\\t\\t# Start Nested Nodes table\\n\\t\\t\\trep_str += get_table_start((\\n\\t\\t\\t\\t\\\"Nested Nodes\\\",\\n\\t\\t\\t\\t\\\"Description\\\",\\n\\t\\t\\t))\\n\\n\\t\\t\\t# Iterate over nested node names\\n\\t\\t\\tfor nested_node in nested_nodes:\\n\\t\\t\\t\\t# Add to table\\n\\t\\t\\t\\trep_str += get_table_line((codify(nested_node.name), str(nested_node)))\\n\\t\\t\\t\\t# Store full node sections, will be added after table\\n\\t\\t\\t\\tnested_reps += repr(nested_node)\\n\\n\\t\\t\\t# End Nested Nodes Table\\n\\t\\t\\trep_str += get_table_end(1)\\n\\n\\t\\t\\t# Add stored sections\\n\\t\\t\\trep_str += nested_reps\\n\\n\\t\\t# Handle SubNodes, should be present\\n\\t\\tif self.has_subnodes():\\n\\t\\t\\t# Get header, different if nested\\n\\t\\t\\tif self.nested:\\n\\t\\t\\t\\trep_str += get_header(\\\"{}'s SubNodes\\\".format(code_name), '\\\"')\\n\\t\\t\\telse:\\n\\t\\t\\t\\trep_str += get_header(\\\"SubNodes\\\", \\\"^\\\")\\n\\n\\t\\t\\t# Iterate over SubNodes\\n\\t\\t\\tfor curr_subnode in self.get_subnodes():\\n\\t\\t\\t\\trep_str += repr(curr_subnode)\\n\\n\\t\\t\\t# Add extra newline\\n\\t\\t\\trep_str += get_line_padding(1)\\n\\n\\t\\t# Add final newline\\n\\t\\trep_str += get_line_padding(1)\\n\\t\\t# Return\\n\\t\\treturn rep_str\",\n \"def _repr_(self):\\n if self._is_identity:\\n description = \\\"Identity map \\\"\\n else:\\n description = \\\"Automorphism \\\"\\n if self._name is not None:\\n description += self._name + \\\" \\\"\\n description += \\\"of the {}\\\".format(self._fmodule)\\n return description\",\n \"def __str__(self) :\\n if not self.parsed :\\n return \\\"\\\"\\n mybuffer = []\\n mybuffer.append(\\\"IPP version : %s.%s\\\" % self.version)\\n mybuffer.append(\\\"IPP operation Id : 0x%04x\\\" % self.operation_id)\\n mybuffer.append(\\\"IPP request Id : 0x%08x\\\" % self.request_id)\\n for attrtype in self.attributes_types :\\n for attribute in getattr(self, \\\"_%s_attributes\\\" % attrtype) :\\n if attribute :\\n mybuffer.append(\\\"%s attributes :\\\" % attrtype.title())\\n for (name, value) in attribute :\\n mybuffer.append(\\\" %s : %s\\\" % (name, value))\\n # if self.data :\\n # mybuffer.append(\\\"IPP datas : %s\\\" % repr(self.data))\\n return \\\"\\\\n\\\".join(mybuffer)\",\n \"def __str__(self):\\n return_string = self.name + \\\"\\\\n\\\" + str(self.traits)\\n\\n return return_string\",\n \"def __str__(self) -> str:\\n\\n assert self.data is not None\\n border = \\\"****************************************\\\"\\n name_border = \\\"=\\\" * len(self.name)\\n lines = [border, name_border, self.name, name_border]\\n for spec in self.specs.values():\\n lines.append(str(spec))\\n lines.append(border)\\n return os.linesep.join(lines)\",\n \"def description():\",\n \"def __str__(self):\\n debug_str = \\\"%s ::=\\\" % str(self.head)\\n for symbol in self.body:\\n debug_str += \\\" %s\\\" % str(symbol)\\n return debug_str\",\n \"def toString():\",\n \"def __str__(self):\\n return \\\"<%s: %s>\\\" % (self.__class__, self.describe())\",\n \"def __str__(self):\\n out = str(self.tag_pairs)\\n if self.comment:\\n out += \\\"{\\\" + self.comment + \\\"} \\\"\\n out += self.format_body()\\n return out\",\n \"def __str__(self):\\n description = \\\"Object class Critter.\\\"\\n description += \\\"\\\\nName: \\\" + self.name + \\\"\\\\nMood: \\\" + self.mood + \\\"\\\\nHunger: \\\" + str(self.hunger) + \\\"\\\\nBoredom: \\\" + str(self.boredom) + \\\"\\\\n\\\"\\n return description\",\n \"def __str__(self):\\n context_print = \\\"EDB :\\\\n\\\"\\n for fact_name, facts in self._facts.items():\\n for f in facts:\\n context_print += \\\" \\\" + str(f) + \\\".\\\\n\\\"\\n\\n context_print += \\\"\\\\nIDB :\\\\n\\\"\\n for predicates in self._predicates.values():\\n for predicate in predicates:\\n context_print += \\\" \\\" + str(predicate) + \\\".\\\\n\\\"\\n\\n context_print += \\\"\\\\nMAPPING :\\\\n\\\"\\n for rule_name, rules in self._rules.items():\\n for r in rules:\\n context_print += \\\" \\\" + str(r) + \\\".\\\\n\\\"\\n\\n context_print += \\\"\\\\nQUERY :\\\\n\\\"\\n for q in self.queries:\\n context_print += \\\" \\\" + str(q) + \\\".\\\\n\\\"\\n\\n return context_print\",\n \"def __str__(self):\\n s = \\\"--\\\\n\\\"\\n for element in self:\\n s += element.__str__() + \\\"\\\\n\\\"\\n s += \\\"--\\\"\\n \\\"\\\"\\\"\\n # Uncomment if you want to see the internal structure\\n s = \\\"\\\\n--\\\\n\\\"\\n for i in xrange(self.size):\\n s += \\\"%d [%s, %s]\\\\n\\\" % ( i, self.slot[i], self.data[i] )\\n s += \\\"--\\\"\\n \\\"\\\"\\\"\\n return s\",\n \"def __str__(self):\\n if self.__description:\\n return self.__description\\n return repr(self)\",\n \"def logic_program_form(self):\\r\\n return '% -------------------------------------\\\\n' +\\\\\\r\\n '% Theory ' + self.name + '\\\\n' +\\\\\\r\\n '% -------------------------------------\\\\n\\\\n' +\\\\\\r\\n GENERAL_AXIOMS\",\n \"def __str__(self):\\n if __debug__:\\n description = ('CM' in debug.active)\\n else:\\n description = False\\n return self.asstring(short=False, header=True, summary=True,\\n description=description)\",\n \"def __repr__(self) -> str:\\n preprocessor_str = f\\\", Preprocessors: {self._pre}\\\"\\n return f\\\"{type(self).__name__} {self.name}{preprocessor_str}\\\"\",\n \"def __repr__(self):\\n\\n rep = \\\"\\\"\\n rep += str(self.literal)+\\\"\\\\n\\\"\\n rep += str(self.bindings)+\\\"\\\\n\\\"\\n rep += str(self.facts)+\\\"\\\\n\\\"\\n return (rep)\",\n \"def __str__(self):\\r\\n return repr(self)\",\n \"def pretty_str(self) -> str:\\n ...\",\n \"def __str__(self):\\n\\t\\n\\t\\tresult = \\\"\\\"\\n\\t\\tresult += \\\"Torsional Spring Specs: \\\\n\\\"\\n\\t\\tresult += \\\"Shape Eq. Slope: {0}\\\\n\\\".format(str(self.shape_slope))\\n\\t\\tresult += \\\"Z Thickness: {0}\\\\n\\\".format(str(self.z_thick))\\n\\t\\tresult += \\\"In-Plane Thickness: {0}\\\\n\\\".format(str(self.thick))\\n\\t\\tresult += \\\"Spiral Length: {0}\\\\n\\\".format(str(self.length))\\n\\n\\t\\treturn result\",\n \"def __str__(self) -> str:\\n if len(self.saliva_data) > 0:\\n return \\\"\\\"\\\"{}\\n Saliva Type(s): {}\\n Saliva Sample Times: {}\\n Structure: {}\\n \\\"\\\"\\\".format(\\n self.name, self.saliva_types, self.sample_times, self.structure\\n )\\n return \\\"\\\"\\\"{}\\n Structure: {}\\\"\\\"\\\".format(\\n self.name, self.structure\\n )\",\n \"def __str__(self):\\n try:\\n delim = ', ' if len(self) < 8 else ',\\\\n '\\n s = delim.join('%s: %s' % (repr(k), repr(self[k])) for k in self.peys())\\n return '{' + s + '}'\\n except Exception:\\n return dict.__repr__(self)\",\n \"def __repr__(self):\\n s = ''\\n for attr in self.__dict__:\\n val = pformat(self.__dict__[attr])[:1500]\\n if len(val)>70:\\n s+=f'\\\\n{attr}:\\\\n{val}\\\\n\\\\n'\\n else:\\n s += f'{attr}: {val}\\\\n'\\n return s\",\n \"def __str__(self):\\n _str = \\\"Variables:\\\\n\\\"\\n for variable in self.variables:\\n _str += \\\" {}\\\\n\\\".format(str(variable))\\n _str += \\\"\\\\nConstraints:\\\\n\\\"\\n for constraint in self.constraints:\\n _str += \\\" {}\\\\n\\\".format(str(constraint))\\n return _str\",\n \"def __str__(self):\\n out = \\\"<\\\"\\n out += str(type(self)).split(\\\"'\\\")[1].split(\\\".\\\")[-1]\\n out += \\\" \\\" + str(self.name)\\n out += \\\" id:\\\" + str(self.id)\\n out += \\\" owner:\\\" + str(self.owner.id)\\n\\n if self.tags is not None and len(self.tags):\\n out += \\\" Tags:\\\"\\n for tag in self.tags:\\n out += \\\" \\\" + str(tag)\\n\\n if self.is_built:\\n out += \\\" built\\\"\\n\\n out += \\\">\\\"\\n out += \\\"\\\\n\\\"\\n _self = self\\n\\n # out += f\\\"def {self.name}(\\\"\\n # out += \\\", \\\".join(f\\\"arg_{extract_tag(p)}\\\" for p in self.find_placeholders(\\\"input\\\"))\\n # out += \\\"):\\\\n\\\"\\n # for action in self.actions:\\n # line = \\\" \\\"\\n # if action.return_ids is not None:\\n # if isinstance(action.return_ids, PlaceHolder):\\n # tag = extract_tag(action.return_ids)\\n # line += f\\\"_{tag} = \\\"\\n # elif isinstance(action.return_ids, tuple):\\n # line += (\\n # \\\", \\\".join(\\n # f\\\"_{extract_tag(o)}\\\" if isinstance(o, PlaceHolder) else str(o)\\n # for o in action.return_ids\\n # )\\n # + \\\" = \\\"\\n # )\\n # else:\\n # line += str(action.return_ids) + \\\" = \\\"\\n # if action.target is not None:\\n # line += f\\\"_{extract_tag(self.placeholders[action.target.value])}.\\\"\\n # line += action.name + \\\"(\\\"\\n # line += \\\", \\\".join(\\n # f\\\"_{extract_tag(arg)}\\\" if isinstance(arg, PlaceHolder) else str(arg)\\n # for arg in action.args\\n # )\\n # if action.kwargs:\\n # line += \\\", \\\" + \\\", \\\".join(f\\\"{k}={w}\\\" for k, w in action.kwargs.items())\\n # line += \\\")\\\\n\\\"\\n # out += line\\n\\n # out += \\\" return \\\"\\n # out += \\\", \\\".join(f\\\"_{extract_tag(p)}\\\" for p in self.find_placeholders(\\\"output\\\"))\\n\\n return out\",\n \"def __str__(self):\\n \\n string = \\\"{}: {} ({}) - {}\\\".format(self.code, self.title, self.credit, self._term_name())\\n return string\",\n \"def __repr__(self):\\n return pformat(vars(self))\",\n \"def __str__(self):\\n segments = []\\n if self.comment:\\n segments.append('\\\"%s\\\"' % self.comment)\\n if self.sg:\\n if self.dbow_words:\\n segments.append('dbow+w') # also training words\\n else:\\n segments.append('dbow') # PV-DBOW (skip-gram-style)\\n\\n else: # PV-DM...\\n if self.dm_concat:\\n segments.append('dm/c') # ...with concatenative context layer\\n else:\\n if self.cbow_mean:\\n segments.append('dm/m')\\n else:\\n segments.append('dm/s')\\n segments.append('d%d' % self.docvecs.vector_size) # dimensions\\n if self.negative:\\n segments.append('n%d' % self.negative) # negative samples\\n if self.hs:\\n segments.append('hs')\\n if not self.sg or (self.sg and self.dbow_words):\\n segments.append('w%d' % self.window) # window size, when relevant\\n if self.vocabulary.min_count > 1:\\n segments.append('mc%d' % self.vocabulary.min_count)\\n if self.vocabulary.sample > 0:\\n segments.append('s%g' % self.vocabulary.sample)\\n if self.workers > 1:\\n segments.append('t%d' % self.workers)\\n return '%s(%s)' % (self.__class__.__name__, ','.join(segments))\",\n \"def __repr__(self):\\n return self.pretty_print(self.__dict__)\",\n \"def __str__(self):\\n # define the prefix\\n prefix = \\\"py_SEX2GOL: \\\"\\n\\n # compose the feedback\\n big_str = \\\"{0:s} Setup:\\\\n\\\".format(prefix)\\n big_str += \\\"{0:s} Input g/prism image: {0:s} \\\\n\\\".format(prefix, self.grisim)\\n big_str += \\\"{0:s} Configuration file name: {0:s} \\\\n\\\".format(prefix, self.config)\\n big_str += \\\"{0:s} Direct image: {0:s} \\\\n\\\".format(prefix, self.dirname)\\n big_str += \\\"{0:s} G/Prism extension: {0:s} \\\\n\\\".format(prefix, self.grism_extinfo['axe_ext'])\\n big_str += \\\"{0:s} Direct image extension: {0:s} \\\\n\\\".format(prefix, self.dirname_extinfo['axe_ext'])\\n big_str += \\\"{0:s} Input catalog name: {0:s} \\\\n\\\".format(prefix, self.in_sex)\\n big_str += \\\"{0:s} Output catalog name: {0:s} \\\".format(prefix, self.out_sex)\\n\\n # return the string\\n return big_str\",\n \"def __str__(self) -> str:\\n\\n sources_joined = \\\" \\\".join(self.sources)\\n sources = f\\\"[SOURCES]\\\\n{sources_joined}\\\"\\n\\n sp_joined = \\\"\\\\n\\\".join(map(str, self.source_parameters))\\n source_parameters = f\\\"[SOURCE-PARAMETERS]\\\\n{sp_joined}\\\"\\n\\n hints_joined = \\\"\\\\n\\\".join(map(str, self.hints))\\n general = f\\\"[GENERAL]\\\\n{hints_joined}\\\"\\n\\n return \\\"\\\\n\\\".join([\\n \\\"# Augustus extrinsic hints config file.\\\",\\n (\\\"# Automatically generated by [augustus_optimiser]\\\"\\n \\\"(https://github.com/darcyabjones/augustus_optimiser)\\\"),\\n \\\"\\\",\\n sources,\\n \\\"\\\",\\n source_parameters,\\n \\\"\\\",\\n general,\\n ])\",\n \"def __str__(self):\\n output_dict = {\\n 'first_name': self.first_name,\\n 'last_name': self.last_name,\\n 'year': self.year,\\n 'major': self.major,\\n 'academic_interests': self.academic_interests,\\n 'post_grad_goal': self.post_grad_goal,\\n 'software_experience': self.software_experience,\\n 'hobbies': self.hobbies\\n }\\n return str(output_dict)\",\n \"def code(self):\\n t = ''\\n for k, v in self.traits.iteritems():\\n t += '{k}={v},'.format(k=k, v=v)\\n\\n return '{0}({1})'.format(self.__class__.__name__, t[:-1])\",\n \"def __str__(self):\\n _str = indent(self.name, color = self.color)\\n _str += indent(\\\"-\\\"*len(self.name))\\n _str += indent(\\\"( \\\" + self.movemement + \\\" - \\\"+ self.symbole + \\\" )\\\")\\n _str += indent(\\\"Awareness: \\\" + str(self.awareness))\\n for _iel in self.abilities:\\n _str += indent(_iel)\\n if self.description is not None:\\n _str += indent(\\\"-\\\"*45 + \\\"\\\\n\\\")\\n _str += indent(self.description)\\n _str += indent(\\\"-\\\"*45 + \\\"\\\\n\\\")\\n _str += indent(BOLD_BLACK + \\\" \\\"*15 + \\\"Combat Stats\\\" + RESET)\\n _str += indent(\\\"-\\\"*45 + \\\"\\\\n\\\")\\n _str += indent(BLUE + \\\" Horror\\\" + RESET + \\\" Toughness\\\"\\\\\\n + RED + \\\" Combat\\\" + RESET)\\n _str += indent(BLUE + \\\"Rating Damage \\\"\\\\\\n + RED + \\\"Rating Damage\\\")\\n _str += indent(BLUE + \\\" \\\" + str(self.horror_rating)\\\\\\n + \\\" \\\"*8 + str(self.horror_damage) + RESET\\\\\\n + \\\" \\\"*8 + str(self.toughness) + RED\\\\\\n + \\\" \\\"*8 + str(self.combat_rating)\\\\\\n + \\\" \\\"*8 + str(self.combat_damage) + RESET)\\n _str += indent(\\\"-\\\"*45 + \\\"\\\\n\\\")\\n return _str\",\n \"def __str__(self):\\n from nodepy.utils import array2strings\\n\\n c = array2strings(self.c,printzeros=True)\\n A = array2strings(self.A)\\n b = array2strings(self.b,printzeros=True)\\n lenmax, colmax = _get_column_widths([A,b,c])\\n\\n s=self.name+'\\\\n'+self.info+'\\\\n'\\n for i in range(len(self)):\\n s+=c[i].ljust(colmax+1)+'|'\\n for j in range(len(self)):\\n s+=A[i,j].ljust(colmax+1)\\n s=s.rstrip()+'\\\\n'\\n s+='_'*(colmax+1)+'|'+('_'*(colmax+1)*len(self))+'\\\\n'\\n s+= ' '*(colmax+1)+'|'\\n for j in range(len(self)):\\n s+=b[j].ljust(colmax+1)\\n return s.rstrip()\",\n \"def __str__(self):\\n print_info = f\\\"\\\\nStudent ID: {self._id}, Name: {self._name}, \\\" \\\\\\n f\\\"Year: {self._year} \\\\nPhone: {str(self._phone)}, \\\" \\\\\\n f\\\"Address: {str(self._address)} \\\" \\\\\\n f\\\"\\\\nClasses: {str(self._classes)}\\\" \\\\\\n f\\\"\\\\nBirth Date: {self._date}\\\"\\n return print_info\",\n \"def __str__(self):\\n return repr(self)\",\n \"def __repr__(self):\\n modulename = str(type(self).__module__)\\n\\n ichars = len(str(int(self.max())))\\n slen = ichars + casas\\n fstr = \\\"{{:>{}.{}g}}\\\".format(slen, casas)\\n\\n if modulename == \\\"__main__\\\":\\n s = str(type(self).__name__)\\n else:\\n s = modulename + '.' + str(type(self).__name__)\\n\\n s += '(['\\n s += ', '.join([fstr.format(x) for x in self.elem])\\n s += '])'\\n\\n return s\",\n \"def __str__(self):\\n if len(self.label) > 0:\\n descr = [\\\"'%s', target='%s' [%s]\\\" % (self.label, self.target.name, self.target.body_type)]\\n else:\\n descr = [\\\"target='%s' [%s]\\\" % (self.target.name, self.target.body_type)]\\n if self.baseline:\\n descr[0] += ', initial baseline offset=%f' % (self.baseline.poly[-1],)\\n if self.beam:\\n descr[0] += ', beam height=%f' % (self.beam.height,)\\n for scan_ind, scan in enumerate(self.scans):\\n descr.append('%4d: %s' % (scan_ind, str(scan)))\\n return '\\\\n'.join(descr)\",\n \"def __str__(self):\\n string = super().__str__()\\n string += \\\"\\\\n\\\" + str(self.get_dict())\\n return string\",\n \"def __repr__(self):\\r\\n s = 'Words:\\\\n' + str(self.words) + '\\\\n\\\\n'\\r\\n s += 'Word lengths:\\\\n' + str(self.wordlengths) + '\\\\n\\\\n'\\r\\n s += 'Stems:\\\\n' + str(self.stems) + '\\\\n\\\\n'\\r\\n s += 'Sentence lengths:\\\\n' + str(self.sentencelengths) + '\\\\n\\\\n'\\r\\n s += 'Gerunds:\\\\n' + str(self.gerund)\\r\\n return s\",\n \"def __repr__(self):\\n format_string = self.__class__.__name__ + '('\\n for t in self.transforms:\\n format_string += f'\\\\n {t}'\\n format_string += '\\\\n)'\\n return format_string\",\n \"def __str__(self) -> str:\\n model_str = [\\\"\\\\nModel info:\\\\n\\\", \\\" Unimodal encoder:\\\\n\\\"]\\n\\n for modality in range(self.num_modalities):\\n model_str.append(f\\\" ({modality + 1}) {self.unimodal_encoder[modality]}\\\")\\n\\n model_str.append(\\\"\\\\n\\\\n Unimodal decoder:\\\\n\\\")\\n for modality in range(self.num_modalities):\\n model_str.append(f\\\" ({modality + 1}) {self.unimodal_decoder[modality]}\\\")\\n\\n if self.multimodal_decoder is not None:\\n model_str.append(\\\"\\\\n\\\\n Multimodal decoder:\\\\n\\\")\\n model_str.append(f\\\" {self.multimodal_decoder}\\\")\\n\\n return \\\"\\\".join(model_str)\",\n \"def __str__(self):\\n class_name_str = str(self.__class__.__name__) + \\\": (\\\"\\n head_str = str(self.head_vertex) + \\\", \\\"\\n tail_str = str(self.tail_vertex) + \\\", \\\"\\n weight_str = str(self.weight) + \\\")\\\"\\n attributes_str = head_str + tail_str + weight_str\\n str_rep = class_name_str + attributes_str\\n return str_rep\",\n \"def __str__(self):\\n class_name_str = str(self.__class__.__name__) + \\\": (\\\"\\n head_str = str(self.head_vertex) + \\\", \\\"\\n tail_str = str(self.tail_vertex) + \\\", \\\"\\n weight_str = str(self.weight) + \\\")\\\"\\n attributes_str = head_str + tail_str + weight_str\\n str_rep = class_name_str + attributes_str\\n return str_rep\",\n \"def __str__(self):\\n \\n result = '<' + self._name + ', ' + str(self._id) + ', ' + self._age + ', ' \\n for elem in self._direct:\\n result += elem.getID() + ', '\\n result += self._fitness + ', ' + self._immune + '>'\\n\\n return result\",\n \"def __str__(self):\\n return self.make_flat()\",\n \"def __repr__(self):\\n return ''.join(f'\\\\ncompany: {self.company_name}\\\\nsize: {self.company_size}\\\\ncompany_founded: '\\n f'{self.company_founded}\\\\ncompany_industry: {self.company_industry}\\\\ncompany_sector: '\\n f'{self.company_sector}\\\\ncompany_type: {self.company_type}\\\\ncompany_rating: '\\n f'{self.company_rating}\\\\ncompany_competitors: {self.company_competitors}\\\\ncompany_revenue: '\\n f'{self.company_revenue}\\\\ncompany_headquarters: {self.company_headquarters}')\",\n \"def __str__(self):\\n\\n desc = self.description\\n if desc is not None:\\n return str(desc)\\n\\n desc = self.debugDescription\\n if desc is not None:\\n return str(desc)\\n\\n return repr(self)\",\n \"def description(self):\",\n \"def __str__(self):\\n reprStr = 'Help Mario build Iron Man suit!'+'\\\\n' +'To make the ' + self._name + ',you need:'+'\\\\n'\\n for part in self._supplies:\\n reprStr = reprStr + str(part.getCount()) + ' ' + part.getData() + '\\\\n'\\n return reprStr\",\n \"def __repr__(self) -> str:\\n\\t\\treturn \\\"- {}\\\\n{}\\\\n\\\".format(self.name, self.__str__())\",\n \"def __repr__(self):\\n return u\\\"(\\\" + str(self) + \\\", \\\" + str(dict(self)) + u')'\",\n \"def __repr__(self) -> str:\\n return \\\"a bunch of OLD values\\\"\",\n \"def __repr__(self) -> str:\\n return f\\\"<Doc[{self.desc}]>\\\"\",\n \"def __str__(self):\\n return self.getBooksString() + \\\"\\\\n\\\" + self.getPatronsString()\",\n \"def __str__(self):\\n to_print = '{} : {}\\\\n'.format('Name'.ljust(34),self.name)\\n to_print = to_print + '{} : {}\\\\n'.format('Name'.ljust(34),self.pathloss.name)\\n to_print = to_print + '{} : {}\\\\n'.format('Number of samples'.ljust(34),self.nsamples)\\n to_print = to_print + '{} : {}\\\\n'.format('Sensor model'.ljust(34),self.sensor_model.name)\\n to_print = to_print + '{} : {}\\\\n'.format('Motion model'.ljust(34),self.motion_model.name)\\n return to_print\",\n \"def __str__(self):\\n result = ''\\n result += '+---+\\\\n'\\n for i in range(3):\\n result += '|' + self[i*3] + self[i*3+1] + self[i*3+2] + '|\\\\n'\\n result += '+---+'\\n return result\",\n \"def __str__(self):\\n description = \\\"-------- %s --------\\\" % (self.name)\\n description += \\\"\\\\nnmax = %i\\\" % (self.nmax)\\n description += \\\"\\\\nnslots = %i\\\" % (self.nslots)\\n description += \\\"\\\\nbonus_power = %i\\\" % (self.bonus_power)\\n description += \\\"\\\\nbonus_initiative = %.1f\\\" % (self.bonus_initiative)\\n description += \\\"\\\\nneeds_drive = %i\\\" % (self.needs_drive)\\n description += \\\"\\\\nis_mobile = %i\\\" % (self.is_mobile)\\n description += \\\"\\\\n----- Default Parts -----\\\"\\n for i in range(len(self.default_parts)):\\n description += \\\"\\\\n%i) %s\\\" % (i + 1, self.default_parts[i].name)\\n return description\",\n \"def __str__(self):\\n st=\\\"\\\"\\n for g in self:\\n st+=g.fasta()\\n st+=\\\"\\\\n\\\"\\n return st\",\n \"def _repr_(self):\\n desc = ''\\n if self.n_vertices()==0:\\n desc += 'The empty polyhedron'\\n else:\\n desc += 'A ' + repr(self.dim()) + '-dimensional polyhedron'\\n desc += ' in '\\n if self.field()==QQ: desc += 'QQ'\\n else: desc += 'RDF'\\n desc += '^' + repr(self.ambient_dim()) \\n\\n if self.n_vertices()>0:\\n desc += ' defined as the convex hull of ' \\n desc += repr(self.n_vertices())\\n if self.n_vertices()==1: desc += ' vertex'\\n else: desc += ' vertices'\\n \\n if self.n_rays()>0:\\n if self.n_lines()>0: desc += \\\", \\\"\\n else: desc += \\\" and \\\"\\n desc += repr(self.n_rays())\\n if self.n_rays()==1: desc += ' ray'\\n else: desc += ' rays'\\n \\n if self.n_lines()>0:\\n if self.n_rays()>0: desc += \\\", \\\"\\n else: desc += \\\" and \\\"\\n desc += repr(self.n_lines())\\n if self.n_lines()==1: desc +=' line'\\n else: desc +=' lines'\\n\\n return desc + \\\".\\\\n\\\";\",\n \"def __str__(self):\\n return \\\"*** MAKE_JWST_SPEC_PREVIEWS ERROR: \\\"+repr(self.value)\",\n \"def __repr__(self):\\n string_representation = self.__str__().replace(\\\"{\\\", \\\"(\\\").replace(\\n \\\"}\\\", \\\")\\\").replace(\\\":\\\", \\\"=\\\")\\n return f\\\"{type(self).__name__}{string_representation}\\\"\",\n \"def __str__(self):\\n l = [\\\"MARKING DUMP BEGIN\\\\n\\\"]\\n for place_name, place_type in self.place_types.items():\\n l.append(place_name)\\n l.append(\\\" \\\\t\\\")\\n l.append(str(place_type.info.type))\\n l.append(\\\" \\\\tonesafe\\\") if place_type.info.one_safe else l.append(\\\"\\\")\\n l.append(\\\"\\\\n\\\")\\n l.append(\\\"MARKING DUMP END\\\\n\\\")\\n return \\\"\\\".join(l)\",\n \"def pprint(self):\\n # just here for defining the interface; work is done in subclasses\\n pass\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self) -> str:\",\n \"def __str__(self): # pragma: no cover\\n return self.display()\",\n \"def __repr__(self):\\n return self.description\",\n \"def toString(self):\\n\\t\\ts = \\\"A %s titled '%s':\\\\n\\\\n\\\" % (self.getSpecString(), self.getName())\\n\\t\\ts += \\\"It's summary reads: %s\\\\n\\\\n\\\" % (self.getDescription())\\n\\t\\ts += \\\"~~\\\\n%s\\\\n~~\\\" % (self.getAllItemsStr())\\n\\t\\treturn s\",\n \"def __repr__(self):\\n doc_string = \\\"# %s class description:\\\\n%s\\\\n# Instance attributes:\\\\n\\\" % (self.__class__, self.__doc__)\\n # write each argument with its value\\n properties = dir(self)\\n for elem in properties:\\n if not elem.startswith(\\\"_\\\"):\\n doc_string += \\\"\\\\t%s:%s\\\\n\\\" % (elem, self.__getattribute__(elem))\\n return doc_string\",\n \"def __str__(self) -> str:\\n if self.decorator is None:\\n decorator_str = \\\"\\\"\\n elif self.decorator:\\n decorator_str = \\\"+\\\"\\n else:\\n decorator_str = \\\"-\\\"\\n return \\\" \\\".join([\\\"The nilpotent orbit corresponding\\\",\\n f\\\"to partition {self.my_diagram}{decorator_str}\\\",\\n f\\\"in type {self.my_type.letter()} {self.lie_rank}\\\"])\",\n \"def __repr__(self):\\n\\n\\t\\t# Preparing variables\\n\\t\\tl_s_content = [\\t\\t# List containing the content to print\\n\\t\\t\\t\\\"> The structure object :\\\"\\n\\t\\t]\\n\\n\\t\\t# PDB fields\\n\\t\\tl_s_content.append(\\\"s_name : {}\\\".format(self.s_name))\\n\\n\\t\\t# Structural fields\\n\\t\\tl_s_content.append(\\\"i_atom_count : {}\\\".format(self.i_atom_count))\\n\\t\\tl_s_content.append(\\\"a_atoms : {}\\\".format(len(self.a_atoms)))\\n\\n\\t\\t# Grid fields\\n\\t\\tl_s_content.append(\\\"b_loaded : {}\\\".format(self.b_loaded))\\n\\t\\tl_s_content.append(\\\"a_grid : {}\\\".format(self.a_grid.size))\\n\\n\\t\\treturn \\\"\\\\n\\\".join(l_s_content)\\t\\t# Returns the content to show\",\n \"def __str__(self):\\n\\n return (self._display_name + \\\"\\\\n\\\\t\\\" + self._description + \\\"\\\\n\\\")\",\n \"def __str__(self):\\n\\n OptiObjFunc_str = \\\"\\\"\\n if self.parent is None:\\n OptiObjFunc_str += \\\"parent = None \\\" + linesep\\n else:\\n OptiObjFunc_str += (\\n \\\"parent = \\\" + str(type(self.parent)) + \\\" object\\\" + linesep\\n )\\n OptiObjFunc_str += 'description = \\\"' + str(self.description) + '\\\"' + linesep\\n if self._func[1] is None:\\n OptiObjFunc_str += \\\"func = \\\" + str(self._func[1])\\n else:\\n OptiObjFunc_str += (\\n \\\"func = \\\" + linesep + str(self._func[1]) + linesep + linesep\\n )\\n return OptiObjFunc_str\",\n \"def __str__(self):\\n return self._name+self._description\",\n \"def __str__(self):\\n s = []\\n s.append('device %d' % self.ndevs_before)\\n s.append('idcode 0x%08x' % self.idcode)\\n s.append('irchain %s' % self.irchain_str())\\n return ' '.join(s)\",\n \"def __str__(self) -> str:\\n return \\\"\\\".join([\\\"{\\\", \\\", \\\".join(map(str, self.__elements)), \\\"}\\\"])\",\n \"def __str__(self):\\n # Power/toughness, seen only if it's a creature\\n pt = \\\"\\\"\\n if \\\"power\\\" in self:\\n pt = \\\"{0}/{1}\\\".format(self.power,\\n self.toughness).replace(\\\"*\\\", \\\"\\\\*\\\")\\n # Append loyalty to the end of oracle text if the creature is a\\n # planeswalker\\n if \\\"loyalty\\\" in self:\\n self.oracle_text = \\\"{0}\\\\nStarting Loyalty: {1}\\\".format(\\n self.oracle_text, self.loyalty)\\n\\n flavor = \\\"*{0}*\\\".format(\\n self.flavor_text) if \\\"flavor_text\\\" in self else \\\"\\\"\\n\\n return \\\"**{0}** {1}\\\\n{2} {3}\\\\n{4}\\\\n{5}\\\\n\\\\n\\\".format(self.name,\\n self.mana_cost,\\n self.type_line,\\n pt,\\n self.oracle_text,\\n flavor)\",\n \"def __repr__(self):\\n\\n return '%s(%s)' % (self, self._format_entries(),)\",\n \"def __repr__(self):\\n return \\\"%s(%s)\\\" % (self.__class__.__name__, self.tokens())\",\n \"def __repr__(self):\\r\\n # get and sort children\\r\\n folders = []\\r\\n programs = []\\r\\n for child in self.children:\\r\\n if child[0] is 'folder':\\r\\n folders.append(child)\\r\\n elif child[0] is 'program':\\r\\n programs.append(child)\\r\\n\\r\\n # initialize data\\r\\n folders.sort(key=lambda x: x[1])\\r\\n programs.sort(key=lambda x: x[1])\\r\\n out = str(self) + '\\\\n'\\r\\n\\r\\n # format folders\\r\\n for fold in folders:\\r\\n fold_obj = self[fold[2]]\\r\\n out += ' + ' + fold[1] + ': Folder(' + fold[2] + ')\\\\n'\\r\\n for line in repr(fold_obj).split('\\\\n')[1:]:\\r\\n if len(line) > 0:\\r\\n out += ' | ' + line + '\\\\n'\\r\\n out += ' -\\\\n'\\r\\n\\r\\n # format programs\\r\\n for prog in programs:\\r\\n out += ' ' + prog[1] + ': ' + self[prog[2]].__str__() + '\\\\n'\\r\\n\\r\\n return out\",\n \"def __str__(self):\\r\\n return self.__repr__()\",\n \"def __repr__(self):\\n repr_parts = ['<', self.__class__.__name__]\\n \\n repr_parts.append(' month = ')\\n repr_parts.append(repr(self.month))\\n \\n repr_parts.append(' day = ')\\n repr_parts.append(repr(self.day))\\n \\n repr_parts.append(' name = ')\\n repr_parts.append(repr(self.name))\\n \\n repr_parts.append(' color_code = ')\\n repr_parts.append(repr(self.color_code))\\n \\n repr_parts.append('>')\\n return ''.join(repr_parts)\",\n \"def __repr__(self):\\n\\n if not self.output :\\n return \\\"\\\"\\n\\n # if self.is_abstract:\\n # result = \\\"\\\\n # Properties inherited from \\\" + self.class_name + \\\"\\\\n\\\"\\n # if len(self.attributes) > 0:\\n # for attribute_ in self.attributes:\\n # result += repr(attribute_)\\n # # else:\\n # # result += \\\"\\\\n pass\\\"\\n # result += \\\"\\\\n\\\"\\n # result += \\\" # End of properties inherited from \\\" + self.class_name + \\\"\\\\n\\\"\\n # return result.encode('ascii', 'ignore')\\n\\n # Not an abstract class, so output as a full class\\n result = \\\"class \\\"\\n result += self.class_name\\n\\n result += \\\"(Base): # class definition\\\\n\\\"\\n\\n result += \\\" __tablename__ = \\\\'\\\" + self.class_name.lower() + \\\"\\\\'\\\\n\\\\n\\\"\\n result += \\\" id = Column(Integer, primary_key=True)\\\\n\\\"\\n\\n\\n # If this class has a general class, then add a foreign key to it\\n if self.general_class:\\n #result += repr(self.general_class)\\n result += \\\" \\\" + self.general_class_name.lower() + \\\"_id = \\\"\\n result += \\\"Column('\\\" + self.general_class_name.lower() + \\\"_id', \\\"\\n result += \\\"ForeignKey('\\\" + self.general_class_name.lower() + \\\".id'), nullable = True)\\\"\\n\\n if len(self.attributes) > 0:\\n for attribute_ in self.attributes:\\n result += repr(attribute_)\\n # else:\\n # result += \\\"\\\\n pass\\\"\\n\\n result += \\\"\\\\n\\\"\\n\\n return result.encode('ascii', 'ignore')\",\n \"def __str__(self):\\r\\n to_print = (\\\"Name: \\\" + self.name + \\\", Age: \\\" +\\r\\n str(self.age) + \\\", Hobbys: \\\" + str(self.hobbys))\\r\\n return to_print\",\n \"def __str__(self):\\n\\n result = \\\"n: \\\" + str(self.n) + \\\"\\\\n\\\"\\n result += \\\"m: \\\" + str(self.m) + \\\"\\\\n\\\"\\n result += \\\"ns: \\\" + str(self.ns) + \\\"\\\\n\\\"\\n result += \\\"s0: \\\" + str(self.s0) + \\\"\\\\n\\\"\\n result += \\\"goals: \\\" + str([self.goals[i] for i in range(self.ng)]) + \\\"\\\\n\\\"\\n result += \\\"horizon: \\\" + str(self.horizon) + \\\"\\\\n\\\"\\n result += \\\"gamma: \\\" + str(self.gamma) + \\\"\\\\n\\\\n\\\"\\n\\n result += \\\"S(s, a, s'):\\\\n%s\\\" % (str(np.array([self.S[i] \\\\\\n for i in range(self.n * self.m * self.ns)]).reshape((self.n, self.m, self.ns)))) + \\\"\\\\n\\\\n\\\"\\n\\n result += \\\"T(s, a, s'):\\\\n%s\\\" % (str(np.array([self.T[i] \\\\\\n for i in range(self.n * self.m * self.ns)]).reshape((self.n, self.m, self.ns)))) + \\\"\\\\n\\\\n\\\"\\n\\n result += \\\"R(s, a):\\\\n%s\\\" % (str(np.array([self.R[i] \\\\\\n for i in range(self.n * self.m)]).reshape((self.n, self.m)))) + \\\"\\\\n\\\\n\\\"\\n\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7089211","0.68339634","0.6794942","0.67740595","0.6765707","0.66930324","0.66878825","0.6668747","0.6645762","0.6644278","0.6640405","0.660601","0.6604529","0.657811","0.6575636","0.65749127","0.6557521","0.65515167","0.65472","0.6546359","0.65233105","0.6498235","0.6477131","0.6460695","0.6452033","0.6436107","0.64256686","0.64231825","0.640884","0.640666","0.64057773","0.64049965","0.6397094","0.6397024","0.63900036","0.6384104","0.63604754","0.6351992","0.63515204","0.6351106","0.6347582","0.63464427","0.63452816","0.634521","0.63430417","0.6341433","0.6339789","0.6337538","0.63374823","0.6337134","0.63348687","0.6333594","0.6330974","0.6329518","0.63287526","0.63277394","0.63277394","0.63232505","0.6321646","0.6305777","0.63051134","0.63036674","0.6303531","0.630035","0.62995684","0.62947065","0.6294498","0.6294331","0.62860334","0.6283809","0.6281495","0.62813765","0.6277486","0.6277146","0.6273255","0.627246","0.62722933","0.6268907","0.6268907","0.6268907","0.6268907","0.62675333","0.62674457","0.6266913","0.6265541","0.62647545","0.62567884","0.6251068","0.6248089","0.6246146","0.6242203","0.6238597","0.6236463","0.6234091","0.62310386","0.6230642","0.6229875","0.6228716","0.6227635","0.6226918","0.62244433"],"string":"[\n \"0.7089211\",\n \"0.68339634\",\n \"0.6794942\",\n \"0.67740595\",\n \"0.6765707\",\n \"0.66930324\",\n \"0.66878825\",\n \"0.6668747\",\n \"0.6645762\",\n \"0.6644278\",\n \"0.6640405\",\n \"0.660601\",\n \"0.6604529\",\n \"0.657811\",\n \"0.6575636\",\n \"0.65749127\",\n \"0.6557521\",\n \"0.65515167\",\n \"0.65472\",\n \"0.6546359\",\n \"0.65233105\",\n \"0.6498235\",\n \"0.6477131\",\n \"0.6460695\",\n \"0.6452033\",\n \"0.6436107\",\n \"0.64256686\",\n \"0.64231825\",\n \"0.640884\",\n \"0.640666\",\n \"0.64057773\",\n \"0.64049965\",\n \"0.6397094\",\n \"0.6397024\",\n \"0.63900036\",\n \"0.6384104\",\n \"0.63604754\",\n \"0.6351992\",\n \"0.63515204\",\n \"0.6351106\",\n \"0.6347582\",\n \"0.63464427\",\n \"0.63452816\",\n \"0.634521\",\n \"0.63430417\",\n \"0.6341433\",\n \"0.6339789\",\n \"0.6337538\",\n \"0.63374823\",\n \"0.6337134\",\n \"0.63348687\",\n \"0.6333594\",\n \"0.6330974\",\n \"0.6329518\",\n \"0.63287526\",\n \"0.63277394\",\n \"0.63277394\",\n \"0.63232505\",\n \"0.6321646\",\n \"0.6305777\",\n \"0.63051134\",\n \"0.63036674\",\n \"0.6303531\",\n \"0.630035\",\n \"0.62995684\",\n \"0.62947065\",\n \"0.6294498\",\n \"0.6294331\",\n \"0.62860334\",\n \"0.6283809\",\n \"0.6281495\",\n \"0.62813765\",\n \"0.6277486\",\n \"0.6277146\",\n \"0.6273255\",\n \"0.627246\",\n \"0.62722933\",\n \"0.6268907\",\n \"0.6268907\",\n \"0.6268907\",\n \"0.6268907\",\n \"0.62675333\",\n \"0.62674457\",\n \"0.6266913\",\n \"0.6265541\",\n \"0.62647545\",\n \"0.62567884\",\n \"0.6251068\",\n \"0.6248089\",\n \"0.6246146\",\n \"0.6242203\",\n \"0.6238597\",\n \"0.6236463\",\n \"0.6234091\",\n \"0.62310386\",\n \"0.6230642\",\n \"0.6229875\",\n \"0.6228716\",\n \"0.6227635\",\n \"0.6226918\",\n \"0.62244433\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":10497,"cells":{"query":{"kind":"string","value":"Get arguments from command line"},"document":{"kind":"string","value":"def getArgumentParser():\n parser = argparse.ArgumentParser(description=\"Script for running optimization for the ZH dark photon SR\")\n parser.add_argument('-i',\n '--infile',\n dest='infile',\n help='Input CSV file',\n default = '/afs/cern.ch/work/s/ssevova/public/dark-photon-atlas/zhdarkphotonml/samples/v09/mc16d_v09_samples.csv')\n parser.add_argument('-o',\n '--output',\n dest='outdir',\n help='Output directory for plots, selection lists, etc',\n default='outdir')\n parser.add_argument('--plotInputs',action='store_true', help='Plot scaled train & test inputs')\n parser.add_argument('--plotOutputs',action='store_true', help='Plot scaled test outputs for given probability range')\n parser.add_argument('--lower',help='Lower limit for conditional filtering')\n parser.add_argument('--upper',help='Upper limit for conditional filtering')\n\n return parser"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_cli_arguments(self):\n pass","def get_command_line_args():\n \n parser = argparse.ArgumentParser()\n parser.add_argument('-s', '--symbol', help='symbol query')\n\n # no limit should be input as 'max'\n parser.add_argument('-l',\n '--limit',\n help='limit on number of image results',\n default='max')\n parser.add_argument('-d', '--directory', help='image directory')\n args = parser.parse_args()\n return args","def get_args_from_command_line():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--input_csv_path\", type=str)\n parser.add_argument(\"--text_column_order\", type=int)\n args = parser.parse_args()\n return args","def get_args():\n\n parser = get_argument_parser()\n args = parser.parse_args()\n\n return args","def process_command_line_arguments() -> Namespace:\n\n parser = build_parser()\n arguments = parser.parse_args()\n\n return arguments","def get_args():\n if len(sys.argv) == 3:\n return sys.argv[1:]\n print(\"USAGE: python3 extract_cds.py infile outfile\\n\\n\")\n exit()","def get_args_from_command_line():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--country_code\", type=str, default='US')\n args = parser.parse_args()\n return args","def get_args_from_command_line():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--country_code\", type=str,\n help=\"Country code\",\n default=\"US\")\n parser.add_argument(\"--n_workers\", type=int, help=\"number of workers\",\n default=20)\n parser.add_argument(\"--survey_link\", type=str)\n parser.add_argument(\"--block_size\", help='number of tweets per worker', type=int)\n parser.add_argument(\"--version_number\", type=str)\n parser.add_argument(\"--mode\", type=str, help='Whether to create HIT in sandbox or in production')\n parser.add_argument(\"--language_qualification\", type=int, help='')\n\n args = parser.parse_args()\n return args","def get_args(args):\n parser = parse_arguments()\n return parser.parse_args(args)","def _parse_command_line_arguments():\n parser = ArgumentParser(\n description=(\n 'Command-line tool to generate a list of unique from a TS file from FermiFAST'\n ),\n )\n parser.add_argument(\n 'ts-file',\n type=str,\n help=(\n 'A file containing the TS sky map'\n ),\n )\n parser.add_argument('--skiprows',\n type=int,\n help='number of rows to skip at the top (default 0)',\n required=False)\n parser.set_defaults(skiprows=0)\n arguments = vars(parser.parse_args())\n return arguments","def command_line_arguments():\n\n try:\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\n\n # Add required arguments.\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\n\n # Parse the arguments\n args = parser.parse_args()\n\n return args\n\n except Exception as err:\n print(err)\n return","def get_args():\n parser = argparse.ArgumentParser(description='Runner for tasks')\n parser.add_argument('--db_url', help='Database url string to the db.', required=True)\n return parser.parse_args()","def get_args():\n parser = argparse.ArgumentParser(\n description=\"Extract a sample of the data.\")\n\n parser.add_argument(\"userid\", help=\"User ID\")\n parser.add_argument(\"start\", help=\"Start\")\n parser.add_argument(\"end\", help=\"End\")\n parser.add_argument(\"source\", help=\"Source data file\")\n parser.add_argument(\"dest\", help=\"Destination file\")\n\n return parser.parse_args()","def get_command_line_args():\n\tparser: ArgumentParser = argparse.ArgumentParser()\n\tparser.add_argument('-t', '--t_blank', help=\"Number of blanks until delimiter\", default=20)\n\tparser.add_argument('-k', '--k_copynum', help=\"Number of numbers to copy\", default=3)\n\tparser.add_argument('-m', '--model', help=\"Choose model RNN, LSTM or MLP\", default='MLP')\n\targs = parser.parse_args()\n\treturn args","def get_args():\n parser = argparse.ArgumentParser()\n arg = parser.add_argument\n\n arg('--raw_source_dir',\n default=os.path.expanduser(\n '~/Personal/Columbia/Applied_DL/Camelyon_Project/data/source_data'))\n arg('--meta_data_dir',\n default=os.path.expanduser(\n '~/Personal/Columbia/Applied_DL/Camelyon_Project/data/test_dir'))\n arg('--img_data_dir',\n default=os.path.expanduser(\n '~/Personal/Columbia/Applied_DL/Camelyon_Project/data/test_dir/input_data'))\n arg('--output_data_dir',\n default=os.path.expanduser(\n '~/Personal/Columbia/Applied_DL/Camelyon_Project/data/test_dir/output_data'))\n\n arg('--img_partition_option', default='zoom_1_256_256')\n\n input_args = parser.parse_known_args()[0]\n\n return input_args","def get_args():\n\tparser = argparse.ArgumentParser(\n\t\t\tdescription=\"\"\"Re-sorts multi-locus bootstraps by loci\"\"\")\n\tparser.add_argument(\n\t\t\t\"--input\",\n\t\t\trequired=True,\n\t\t\ttype=is_dir,\n\t\t\taction=FullPaths,\n\t\t\thelp=\"\"\"The input directory containing multi-locus bootstraps\"\"\"\n\t\t)\n\tparser.add_argument(\n\t\t\t\"--bootstrap_replicates\",\n\t\t\trequired=True,\n\t\t\ttype=is_file,\n\t\t\taction=FullPaths,\n\t\t\thelp=\"\"\"The file containing bootstrap replicate sampling\"\"\"\n\t\t)\n\tparser.add_argument(\n\t\t\t\"--output\",\n\t\t\trequired=True,\n\t\t\taction=CreateDir,\n\t\t\thelp=\"\"\"The output directory that will contain sorted bootstraps\"\"\"\n\t\t)\n\treturn parser.parse_args()","def _read_cmd_args():\n\n # Check if argument count is correct.\n if len(sys.argv) != 5:\n print(\"[ERR] Invalid number of command line arguments!\")\n _usage()\n sys.exit(1)\n\n # Get path to config file\n configfile = sys.argv[1]\n if not os.path.exists(configfile):\n print(f\"[ERR] Config file {configfile} does not exist!\")\n sys.exit(1)\n\n # Get top directory of LIS data\n topdatadir = sys.argv[2]\n if not os.path.exists(topdatadir):\n print(f\"[ERR] LIS data directory {topdatadir} does not exist!\")\n sys.exit(1)\n\n # Get valid year and month\n yyyymm = sys.argv[3]\n if len(yyyymm) != 6:\n print(\"[ERR] Invalid length of YYYYMM, must be 6 characters!\")\n sys.exit(1)\n year = int(yyyymm[0:4])\n month = int(yyyymm[4:6])\n try:\n startdate = datetime.datetime(year, month, day=1)\n except ValueError:\n print(\"[ERR] Invalid YYYYMM passed to script!\")\n sys.exit(1)\n\n # Get model forcing ID\n model_forcing = sys.argv[4]\n\n return configfile, topdatadir, startdate, model_forcing","def get_args():\n parser = argparse.ArgumentParser(\n description=\"\"\"Given an input LASTZ file, output a BED-formatted file of locus coordinates\"\"\"\n )\n parser.add_argument(\n \"--alignments\",\n required=True,\n type=is_dir,\n action=FullPaths,\n help=\"\"\"The input directory containing LASTZ files\"\"\",\n )\n parser.add_argument(\n \"--output\",\n required=True,\n action=CreateDir,\n help=\"\"\"The output directory to hold BED-formatted files\"\"\",\n )\n parser.add_argument(\n \"--regex\",\n type=str,\n default=\"^(uce-\\d+)(?:_p\\d+.*)\",\n help=\"\"\"A regular expression to apply to the probe sequences for replacement\"\"\",\n )\n parser.add_argument(\n \"--verbosity\",\n type=str,\n choices=[\"INFO\", \"WARN\", \"CRITICAL\"],\n default=\"INFO\",\n help=\"\"\"The logging level to use.\"\"\",\n )\n parser.add_argument(\n \"--log-path\",\n action=FullPaths,\n type=is_dir,\n default=None,\n help=\"\"\"The path to a directory to hold logs.\"\"\",\n )\n return parser.parse_args()","def _get_args():\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument('--env', '-e',\n type=str,\n default='Zelda1-v0',\n choices=['Zelda1-v0'],\n help='The environment to play'\n )\n parser.add_argument('--mode', '-m',\n type=str,\n default='human',\n choices=['human', 'random'],\n help='The execution mode for the environment.'\n )\n parser.add_argument('--steps', '-s',\n type=int,\n default=500,\n help='The number of random steps to take.',\n )\n return parser.parse_args()","def get_args():\n\n parser = argparse.ArgumentParser(description=\"Get DC, Clusters, Hosts and VM in JSON.\")\n parser.add_argument('-H', '--host', nargs=1, required=True, help='The vCenter to connect to',\n dest='host', type=str)\n parser.add_argument('-p', '--password', nargs=1, required=False,\n help='The password with which to connect to the VC. If not specified, the user is prompted at runtime for a password',\n dest='password', type=str)\n parser.add_argument('-u', '--user', nargs=1, required=True, help='The username with which to connect to the host',\n dest='username', type=str)\n args = parser.parse_args()\n return args","def parse_arguments(args):","def process_command_line_input():\n\n input_args = sys.argv\n if input_args[0].find('ipython') >= 0:\n input_args = list()\n else:\n input_args.pop(0)\n\n return input_args","def get_args():\n parser = argparse.ArgumentParser(\n description=\"Obstacle avoidance python script.\"\n )\n\n # Required arguments\n parser.add_argument(\"-n\", \"--number\",\n action=\"store\",\n required=False,\n help=\"Add a pheeno number namespace.\",\n default=\"\")\n\n # The rationale behind rospy.myargv()[1:] is provided here:\n # https://groups.google.com/a/rethinkrobotics.com/forum/#!topic/brr-users/ErXVWhRmtNA\n return parser.parse_args(rospy.myargv()[1:])","def get_args(self):\n req_argv = self._ptr.contents.argv\n args = []\n if bool(req_argv):\n i = 0\n while 1:\n s = bytestostr(req_argv[i])\n i += 1\n if s == None:\n break\n args.append(s)\n return args","def get_args():\n parser = argparse.ArgumentParser(description='Download genome')\n parser.add_argument(\"accession\", help=\"NCBI Accession Number\")\n parser.add_argument(\"email\", help=\"E-mail address\")\n return parser.parse_args()","def parse_cmdline():\n\tparser = ArgumentParser(prog=\"FastP_QC.py\", description=\"\"\"Script collects stats from fastp jsons.\"\"\")\n\tparser.add_argument(\"-r1\", \"--r1_stats\", dest=\"r1_stats\", action=\"store\", required=True, help=\"Text file with r1 stats, from q30.py script.\")\n\tparser.add_argument(\"-r2\", \"--r2_stats\", dest=\"r2_stats\", action=\"store\", required=True, help=\"Text file with r2 stats, from q30.py script.\")\n\tparser.add_argument(\"-n\", \"--name\", dest=\"name\", action=\"store\", required=True, help=\"Sample name\")\n\targs = parser.parse_args()\n\treturn args","def get_args():\n parser = argparse.ArgumentParser(add_help=False)\n\n parser.add_argument(\n '--ckpt_path',\n type=str,\n help='ckpt path')\n\n parser.add_argument('--gpu', action='store_false', help='gpu/cpu')\n parser.add_argument(\n '--img_path',\n type=str,\n help='image path')\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\")\n parser.add_argument(\"--visualization\", \"-v\", action=\"store_true\", help=\"if generated clouds should be visualized\")\n parser.add_argument(\"--directory\", \"-d\",\n help=\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\")\n args = parser.parse_args()\n return args.visualization, args.directory","def get_args():\n parser = argparse.ArgumentParser(description=\"Arguments for data exploration\")\n parser.add_argument(\"--tokenize\",\n dest=\"tokenize\",\n action=\"store_true\",\n help=\"Tokenize by words and sentences, counting averages/sd for each.\")\n return parser","def get_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--all_info\", required=False, action=\"store_true\", help=\"Represents: list of files in a \"\n \"current directory; \"\n \"core version; \"\n \"OS version; \"\n \"list of all processes\")\n parser.add_argument(\"--proc_info\", required=False, help=\"Represents list of all processes or info \"\n \"about provided process. \"\n \"Name of a searching process should be provided.\"\n \"'all' is to show all processes\")\n parser.add_argument(\"--core_version\", required=False, action=\"store_true\", help=\"Represents core version\")\n parser.add_argument(\"--os_version\", required=False, action=\"store_true\", help=\"Represents OS version\")\n parser.add_argument(\"--cur_dir_info\", required=False, action=\"store_true\", help=\"Represents list of files in a \"\n \"current directory\")\n parser.add_argument(\"--dir_info\", required=False, nargs='?', help=\"Represents list of files in a \"\n \"provided directory.\")\n args = parser.parse_args()\n return args","def get_args():\n parser = argparse.ArgumentParser(description='Simple dmenu launcher for passwords, notes and application shortcuts.')\n group = parser.add_mutually_exclusive_group()\n\n group.add_argument('--pass', dest='passw', action='store_true',\n help='Copy password from password store.')\n group.add_argument('--apps', action='store_true',\n help='Quick launches a desktop application with exo-open.')\n group.add_argument('--notes', action='store_true',\n help='Opens a text/markdown note from a given directory with exo-open.')\n group.add_argument('--search', action='store_true',\n help='Quick search and launch from a given directory with exo-open.')\n\n if not len(sys.argv) > 1:\n parser.print_help()\n sys.exit(1)\n\n return parser.parse_args()","def get_args(argv):\r\n parser = argparse.ArgumentParser()\r\n parser.add_argument(\"design\", help=\"design file name\")\r\n parser.add_argument(\"-v\", \"--verbose\", action=\"store_true\",\r\n help=\"print a verbose report\")\r\n return parser.parse_args(argv)","def cmd_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--image\",\n help=\"Full image path can be optionally supplied.\")\n args = parser.parse_args()\n return args","def get_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--input\",\n help=\"text file, one compound per line\", required=True)\n parser.add_argument(\"-j\", \"--jsononto\",\n help=\"json ontology of families\", required=True)\n parser.add_argument(\"-o\", \"--output\",\n help=\"output file\", required=True)\n parser.add_argument(\"-e\", \"--encoded\",\n help=\"identifiers are encoded\", action=\"store_true\", default=False)\n\n args = parser.parse_args()\n\n run_analysis(args.input, args.jsononto, args.output, args.encoded)","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # All reference encoders\n parser.add_argument(\"--step\", dest=\"step\", default=\"10\", type=int, help=\"step size\")\n parser.add_argument(\"--repeats\", dest=\"repeats\", type=int, default=1, help=\"repeats\")\n\n parser.add_argument(dest=\"image\", default=None,\n help=\"select the test image to run\")\n\n args = parser.parse_args()\n return args","def get_args():\n parser = argparse.ArgumentParser(\n description='Standard Arguments for talking to Distributed Index Server')\n parser.add_argument('-c', '--config',\n required=True,\n action='store',\n help='Config file of the network')\n parser.add_argument('-i', '--index',\n type=int,\n required=True,\n action='store',\n help='key range start index')\n parser.add_argument('-e', '--end',\n type=int,\n required=True,\n action='store',\n help='key range end index')\n parser.add_argument('-o', '--operation',\n type=int,\n required=True,\n action='store',\n help='operation: 1.Register & Search ops 2.Obtain ops')\n args = parser.parse_args()\n return args","def getargs(ver='%prog 0.0'):\n parser = argparse.ArgumentParser(\n description=open(__file__).read().split(\"'''\")[1],\n formatter_class=argparse.RawDescriptionHelpFormatter) \n #@todo: OptionParser is depreciated in Python 3.2. \n #Need to move to the new style of parser. \n parser.add_argument(\"--fasta_a_name\", \n required=True,\n help = \"REQUIRED: The name of the fasta file a.\")\n parser.add_argument(\"--fasta_b_name\", \n required=True,\n help = \"REQUIRED: The name of the fasta file a.\")\n parser.add_argument(\"--set_operation\", \n default=\"U\",\n help = \"The operation you want to do. \")\n \n args = parser.parse_args()\n \n fasta_a_name = args.fasta_a_name\n fasta_b_name = args.fasta_b_name\n set_operation = args.set_operation\n \n return fasta_a_name,fasta_b_name,set_operation","def get_args():\n parser = argparse.ArgumentParser(\n description=\"Sets up package within the pheeno's directory.\"\n )\n\n # Required arguments\n parser.add_argument(\"-x\", \"--execute\", action=\"execute\", required=True,\n help=\"something\", default=False)\n\n # Optional arguments\n parser.add_argument(\"-s\", \"--save\", action=\"store\", required=False,\n help=\"something\", default=False)","def parse_cmdline(get_parser=get_parser_files):\n return get_parser().parse_args()","def get_args():\n parser = argparse.ArgumentParser(description=\"Processing tweets\")\n\n parser.add_argument(\"-db\", \"--db\", type = str, required = True, \n help = \"The Name of Database to store\")\n\n args = parser.parse_args()\n \n return args","def GetArgs():\n parser = argparse.ArgumentParser(\n description='Process args for retrieving all the Virtual Machines')\n parser.add_argument('-s', '--host', required=True, action='store',\n help='Remote host to connect to')\n parser.add_argument('-o', '--port', type=int, default=443, action='store',\n help='Port to connect on')\n parser.add_argument('-u', '--user', required=True, action='store',\n help='User name to use when connecting to host')\n parser.add_argument('-p', '--password', required=False, action='store',\n help='Password to use when connecting to host')\n args = parser.parse_args()\n return args","def ReadArguments():\n\n args = ParseArguments()\n\n logging.info('Command line arguments...')\n for arg in vars(args):\n logging.info(str(arg) + ': ' + str(getattr(args, arg)))\n logging.info('')\n\n IsTest(args)\n ProcessCacheSize(args)\n ProcessLineSize(args)\n ProcessMulti(args)\n ProcessMemPattern(args)\n ProcessMemFile(args)","def get_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"model_type\")\n parser.add_argument(\"run_name\")\n parser.add_argument(\"run_comment\")\n parser.add_argument(\"epoch\")\n parser.add_argument(\"--verbose\", default=True)\n args = parser.parse_args()\n return (args.model_type, args.run_name, args.run_comment, args.epoch, args.verbose)","def __get_cli_args():\r\n parser = argparse.ArgumentParser()\r\n o = parser.add_mutually_exclusive_group()\r\n o.add_argument('-a', action='store_true')\r\n o.add_argument('-b', action='store_true')\r\n parser.add_argument('-suite', help='suite file name for execution')\r\n parser.add_argument('-log', help='LOG level for the execution', default='INFO',\r\n choices=['INFO', 'DEBUG', 'WARNING', 'ERROR', 'CRITICAL'])\r\n args = parser.parse_args()\r\n return args","def get_args():\n parser = argparse.ArgumentParser(description='Compare core genomes')\n parser.add_argument(\"directory\", help=\"Directory of alignments\", \n type=is_dir, action=FullPaths)\n return parser.parse_args()","def get_arguments(args_in):\n parser = argparse.ArgumentParser(description=\"Model Evaluation\")\n\n add_global_arguments(parser)\n args = parser.parse_args(args_in)\n check_global_arguments(args)\n\n return args","def parse_command_line():\n parser = argparse.ArgumentParser(description='Parses ID\\'s from the DDI compendium search results, and then downloads the html and puts them into a sqlite database.')\n parser.add_argument('-f', '--file', dest='file',\n action='store',\n help='Filenname to be read')\n arg_manager = parser.parse_args()\n return arg_manager","def get_arguments():\n parser = argparse.ArgumentParser(description=\"\"\"\n Yield a sorted frequency count of similar/dissimilar InChi DW/OpenBabel.\n\"\"\")\n\n parser.add_argument(\n \"file\",\n help=\"DataWarrior's list file exported after running the macro.\")\n args = parser.parse_args()\n\n data = args.file\n return data","def parse_command_line_arguments(argv):\n print(\"reading command line arguments in...\")\n\n parser = argparse.ArgumentParser(description='Description of your program')\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\n args = parser.parse_args()\n\n return args.input, args.predicting, args.scoring, args.scale","def get_args():\n use = (\"%prog is used to run user-specified actions against files. It is \"\n \"typically scheduled to run periodically, and uses a config file for \"\n \"criteria. \\n\"\n \" \\n\"\n \" %prog [file] [misc options]\")\n\n parser = argparse.ArgumentParser(description=use,\n formatter_class=argparse.RawTextHelpFormatter)\n\n parser.add_argument('--config-name',\n dest='config_name',\n default=None,\n help='Specifies the name of the config file in the standard xdg datagristle config')\n parser.add_argument('-c', '--config-file',\n dest='config_file',\n default=None,\n help='Specifies the name of the config file in a user-specified directory')\n parser.add_argument('--log-dir',\n dest='log_dir',\n default=None,\n help='Overrides the xdg-default logging directory. XDG default on linux is $HOME/.cache/datagristle/gristle_process')\n parser.add_argument('--log-level',\n dest='log_level',\n choices=['debug', 'info', 'warning', 'error', 'critical'],\n help='Specifies level of detail in logs. Default is None - which leaves it to the config file.')\n\n parser.add_argument('--testrun',\n default=False,\n action='store_true',\n dest='test_run',\n help=('Identify files to act upon - but just list them'))\n\n parser.add_argument('--long-help',\n default=False,\n action='store_true',\n help='Print more verbose help')\n\n args = parser.parse_args()\n\n if args.long_help:\n print(__doc__)\n sys.exit(0)\n\n\n return args","def get_command_line_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'docx_path', help=\"path to directory containing docx files\")\n parser.add_argument(\n '-sn', '--save_name', help=\"name of the directory containing the marked text files\")\n args = parser.parse_args()\n\n return args","def get_args():\n arg_parser = argparse.ArgumentParser(description='run the if')\n arg_parser.add_argument('story', help='story to run')\n arg_parser.add_argument('-D', '--debug',\n action='store_true',\n help='turn on debugging')\n\n args = arg_parser.parse_args()\n return vars(args)","def commandline():\n command_parser = argparse.ArgumentParser(description=__doc__, epilog=epilog, formatter_class=argparse.RawDescriptionHelpFormatter)\n command_parser.add_argument('-i','--input_file', type=str, required=True, help='input file.')\n command_parser.add_argument('-o','--output_file', type=str, required=True, help='output file.')\n args = command_parser.parse_args()\n return args","def get_argv_list(args):\n # parse the string format of arguments and return a list of arguments\n argv = args.split(' ')\n if len(argv) == 1 and argv[0] == '':\n return []\n return argv","def _read_cmd_args():\n\n # Check if argument count is correct.\n if len(sys.argv) != 4:\n print(\"[ERR] Invalid number of command line arguments!\")\n print(len(sys.argv))\n print(sys.argv[:])\n _usage()\n sys.exit(1)\n\n # Check if lis.config template exists.\n lis_config_template = sys.argv[1]\n if not os.path.exists(lis_config_template):\n print(f\"[ERR] {lis_config_template} does not exist!\")\n sys.exit(1)\n\n # Check if directory for restart files exists. Actual restart file\n # shall be checked later.\n restart_dir = sys.argv[2]\n if not os.path.exists(restart_dir):\n print(f\"[ERR] Directory {restart_dir} does not exist!\")\n sys.exit(1)\n\n # Get start date of new LIS run.\n yyyymmdd = sys.argv[3]\n if len(yyyymmdd) != 8:\n print(\"[ERR] Invalid length for YYYYMMDD, must be 8 characters!\")\n sys.exit(1)\n year = int(yyyymmdd[0:4])\n month = int(yyyymmdd[4:6])\n day = int(yyyymmdd[6:8])\n try:\n startdate = datetime.date(year, month, day)\n except ValueError:\n print(\"[ERR] Invalid YYYYMMDD passed to script!\")\n sys.exit(1)\n\n return lis_config_template, restart_dir, startdate","def command_line_args(parser):\n AbyssAssembler.command_line_args(parser)\n SpadesAssembler.command_line_args(parser)\n TrinityAssembler.command_line_args(parser)\n VelvetAssembler.command_line_args(parser)","def args(self):\n return self.cmd_args","def get_arguments():\n parser = argparse.ArgumentParser(description=\"Argument Parser\")\n parser.add_argument(\"--batch-size\", type=int, default=BATCH_SIZE,\n help=\"Number of images sent to the network in one step.\")\n print('parsing')\n return parser.parse_args()","def get_args():\n argparser = argparse.ArgumentParser(description=__doc__)\n argparser.add_argument(\n \"-c\",\n \"--config\",\n metavar=\"C\",\n default=\"None\",\n help=\"The Configuration file\",\n )\n args = argparser.parse_args()\n return args","def GetArgs():\n\tparser = argparse.ArgumentParser(description='Process args for retrieving all the Virtual Machines')\n\tparser.add_argument('-s', '--host', required=True, action='store', help='Remote host to connect to')\n\tparser.add_argument('-o', '--port', type=int, default=443,\taction='store', help='Port to connect on')\n\tparser.add_argument('-u', '--user', required=True, action='store', help='User name to use when connecting to host')\n\tparser.add_argument('-p', '--password', required=True, action='store', help='Password to use when connecting to host')\n\tparser.add_argument('-m', '--vm', required=True, action='store', help='On eor more Virtual Machines to report on')\n\tparser.add_argument('-i', '--int', type=int, default=15, action='store', help='Interval to average the vSphere stats over')\n\targs = parser.parse_args()\n\treturn args","def readArgs():\n parser = argparse.ArgumentParser(description=\n \"\"\"Debug script. This program is used in order to generate a summary\n statistics for the csv files generated by the annotation_parser. Things\n like the average amount of overlap of each window and the average deviation.\n \"\"\")\n\n parser.add_argument('-f', '--csv-dir', metavar='',\n dest='csv_dir',\n action='store', default=os.path.dirname(os.path.abspath(__file__)),\n help='Specify the csv directory.')\n parser.add_argument('-d', '--deviation', metavar='',\n dest='deviation', action='store',\n default=50,\n help='percentage set point from which evaluate the deviation from.')\n\n return parser.parse_args()","def get_args():\n parser = argparse.ArgumentParser(\n description='Some Basic Spark Job doing some stuff on IMDb data stored within HDFS.')\n return parser.parse_args()","def get_args():\n parser = argparse.ArgumentParser(\n description='Grab the various stream profile bitrates and resolutions for master m3u8 files')\n\n parser.add_argument('-f', '--file',\n action='store',\n help='File of URLs to load. This overrides a URL provided on the command-line')\n\n parser.add_argument('-o', '--output',\n action='store',\n help='Filename to write output to.')\n\n parser.add_argument('-a', '--append',\n action='store_true',\n default=False,\n help='Append to the file given with the --output argument as opposed to overwriting the file')\n\n parser.add_argument('url',\n nargs='?', default='NO_URL',\n action='store',\n help='The url of the master m3u8 playlist')\n\n\n\n args = parser.parse_args()\n if args.url == \"NO_URL\" and not args.file:\n print >> sys.stderr, \"Error: You must either specify a URL on the command-line or provide a filename via the --file argument\\n\\n\"\n parser.print_help()\n exit(1)\n\n return args","def get_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('color', help='What color would you like for the '\n 'player?',\n choices=['blue', 'green', 'magenta'])\n parser.add_argument('image_folder', help='Folder contains images',\n type=file_type)\n parser.add_argument('-f', '--fast', help='Fast or slow game',\n action='store_true')\n arguments = parser.parse_args()\n color = arguments.color\n image_folder = arguments.image_folder\n fast = arguments.fast\n return color, image_folder, fast","def args(self):\n return self._parse_args","def get_cmdl_args():\n parser = argparse.ArgumentParser(description=\"Arguments needed to run \"\n \"python scripts eg. \"\n \"cluster_vip,\"\n \"UserName & Password\")\n parser.add_argument(\"-i\", \"--cluster_vip\", help=\"Cluster VIP to login\")\n parser.add_argument(\"-u\", \"--user\", help=\"Username to login\")\n parser.add_argument(\"-p\", \"--password\", help=\"password to login\")\n args = parser.parse_args()\n return args","def getArguments():\n dfPath = sys.argv[1]\n if(len(sys.argv) == 4):\n pop = int(sys.argv[2])\n gen = int(sys.argv[3])\n else:\n pop = 10\n gen = 2\n return dfPath, pop, gen","def _argsForSubprocess(self) -> list[str]:\n pass","def get_args():\n parser = argparse.ArgumentParser(description=__doc__)\n\n parser.add_argument('--batch_size', type=int, default=64,\n help='The batch size to load the data. (default: 64)')\n parser.add_argument('--num_workers', type=int, default=4,\n help=('The number of worker processes to use in '\n 'loading the dataset. (default: 4)'))\n parser.add_argument('--num_epochs', type=int, default=30,\n help=('The number of training epochs to run. (default:'\n '30)'))\n parser.add_argument('--learning_rate', type=float, default=0.1,\n help='The learning rate for SGD. (default: 0.1)')\n parser.add_argument('--momentum', type=float, default=0.9,\n help='The momentum for SGD. (default: 0.9)')\n parser.add_argument('--checkpoint',\n help='The path of the checkpoint file to load')\n parser.add_argument('--cuda', default=False, action='store_true',\n help='Use GPU if available.')\n\n args = parser.parse_args(sys.argv[1:])\n\n return args","def getargs():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"path\", type=chkpath, nargs=\"?\", default=\".\", help=\"a valid path\"\n )\n parser.add_argument(\n \"-v\", \"--verbosity\", action=\"count\", default=0, help=\"increase output verbosity\"\n )\n return parser.parse_args()","def get_args():\n parser = argparse.ArgumentParser(description=__doc__.strip())\n parser.add_argument(\"sparkylist\", type=str,\n help=\"sparky file to be converted\")\n parser.add_argument(\"output\", type=str, help=\"name of output csv file\")\n parser.add_argument(\"--hch\", action=\"store_true\",\n help=\"hch instead of cch\")\n return parser.parse_args()","def get_args():\n parser = argparse.ArgumentParser(description='\"Some Input argu for Generate Fragsize Distribution.')\n parser.add_argument('-i', '--input', required=True, action='store',\n help=\"Input File of .molucule.table\")\n parser.add_argument('-o', '--output', required=True, action='store',\n help=\"Output File of .fragsize_distribution.txt\")\n \n return parser.parse_args()","def get_args():\n parser = argparse.ArgumentParser('Find a featureclass, database, mxd, or service in ArcGIS Server',\n epilog='For search strings inlcuding spaces, enclose the query in double-quotes')\n parser.add_argument('name', help='string for which to search (blank returns info on all services)',\n nargs='?', default='')\n parser.add_argument('-q', '--quiet', help='only display service names and URLs', action='store_true')\n parser.add_argument('-qq', '--veryquiet', help='only display service URLs, comma delimited', action='store_true')\n parser.add_argument('-cs', '--configstore', help='explicitly provide full path to config store', action='store')\n parser.add_argument('-csv', '--tocsv', help='create csv output', action='store_true')\n parser.add_argument('-md', '--markdown', help='create Markdown output', action='store_true')\n return parser.parse_args()","def getPositionalArgs():","def get_args( self, ):\r\n for iarg in sys.argv[1:]:\r\n #print iarg\r\n argsplits = iarg.split(\"=\")\r\n parm_name = argsplits[0]\r\n parm_value = argsplits[1]\r\n\r\n # so far only one is captured\r\n if parm_name == \"parameters\":\r\n self.parmeters_x = parm_value #\r\n msg = \"command line arg >>{iarg}\" # log file not open but use alt\r\n AppGlobal.logger.info( msg )\r\n else:\r\n msg = \"no parmeter extensions\"\r\n AppGlobal.logger.info( msg )\r\n return","def parse_cmdline_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-v', '--verbose',\n action=\"store_true\",\n help=\"Be chatty\")\n parser.add_argument('-d', '--dryrun',\n action=\"store_true\",\n help=\"Do not send emails\")\n foreman_config = ForemanConfig()\n foreman_config.add_standard_args(parser)\n parser.add_argument('-e', '--environments', type=str,\n default=DEFAULT_ENVIRONMENTS_PATH,\n help=\"Clone of it-puppet-environments\")\n args = parser.parse_args()\n return args","def get_args():\n parser = argparse.ArgumentParser(\n description='Utterance level classification Leave one '\n 'speaker out schema pipeline' )\n parser.add_argument('-i', '--input_features_paths', nargs='+',\n help='File paths of the features you want to '\n 'concatenate and the classify')\n args = parser.parse_args()\n return args","def input_args():\n return filter(lambda x: len(x) > 0,\n map(lambda x: x.strip(), sys.argv[1:]))","def get_arguments():\n # Parsing arguments\n parser = argparse.ArgumentParser(description=__doc__, usage=\n \"{0} -h (see also \"\n \"ftp://ftp.ncbi.nih.gov/pub/taxonomy/)\"\n .format(sys.argv[0]))\n parser.add_argument('-i', dest='blast_output_file', type=isfile,\n required=True, help=\"blast_output_file\")\n parser.add_argument('-d', dest='taxadb_file', type=isfile,\n required=True, help=\"Taxadb file\")\n parser.add_argument('-o', dest='taxonomy_file', type=str, required=True,\n help=\"Output taxonomy_file\")\n return parser.parse_args()","def parse_arguments():\n # shift away script name\n scriptname=sys.argv[0]\n shift()\n ncl_cmd=list()\n quali_cmd=list()\n id_cmd=list() \n while(len(sys.argv)>0):\n carg = sys.argv[0]\n shift()\n if(carg == \"--nucleotide\"):\n ncl_cmd = mungeArgs(sys.argv)\n elif(carg == \"--quality\"):\n quali_cmd = mungeArgs(sys.argv)\n elif(carg == \"--id\" ):\n id_cmd = mungeArgs(sys.argv)\n elif(carg in [\"-h\", \"--help\"]):\n usage()\n else:\n usage(error=True)\n # Excess arguments which are not processed \n if(len(sys.argv) > 0):\n sys.stdout.write(\"Excess arguments!\\n\")\n sys.stdout.flush()\n usage(error=True)\n\n # external modules rely on non-empty argv array, \n # re-append the script name as first command line argument\n sys.argv.append(scriptname)\n return (id_cmd, ncl_cmd, quali_cmd)","def get_arguments_from_cmd():\n\n parser = argparse.ArgumentParser(description=\"\\\n Script for getting the depth of a specific node in a directed \\\n acyclic graph given it root node. \\n\")\n\n parser.add_argument(\"-i\", type=str, required=True,\n help=\"Path to the CSV or tab delimited file \\\n of graph Adjacency matrix of graph\")\n parser.add_argument(\"-r\", type=int, required=True,\n help=\"Root node of the graph\")\n parser.add_argument(\"-n\", type=int, required=True,\n help=\"Node of interest, \"\n \"for which we want to know its depth\")\n\n return parser.parse_args()","def get_arguments(args=None):\n parser = ArgumentParser(prog='rmsd',\n usage='%(prog)s xyzfile1 xyzfil2 [options] ',\n description='''Compute rmsd between 2 xyzfiles''',\n formatter_class=ArgumentDefaultsHelpFormatter\n )\n parser.add_argument('xyzfile1', help='xyzfile1')\n parser.add_argument('xyzfile2', help='xyzfile2')\n opts = parser.parse_args(args)\n return opts","def get_arguments_from_user() -> list:\n\n print(\"Für weitere Konfiguration bitte das Programm direkt über eine Konsole starten.\\nMit -h können alle Argumente aufgelistet werden\\n\")\n code = input(\"Impf-Code: \")\n plz = input(\"PLZ: \")\n bundesland = input(\"Bundesland des Zentrums (zB Baden-Württemberg): \")\n\n arguments = [\"-c\", code, \"-p\", plz, \"-b\", bundesland]\n return arguments","def getArguments():\n parser = argparse.ArgumentParser()\n\n # Required arguments\n parser.add_argument('dataset', help='\\\n The directory with the dataset (should have Images/, Annotations/).')\n \n # Optional arguments\n parser.add_argument('--list', default=\"all\", help='\\\n The list of images (ImageSets/{all ; trainval ; test ; ... }.txt).')\n \n return parser.parse_args()","def parse_arguments():\n arguments_parser = argparse.ArgumentParser()\n add_optional_arguments(arguments_parser)\n add_positional_arguments(arguments_parser)\n arguments = arguments_parser.parse_args()\n return [arguments.paths, _get_options(arguments)]","def read_command_line_arguments() -> Tuple[\n LocalConfig, AuthConfig, Optional[List[str]]\n]:\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"config\", type=str, help=\"Path to the main config file\"\n )\n parser.add_argument(\n \"auth\", type=str, help=\"Path to the authentication config file\"\n )\n parser.add_argument(\n \"--execute-now\",\n type=str,\n help=\"\"\"A set of channel names to execute immediately, or none to\n determine automatically based on the current time.\"\"\",\n nargs=\"*\",\n choices=notification_channels.keys(),\n )\n args = parser.parse_args()\n\n config_file = read_local_config(args.config)\n auth_file = read_local_auth(args.auth)\n\n return config_file, auth_file, args.execute_now","def get_command_line_arguments():\n parser = argparse.ArgumentParser(description='Training script for Lux RL agent.')\n parser.add_argument('--id', help='Identifier of this run', type=str, default=str(random.randint(0, 10000)))\n parser.add_argument('--learning_rate', help='Learning rate', type=float, default=0.001)\n parser.add_argument('--gamma', help='Gamma', type=float, default=0.995)\n parser.add_argument('--gae_lambda', help='GAE Lambda', type=float, default=0.95)\n parser.add_argument('--batch_size', help='batch_size', type=int, default=2048) # 64\n parser.add_argument('--step_count', help='Total number of steps to train', type=int, default=10000000)\n parser.add_argument('--n_steps', help='Number of experiences to gather before each learning period', type=int, default=2048*8)\n parser.add_argument('--path', help='Path to a checkpoint to load to resume training', type=str, default=None)\n args = parser.parse_args()\n\n return args","def command_line_parse(iargs=None):\n\n parser = create_parser()\n inps = parser.parse_args(args=iargs)\n\n return inps","def _get_args(self):\n parser = ArgumentParser(\n description=\"Dynamically generates Snakefiles for data \"\n \"integration and machine learning pipelines.\"\n )\n\n parser.add_argument(\n \"-c\",\n \"--config\",\n help=(\n \"Configuration filepath. (Will look for file named config.yml \"\n \"in current working directory, if none specified.)\"\n ),\n )\n\n parser.add_argument(\n \"-r\",\n \"--run\",\n default=False,\n help=(\n \"Runs pipeline, in addition to generating Snakefile.\"\n ),\n )\n\n # convert command-line args to a dict and return\n args = parser.parse_args()\n\n args = dict(\n (k, v) for k, v in list(vars(args).items()) if v is not None\n )\n\n return args","def getargs():\r\n parser = argparse.ArgumentParser(description='fetch all failed unit tests')\r\n parser.add_argument('dir_name', help='directory to check the junit results')\r\n parser.add_argument('url', help='bitbucket/stash url')\r\n args = parser.parse_args()\r\n return args","def get_args():\n\n parser = argparse.ArgumentParser(\n description=\"Script tests the HCSR04 sensor under different configurations\"\n )\n\n parser.add_argument(\n \"-t\",\n \"--trig\",\n type=int,\n help=\"Trig Pin (Required - must be an integer, must \\\n use BCM pin values)\",\n required=True,\n )\n\n parser.add_argument(\n \"-e\",\n \"--echo\",\n type=int,\n help=\"Echo Pin (Required - must be an integer, must \\\n use BCM pin values)\",\n required=True,\n )\n\n parser.add_argument(\n \"-sp\",\n \"--speed\",\n type=float,\n help=\"Time between individual reading samples \\\n (Optional - must be a float, default\\\n is 0.1 seconds)\",\n required=False,\n default=0.1,\n )\n\n parser.add_argument(\n \"-ss\",\n \"--samples\",\n type=int,\n help=\"Reading Sample Size (Optional - must be an \\\n integer, default is 11)\",\n required=False,\n default=11,\n )\n\n args = parser.parse_args()\n\n trig = args.trig\n echo = args.echo\n speed = args.speed\n samples = args.samples\n\n return trig, echo, speed, samples","def get_args():\n # parse command line args\n parser = argparse.ArgumentParser(\n description=HEADER,\n formatter_class=argparse.RawDescriptionHelpFormatter)\n parser.add_argument(\n '-c',\n '--config-file',\n default=os.path.join(os.path.dirname(__file__), 'config-user.yml'),\n help='Configuration file')\n parser.add_argument(\n '-r',\n '--recipe-files',\n type=str,\n nargs='+',\n help='Recipe files (list or single file)')\n parser.add_argument(\n '-d',\n '--main-dir',\n default=os.path.join(os.environ['HOME'], 'ESMVALTOOL_ROSE'),\n help='Main analysis directory; default to $HOME/ESMVALTOOL_ROSE')\n parser.add_argument(\n '-s',\n '--suite-dir',\n default=os.path.join(os.environ['HOME'], 'u-bd684'),\n help='u-bd684 suite directory; default to $HOME/u-bd684')\n parser.add_argument(\n '-n',\n '--no-submit',\n action='store_true',\n help=\"Flag to NOT submit the Rose suite.\")\n parser.add_argument(\n '-l',\n '--log-level',\n default='info',\n choices=['debug', 'info', 'warning', 'error'])\n args = parser.parse_args()\n return args","def parse_command_line_arguments():\n parser = argparse.ArgumentParser(\n description=\"Convert dependency files into list of GitHub links.\",\n epilog=\"For help with this program, contact John Speed at jmeyers@iqt.org.\",\n )\n parser.add_argument(\n \"--python\",\n default=False, # default value is False\n help=\"Convert requirements.txt file into GitHub links.\",\n )\n return parser.parse_args()","def parse_arguments(self,parser):\r\n return parser.parse_args()","def get_arguments():\n parser = argparse.ArgumentParser(description=\"Simple Jarvice CLI\",\n add_help=False)\n auth_group = parser.add_argument_group('auth', description='Configuration')\n auth_group.add_argument('-username', help='Jarvice username')\n auth_group.add_argument('-apikey', help='Jarvice API key')\n auth_group.add_argument('-apiurl', help='Jarvice API URL',\n default='https://api.jarvice.com')\n auth_group.add_argument('-v', help='loglevel',\n choices=['INFO', 'WARN', 'DEBUG', 'CRITICAL'],\n dest='loglevel', default='CRITICAL')\n auth_group.add_argument(\n 'command',\n choices=['connect', 'submit', 'info', 'status',\n 'action', 'terminate', 'shutdown', 'jobs',\n 'output', 'tail', 'apps', 'machines', 'summary',\n 'download', 'upload', 'wait_for', 'shutdown_all',\n 'terminate_all', 'ls'])\n\n known, unknown = parser.parse_known_args()\n return known, unknown, parser","def get_arguments():\n parser = argparse.ArgumentParser(description=\"DeepLab-ResNet Network\")\n parser.add_argument(\"--mode\", choices={\"SUM\", \"VAL\"}, default=\"VAL\", help=\"\")\n parser.add_argument(\"--sdf-path\", type=str, default=SDF_PATH, help=\"\")\n parser.add_argument(\"--summary-file\", type=str, default=SUMMARY_FILE, help=\"\")\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"auth\",\n help=\"authentication string for Infermedica API: \"\n \"APP_ID:APP_KEY or path to file containing it.\")\n parser.add_argument(\"--model\",\n help=\"use non-standard Infermedica model/language, \"\n \"e.g. infermedica-es\")\n args = parser.parse_args()\n return args","def get_cmd_args():\n\n\n\t#Creates the Argument Parser\n\tparser = ArgumentParser(description = \"ID Lab qPCR Analysis v\" + VERSION + \" \" + QUALITY)\n\n\t#Adds the input file argument\n\tparser.add_argument('-f', '--file',\n\t\t\t\tnargs = '+',\n\t\t\t\ttype = FileType('r'),\n\t\t\t\trequired = True)\n\n\t#Adds the output directory\n\tparser.add_argument('-o', '--output',\n\t\t\t\trequired = True)\n\n\t#Adds the model argument, to select between the three models\n\tparser.add_argument('-m', '--mod', '--model',\n\t\t\t\tnargs = '?',\n\t\t\t\tchoices = ['relative', 'absolute', 'stability'],\n\t\t\t\trequired = True)\n\n\t#Adds the control genes argument, taking a list of gene names\n\tparser.add_argument('-cg', '--cgenes', '--controlgenes',\n\t\t\t\tnargs = '+',\n\t\t\t\trequired = True)\n\n\t#Adds the optional control sample argument for the stability model, taking a list of sample names\n\tparser.add_argument('-cs', '--csample', '--controlsamples',\n\t\t\t\tnargs = '*')\n\n\t#Adds optional outlier cutoff\n\tparser.add_argument('-oc', '--ocutoff',\n\t\t\t\ttype = float,\n\t\t\t\tdefault = 0.3)\n\n\t#Adds optional max outliers\n\tparser.add_argument('-om', '--omax',\n\t\t\t\ttype = float,\n\t\t\t\tdefault = 0.5)\n\n\t#Adds optional encoding \n\tparser.add_argument('-e', '--encoding',\n\t\t\t\tdefault = 'ISO-8859-1')\n\n\t#Adds optional header size\n\tparser.add_argument('-hd', '--header',\n\t\t\t\tdefault = 47)\n\n\treturn vars(parser.parse_args())","def get_args():\r\n if len(sys.argv) < 3:\r\n print USAGE\r\n sys.exit(1)\r\n\r\n service_name = sys.argv[1]\r\n port_num = sys.argv[2]\r\n config_dict = _parse_config_args(sys.argv[3:])\r\n\r\n if service_name not in SERVICES:\r\n print \"Unrecognized service '{0}'. Valid choices are: {1}\".format(\r\n service_name, \", \".join(SERVICES.keys()))\r\n sys.exit(1)\r\n\r\n try:\r\n port_num = int(port_num)\r\n if port_num < 0:\r\n raise ValueError\r\n\r\n except ValueError:\r\n print \"Port '{0}' must be a positive integer\".format(port_num)\r\n sys.exit(1)\r\n\r\n return service_name, port_num, config_dict","def get_args():\n parser = argparse.ArgumentParser(description=\"NGINX Log Parser\")\n parser.add_argument(\"log\", type=str, help=\"Log file\")\n parser.add_argument(\"--output\", \"-o\", type=str, default=\"log.csv\",\n help=\"Path to output csv file (default: log.csv)\")\n args = parser.parse_args()\n return args","def parse_command_line():\n parser = argparse.ArgumentParser(prog='scoring')\n parser.add_argument(\"pdb_list\", help=\"list of PDB structures\")\n script_args = parser.parse_args()\n return script_args"],"string":"[\n \"def get_cli_arguments(self):\\n pass\",\n \"def get_command_line_args():\\n \\n parser = argparse.ArgumentParser()\\n parser.add_argument('-s', '--symbol', help='symbol query')\\n\\n # no limit should be input as 'max'\\n parser.add_argument('-l',\\n '--limit',\\n help='limit on number of image results',\\n default='max')\\n parser.add_argument('-d', '--directory', help='image directory')\\n args = parser.parse_args()\\n return args\",\n \"def get_args_from_command_line():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--input_csv_path\\\", type=str)\\n parser.add_argument(\\\"--text_column_order\\\", type=int)\\n args = parser.parse_args()\\n return args\",\n \"def get_args():\\n\\n parser = get_argument_parser()\\n args = parser.parse_args()\\n\\n return args\",\n \"def process_command_line_arguments() -> Namespace:\\n\\n parser = build_parser()\\n arguments = parser.parse_args()\\n\\n return arguments\",\n \"def get_args():\\n if len(sys.argv) == 3:\\n return sys.argv[1:]\\n print(\\\"USAGE: python3 extract_cds.py infile outfile\\\\n\\\\n\\\")\\n exit()\",\n \"def get_args_from_command_line():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--country_code\\\", type=str, default='US')\\n args = parser.parse_args()\\n return args\",\n \"def get_args_from_command_line():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--country_code\\\", type=str,\\n help=\\\"Country code\\\",\\n default=\\\"US\\\")\\n parser.add_argument(\\\"--n_workers\\\", type=int, help=\\\"number of workers\\\",\\n default=20)\\n parser.add_argument(\\\"--survey_link\\\", type=str)\\n parser.add_argument(\\\"--block_size\\\", help='number of tweets per worker', type=int)\\n parser.add_argument(\\\"--version_number\\\", type=str)\\n parser.add_argument(\\\"--mode\\\", type=str, help='Whether to create HIT in sandbox or in production')\\n parser.add_argument(\\\"--language_qualification\\\", type=int, help='')\\n\\n args = parser.parse_args()\\n return args\",\n \"def get_args(args):\\n parser = parse_arguments()\\n return parser.parse_args(args)\",\n \"def _parse_command_line_arguments():\\n parser = ArgumentParser(\\n description=(\\n 'Command-line tool to generate a list of unique from a TS file from FermiFAST'\\n ),\\n )\\n parser.add_argument(\\n 'ts-file',\\n type=str,\\n help=(\\n 'A file containing the TS sky map'\\n ),\\n )\\n parser.add_argument('--skiprows',\\n type=int,\\n help='number of rows to skip at the top (default 0)',\\n required=False)\\n parser.set_defaults(skiprows=0)\\n arguments = vars(parser.parse_args())\\n return arguments\",\n \"def command_line_arguments():\\n\\n try:\\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\\n\\n # Add required arguments.\\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\\n\\n # Parse the arguments\\n args = parser.parse_args()\\n\\n return args\\n\\n except Exception as err:\\n print(err)\\n return\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description='Runner for tasks')\\n parser.add_argument('--db_url', help='Database url string to the db.', required=True)\\n return parser.parse_args()\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Extract a sample of the data.\\\")\\n\\n parser.add_argument(\\\"userid\\\", help=\\\"User ID\\\")\\n parser.add_argument(\\\"start\\\", help=\\\"Start\\\")\\n parser.add_argument(\\\"end\\\", help=\\\"End\\\")\\n parser.add_argument(\\\"source\\\", help=\\\"Source data file\\\")\\n parser.add_argument(\\\"dest\\\", help=\\\"Destination file\\\")\\n\\n return parser.parse_args()\",\n \"def get_command_line_args():\\n\\tparser: ArgumentParser = argparse.ArgumentParser()\\n\\tparser.add_argument('-t', '--t_blank', help=\\\"Number of blanks until delimiter\\\", default=20)\\n\\tparser.add_argument('-k', '--k_copynum', help=\\\"Number of numbers to copy\\\", default=3)\\n\\tparser.add_argument('-m', '--model', help=\\\"Choose model RNN, LSTM or MLP\\\", default='MLP')\\n\\targs = parser.parse_args()\\n\\treturn args\",\n \"def get_args():\\n parser = argparse.ArgumentParser()\\n arg = parser.add_argument\\n\\n arg('--raw_source_dir',\\n default=os.path.expanduser(\\n '~/Personal/Columbia/Applied_DL/Camelyon_Project/data/source_data'))\\n arg('--meta_data_dir',\\n default=os.path.expanduser(\\n '~/Personal/Columbia/Applied_DL/Camelyon_Project/data/test_dir'))\\n arg('--img_data_dir',\\n default=os.path.expanduser(\\n '~/Personal/Columbia/Applied_DL/Camelyon_Project/data/test_dir/input_data'))\\n arg('--output_data_dir',\\n default=os.path.expanduser(\\n '~/Personal/Columbia/Applied_DL/Camelyon_Project/data/test_dir/output_data'))\\n\\n arg('--img_partition_option', default='zoom_1_256_256')\\n\\n input_args = parser.parse_known_args()[0]\\n\\n return input_args\",\n \"def get_args():\\n\\tparser = argparse.ArgumentParser(\\n\\t\\t\\tdescription=\\\"\\\"\\\"Re-sorts multi-locus bootstraps by loci\\\"\\\"\\\")\\n\\tparser.add_argument(\\n\\t\\t\\t\\\"--input\\\",\\n\\t\\t\\trequired=True,\\n\\t\\t\\ttype=is_dir,\\n\\t\\t\\taction=FullPaths,\\n\\t\\t\\thelp=\\\"\\\"\\\"The input directory containing multi-locus bootstraps\\\"\\\"\\\"\\n\\t\\t)\\n\\tparser.add_argument(\\n\\t\\t\\t\\\"--bootstrap_replicates\\\",\\n\\t\\t\\trequired=True,\\n\\t\\t\\ttype=is_file,\\n\\t\\t\\taction=FullPaths,\\n\\t\\t\\thelp=\\\"\\\"\\\"The file containing bootstrap replicate sampling\\\"\\\"\\\"\\n\\t\\t)\\n\\tparser.add_argument(\\n\\t\\t\\t\\\"--output\\\",\\n\\t\\t\\trequired=True,\\n\\t\\t\\taction=CreateDir,\\n\\t\\t\\thelp=\\\"\\\"\\\"The output directory that will contain sorted bootstraps\\\"\\\"\\\"\\n\\t\\t)\\n\\treturn parser.parse_args()\",\n \"def _read_cmd_args():\\n\\n # Check if argument count is correct.\\n if len(sys.argv) != 5:\\n print(\\\"[ERR] Invalid number of command line arguments!\\\")\\n _usage()\\n sys.exit(1)\\n\\n # Get path to config file\\n configfile = sys.argv[1]\\n if not os.path.exists(configfile):\\n print(f\\\"[ERR] Config file {configfile} does not exist!\\\")\\n sys.exit(1)\\n\\n # Get top directory of LIS data\\n topdatadir = sys.argv[2]\\n if not os.path.exists(topdatadir):\\n print(f\\\"[ERR] LIS data directory {topdatadir} does not exist!\\\")\\n sys.exit(1)\\n\\n # Get valid year and month\\n yyyymm = sys.argv[3]\\n if len(yyyymm) != 6:\\n print(\\\"[ERR] Invalid length of YYYYMM, must be 6 characters!\\\")\\n sys.exit(1)\\n year = int(yyyymm[0:4])\\n month = int(yyyymm[4:6])\\n try:\\n startdate = datetime.datetime(year, month, day=1)\\n except ValueError:\\n print(\\\"[ERR] Invalid YYYYMM passed to script!\\\")\\n sys.exit(1)\\n\\n # Get model forcing ID\\n model_forcing = sys.argv[4]\\n\\n return configfile, topdatadir, startdate, model_forcing\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"\\\"\\\"Given an input LASTZ file, output a BED-formatted file of locus coordinates\\\"\\\"\\\"\\n )\\n parser.add_argument(\\n \\\"--alignments\\\",\\n required=True,\\n type=is_dir,\\n action=FullPaths,\\n help=\\\"\\\"\\\"The input directory containing LASTZ files\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--output\\\",\\n required=True,\\n action=CreateDir,\\n help=\\\"\\\"\\\"The output directory to hold BED-formatted files\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--regex\\\",\\n type=str,\\n default=\\\"^(uce-\\\\d+)(?:_p\\\\d+.*)\\\",\\n help=\\\"\\\"\\\"A regular expression to apply to the probe sequences for replacement\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--verbosity\\\",\\n type=str,\\n choices=[\\\"INFO\\\", \\\"WARN\\\", \\\"CRITICAL\\\"],\\n default=\\\"INFO\\\",\\n help=\\\"\\\"\\\"The logging level to use.\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--log-path\\\",\\n action=FullPaths,\\n type=is_dir,\\n default=None,\\n help=\\\"\\\"\\\"The path to a directory to hold logs.\\\"\\\"\\\",\\n )\\n return parser.parse_args()\",\n \"def _get_args():\\n parser = argparse.ArgumentParser(description=__doc__)\\n parser.add_argument('--env', '-e',\\n type=str,\\n default='Zelda1-v0',\\n choices=['Zelda1-v0'],\\n help='The environment to play'\\n )\\n parser.add_argument('--mode', '-m',\\n type=str,\\n default='human',\\n choices=['human', 'random'],\\n help='The execution mode for the environment.'\\n )\\n parser.add_argument('--steps', '-s',\\n type=int,\\n default=500,\\n help='The number of random steps to take.',\\n )\\n return parser.parse_args()\",\n \"def get_args():\\n\\n parser = argparse.ArgumentParser(description=\\\"Get DC, Clusters, Hosts and VM in JSON.\\\")\\n parser.add_argument('-H', '--host', nargs=1, required=True, help='The vCenter to connect to',\\n dest='host', type=str)\\n parser.add_argument('-p', '--password', nargs=1, required=False,\\n help='The password with which to connect to the VC. If not specified, the user is prompted at runtime for a password',\\n dest='password', type=str)\\n parser.add_argument('-u', '--user', nargs=1, required=True, help='The username with which to connect to the host',\\n dest='username', type=str)\\n args = parser.parse_args()\\n return args\",\n \"def parse_arguments(args):\",\n \"def process_command_line_input():\\n\\n input_args = sys.argv\\n if input_args[0].find('ipython') >= 0:\\n input_args = list()\\n else:\\n input_args.pop(0)\\n\\n return input_args\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Obstacle avoidance python script.\\\"\\n )\\n\\n # Required arguments\\n parser.add_argument(\\\"-n\\\", \\\"--number\\\",\\n action=\\\"store\\\",\\n required=False,\\n help=\\\"Add a pheeno number namespace.\\\",\\n default=\\\"\\\")\\n\\n # The rationale behind rospy.myargv()[1:] is provided here:\\n # https://groups.google.com/a/rethinkrobotics.com/forum/#!topic/brr-users/ErXVWhRmtNA\\n return parser.parse_args(rospy.myargv()[1:])\",\n \"def get_args(self):\\n req_argv = self._ptr.contents.argv\\n args = []\\n if bool(req_argv):\\n i = 0\\n while 1:\\n s = bytestostr(req_argv[i])\\n i += 1\\n if s == None:\\n break\\n args.append(s)\\n return args\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description='Download genome')\\n parser.add_argument(\\\"accession\\\", help=\\\"NCBI Accession Number\\\")\\n parser.add_argument(\\\"email\\\", help=\\\"E-mail address\\\")\\n return parser.parse_args()\",\n \"def parse_cmdline():\\n\\tparser = ArgumentParser(prog=\\\"FastP_QC.py\\\", description=\\\"\\\"\\\"Script collects stats from fastp jsons.\\\"\\\"\\\")\\n\\tparser.add_argument(\\\"-r1\\\", \\\"--r1_stats\\\", dest=\\\"r1_stats\\\", action=\\\"store\\\", required=True, help=\\\"Text file with r1 stats, from q30.py script.\\\")\\n\\tparser.add_argument(\\\"-r2\\\", \\\"--r2_stats\\\", dest=\\\"r2_stats\\\", action=\\\"store\\\", required=True, help=\\\"Text file with r2 stats, from q30.py script.\\\")\\n\\tparser.add_argument(\\\"-n\\\", \\\"--name\\\", dest=\\\"name\\\", action=\\\"store\\\", required=True, help=\\\"Sample name\\\")\\n\\targs = parser.parse_args()\\n\\treturn args\",\n \"def get_args():\\n parser = argparse.ArgumentParser(add_help=False)\\n\\n parser.add_argument(\\n '--ckpt_path',\\n type=str,\\n help='ckpt path')\\n\\n parser.add_argument('--gpu', action='store_false', help='gpu/cpu')\\n parser.add_argument(\\n '--img_path',\\n type=str,\\n help='image path')\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\\\")\\n parser.add_argument(\\\"--visualization\\\", \\\"-v\\\", action=\\\"store_true\\\", help=\\\"if generated clouds should be visualized\\\")\\n parser.add_argument(\\\"--directory\\\", \\\"-d\\\",\\n help=\\\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\\\")\\n args = parser.parse_args()\\n return args.visualization, args.directory\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description=\\\"Arguments for data exploration\\\")\\n parser.add_argument(\\\"--tokenize\\\",\\n dest=\\\"tokenize\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Tokenize by words and sentences, counting averages/sd for each.\\\")\\n return parser\",\n \"def get_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--all_info\\\", required=False, action=\\\"store_true\\\", help=\\\"Represents: list of files in a \\\"\\n \\\"current directory; \\\"\\n \\\"core version; \\\"\\n \\\"OS version; \\\"\\n \\\"list of all processes\\\")\\n parser.add_argument(\\\"--proc_info\\\", required=False, help=\\\"Represents list of all processes or info \\\"\\n \\\"about provided process. \\\"\\n \\\"Name of a searching process should be provided.\\\"\\n \\\"'all' is to show all processes\\\")\\n parser.add_argument(\\\"--core_version\\\", required=False, action=\\\"store_true\\\", help=\\\"Represents core version\\\")\\n parser.add_argument(\\\"--os_version\\\", required=False, action=\\\"store_true\\\", help=\\\"Represents OS version\\\")\\n parser.add_argument(\\\"--cur_dir_info\\\", required=False, action=\\\"store_true\\\", help=\\\"Represents list of files in a \\\"\\n \\\"current directory\\\")\\n parser.add_argument(\\\"--dir_info\\\", required=False, nargs='?', help=\\\"Represents list of files in a \\\"\\n \\\"provided directory.\\\")\\n args = parser.parse_args()\\n return args\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description='Simple dmenu launcher for passwords, notes and application shortcuts.')\\n group = parser.add_mutually_exclusive_group()\\n\\n group.add_argument('--pass', dest='passw', action='store_true',\\n help='Copy password from password store.')\\n group.add_argument('--apps', action='store_true',\\n help='Quick launches a desktop application with exo-open.')\\n group.add_argument('--notes', action='store_true',\\n help='Opens a text/markdown note from a given directory with exo-open.')\\n group.add_argument('--search', action='store_true',\\n help='Quick search and launch from a given directory with exo-open.')\\n\\n if not len(sys.argv) > 1:\\n parser.print_help()\\n sys.exit(1)\\n\\n return parser.parse_args()\",\n \"def get_args(argv):\\r\\n parser = argparse.ArgumentParser()\\r\\n parser.add_argument(\\\"design\\\", help=\\\"design file name\\\")\\r\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", action=\\\"store_true\\\",\\r\\n help=\\\"print a verbose report\\\")\\r\\n return parser.parse_args(argv)\",\n \"def cmd_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-i\\\", \\\"--image\\\",\\n help=\\\"Full image path can be optionally supplied.\\\")\\n args = parser.parse_args()\\n return args\",\n \"def get_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-i\\\", \\\"--input\\\",\\n help=\\\"text file, one compound per line\\\", required=True)\\n parser.add_argument(\\\"-j\\\", \\\"--jsononto\\\",\\n help=\\\"json ontology of families\\\", required=True)\\n parser.add_argument(\\\"-o\\\", \\\"--output\\\",\\n help=\\\"output file\\\", required=True)\\n parser.add_argument(\\\"-e\\\", \\\"--encoded\\\",\\n help=\\\"identifiers are encoded\\\", action=\\\"store_true\\\", default=False)\\n\\n args = parser.parse_args()\\n\\n run_analysis(args.input, args.jsononto, args.output, args.encoded)\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n # All reference encoders\\n parser.add_argument(\\\"--step\\\", dest=\\\"step\\\", default=\\\"10\\\", type=int, help=\\\"step size\\\")\\n parser.add_argument(\\\"--repeats\\\", dest=\\\"repeats\\\", type=int, default=1, help=\\\"repeats\\\")\\n\\n parser.add_argument(dest=\\\"image\\\", default=None,\\n help=\\\"select the test image to run\\\")\\n\\n args = parser.parse_args()\\n return args\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description='Standard Arguments for talking to Distributed Index Server')\\n parser.add_argument('-c', '--config',\\n required=True,\\n action='store',\\n help='Config file of the network')\\n parser.add_argument('-i', '--index',\\n type=int,\\n required=True,\\n action='store',\\n help='key range start index')\\n parser.add_argument('-e', '--end',\\n type=int,\\n required=True,\\n action='store',\\n help='key range end index')\\n parser.add_argument('-o', '--operation',\\n type=int,\\n required=True,\\n action='store',\\n help='operation: 1.Register & Search ops 2.Obtain ops')\\n args = parser.parse_args()\\n return args\",\n \"def getargs(ver='%prog 0.0'):\\n parser = argparse.ArgumentParser(\\n description=open(__file__).read().split(\\\"'''\\\")[1],\\n formatter_class=argparse.RawDescriptionHelpFormatter) \\n #@todo: OptionParser is depreciated in Python 3.2. \\n #Need to move to the new style of parser. \\n parser.add_argument(\\\"--fasta_a_name\\\", \\n required=True,\\n help = \\\"REQUIRED: The name of the fasta file a.\\\")\\n parser.add_argument(\\\"--fasta_b_name\\\", \\n required=True,\\n help = \\\"REQUIRED: The name of the fasta file a.\\\")\\n parser.add_argument(\\\"--set_operation\\\", \\n default=\\\"U\\\",\\n help = \\\"The operation you want to do. \\\")\\n \\n args = parser.parse_args()\\n \\n fasta_a_name = args.fasta_a_name\\n fasta_b_name = args.fasta_b_name\\n set_operation = args.set_operation\\n \\n return fasta_a_name,fasta_b_name,set_operation\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Sets up package within the pheeno's directory.\\\"\\n )\\n\\n # Required arguments\\n parser.add_argument(\\\"-x\\\", \\\"--execute\\\", action=\\\"execute\\\", required=True,\\n help=\\\"something\\\", default=False)\\n\\n # Optional arguments\\n parser.add_argument(\\\"-s\\\", \\\"--save\\\", action=\\\"store\\\", required=False,\\n help=\\\"something\\\", default=False)\",\n \"def parse_cmdline(get_parser=get_parser_files):\\n return get_parser().parse_args()\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description=\\\"Processing tweets\\\")\\n\\n parser.add_argument(\\\"-db\\\", \\\"--db\\\", type = str, required = True, \\n help = \\\"The Name of Database to store\\\")\\n\\n args = parser.parse_args()\\n \\n return args\",\n \"def GetArgs():\\n parser = argparse.ArgumentParser(\\n description='Process args for retrieving all the Virtual Machines')\\n parser.add_argument('-s', '--host', required=True, action='store',\\n help='Remote host to connect to')\\n parser.add_argument('-o', '--port', type=int, default=443, action='store',\\n help='Port to connect on')\\n parser.add_argument('-u', '--user', required=True, action='store',\\n help='User name to use when connecting to host')\\n parser.add_argument('-p', '--password', required=False, action='store',\\n help='Password to use when connecting to host')\\n args = parser.parse_args()\\n return args\",\n \"def ReadArguments():\\n\\n args = ParseArguments()\\n\\n logging.info('Command line arguments...')\\n for arg in vars(args):\\n logging.info(str(arg) + ': ' + str(getattr(args, arg)))\\n logging.info('')\\n\\n IsTest(args)\\n ProcessCacheSize(args)\\n ProcessLineSize(args)\\n ProcessMulti(args)\\n ProcessMemPattern(args)\\n ProcessMemFile(args)\",\n \"def get_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"model_type\\\")\\n parser.add_argument(\\\"run_name\\\")\\n parser.add_argument(\\\"run_comment\\\")\\n parser.add_argument(\\\"epoch\\\")\\n parser.add_argument(\\\"--verbose\\\", default=True)\\n args = parser.parse_args()\\n return (args.model_type, args.run_name, args.run_comment, args.epoch, args.verbose)\",\n \"def __get_cli_args():\\r\\n parser = argparse.ArgumentParser()\\r\\n o = parser.add_mutually_exclusive_group()\\r\\n o.add_argument('-a', action='store_true')\\r\\n o.add_argument('-b', action='store_true')\\r\\n parser.add_argument('-suite', help='suite file name for execution')\\r\\n parser.add_argument('-log', help='LOG level for the execution', default='INFO',\\r\\n choices=['INFO', 'DEBUG', 'WARNING', 'ERROR', 'CRITICAL'])\\r\\n args = parser.parse_args()\\r\\n return args\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description='Compare core genomes')\\n parser.add_argument(\\\"directory\\\", help=\\\"Directory of alignments\\\", \\n type=is_dir, action=FullPaths)\\n return parser.parse_args()\",\n \"def get_arguments(args_in):\\n parser = argparse.ArgumentParser(description=\\\"Model Evaluation\\\")\\n\\n add_global_arguments(parser)\\n args = parser.parse_args(args_in)\\n check_global_arguments(args)\\n\\n return args\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser(description='Parses ID\\\\'s from the DDI compendium search results, and then downloads the html and puts them into a sqlite database.')\\n parser.add_argument('-f', '--file', dest='file',\\n action='store',\\n help='Filenname to be read')\\n arg_manager = parser.parse_args()\\n return arg_manager\",\n \"def get_arguments():\\n parser = argparse.ArgumentParser(description=\\\"\\\"\\\"\\n Yield a sorted frequency count of similar/dissimilar InChi DW/OpenBabel.\\n\\\"\\\"\\\")\\n\\n parser.add_argument(\\n \\\"file\\\",\\n help=\\\"DataWarrior's list file exported after running the macro.\\\")\\n args = parser.parse_args()\\n\\n data = args.file\\n return data\",\n \"def parse_command_line_arguments(argv):\\n print(\\\"reading command line arguments in...\\\")\\n\\n parser = argparse.ArgumentParser(description='Description of your program')\\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\\n args = parser.parse_args()\\n\\n return args.input, args.predicting, args.scoring, args.scale\",\n \"def get_args():\\n use = (\\\"%prog is used to run user-specified actions against files. It is \\\"\\n \\\"typically scheduled to run periodically, and uses a config file for \\\"\\n \\\"criteria. \\\\n\\\"\\n \\\" \\\\n\\\"\\n \\\" %prog [file] [misc options]\\\")\\n\\n parser = argparse.ArgumentParser(description=use,\\n formatter_class=argparse.RawTextHelpFormatter)\\n\\n parser.add_argument('--config-name',\\n dest='config_name',\\n default=None,\\n help='Specifies the name of the config file in the standard xdg datagristle config')\\n parser.add_argument('-c', '--config-file',\\n dest='config_file',\\n default=None,\\n help='Specifies the name of the config file in a user-specified directory')\\n parser.add_argument('--log-dir',\\n dest='log_dir',\\n default=None,\\n help='Overrides the xdg-default logging directory. XDG default on linux is $HOME/.cache/datagristle/gristle_process')\\n parser.add_argument('--log-level',\\n dest='log_level',\\n choices=['debug', 'info', 'warning', 'error', 'critical'],\\n help='Specifies level of detail in logs. Default is None - which leaves it to the config file.')\\n\\n parser.add_argument('--testrun',\\n default=False,\\n action='store_true',\\n dest='test_run',\\n help=('Identify files to act upon - but just list them'))\\n\\n parser.add_argument('--long-help',\\n default=False,\\n action='store_true',\\n help='Print more verbose help')\\n\\n args = parser.parse_args()\\n\\n if args.long_help:\\n print(__doc__)\\n sys.exit(0)\\n\\n\\n return args\",\n \"def get_command_line_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n 'docx_path', help=\\\"path to directory containing docx files\\\")\\n parser.add_argument(\\n '-sn', '--save_name', help=\\\"name of the directory containing the marked text files\\\")\\n args = parser.parse_args()\\n\\n return args\",\n \"def get_args():\\n arg_parser = argparse.ArgumentParser(description='run the if')\\n arg_parser.add_argument('story', help='story to run')\\n arg_parser.add_argument('-D', '--debug',\\n action='store_true',\\n help='turn on debugging')\\n\\n args = arg_parser.parse_args()\\n return vars(args)\",\n \"def commandline():\\n command_parser = argparse.ArgumentParser(description=__doc__, epilog=epilog, formatter_class=argparse.RawDescriptionHelpFormatter)\\n command_parser.add_argument('-i','--input_file', type=str, required=True, help='input file.')\\n command_parser.add_argument('-o','--output_file', type=str, required=True, help='output file.')\\n args = command_parser.parse_args()\\n return args\",\n \"def get_argv_list(args):\\n # parse the string format of arguments and return a list of arguments\\n argv = args.split(' ')\\n if len(argv) == 1 and argv[0] == '':\\n return []\\n return argv\",\n \"def _read_cmd_args():\\n\\n # Check if argument count is correct.\\n if len(sys.argv) != 4:\\n print(\\\"[ERR] Invalid number of command line arguments!\\\")\\n print(len(sys.argv))\\n print(sys.argv[:])\\n _usage()\\n sys.exit(1)\\n\\n # Check if lis.config template exists.\\n lis_config_template = sys.argv[1]\\n if not os.path.exists(lis_config_template):\\n print(f\\\"[ERR] {lis_config_template} does not exist!\\\")\\n sys.exit(1)\\n\\n # Check if directory for restart files exists. Actual restart file\\n # shall be checked later.\\n restart_dir = sys.argv[2]\\n if not os.path.exists(restart_dir):\\n print(f\\\"[ERR] Directory {restart_dir} does not exist!\\\")\\n sys.exit(1)\\n\\n # Get start date of new LIS run.\\n yyyymmdd = sys.argv[3]\\n if len(yyyymmdd) != 8:\\n print(\\\"[ERR] Invalid length for YYYYMMDD, must be 8 characters!\\\")\\n sys.exit(1)\\n year = int(yyyymmdd[0:4])\\n month = int(yyyymmdd[4:6])\\n day = int(yyyymmdd[6:8])\\n try:\\n startdate = datetime.date(year, month, day)\\n except ValueError:\\n print(\\\"[ERR] Invalid YYYYMMDD passed to script!\\\")\\n sys.exit(1)\\n\\n return lis_config_template, restart_dir, startdate\",\n \"def command_line_args(parser):\\n AbyssAssembler.command_line_args(parser)\\n SpadesAssembler.command_line_args(parser)\\n TrinityAssembler.command_line_args(parser)\\n VelvetAssembler.command_line_args(parser)\",\n \"def args(self):\\n return self.cmd_args\",\n \"def get_arguments():\\n parser = argparse.ArgumentParser(description=\\\"Argument Parser\\\")\\n parser.add_argument(\\\"--batch-size\\\", type=int, default=BATCH_SIZE,\\n help=\\\"Number of images sent to the network in one step.\\\")\\n print('parsing')\\n return parser.parse_args()\",\n \"def get_args():\\n argparser = argparse.ArgumentParser(description=__doc__)\\n argparser.add_argument(\\n \\\"-c\\\",\\n \\\"--config\\\",\\n metavar=\\\"C\\\",\\n default=\\\"None\\\",\\n help=\\\"The Configuration file\\\",\\n )\\n args = argparser.parse_args()\\n return args\",\n \"def GetArgs():\\n\\tparser = argparse.ArgumentParser(description='Process args for retrieving all the Virtual Machines')\\n\\tparser.add_argument('-s', '--host', required=True, action='store', help='Remote host to connect to')\\n\\tparser.add_argument('-o', '--port', type=int, default=443,\\taction='store', help='Port to connect on')\\n\\tparser.add_argument('-u', '--user', required=True, action='store', help='User name to use when connecting to host')\\n\\tparser.add_argument('-p', '--password', required=True, action='store', help='Password to use when connecting to host')\\n\\tparser.add_argument('-m', '--vm', required=True, action='store', help='On eor more Virtual Machines to report on')\\n\\tparser.add_argument('-i', '--int', type=int, default=15, action='store', help='Interval to average the vSphere stats over')\\n\\targs = parser.parse_args()\\n\\treturn args\",\n \"def readArgs():\\n parser = argparse.ArgumentParser(description=\\n \\\"\\\"\\\"Debug script. This program is used in order to generate a summary\\n statistics for the csv files generated by the annotation_parser. Things\\n like the average amount of overlap of each window and the average deviation.\\n \\\"\\\"\\\")\\n\\n parser.add_argument('-f', '--csv-dir', metavar='',\\n dest='csv_dir',\\n action='store', default=os.path.dirname(os.path.abspath(__file__)),\\n help='Specify the csv directory.')\\n parser.add_argument('-d', '--deviation', metavar='',\\n dest='deviation', action='store',\\n default=50,\\n help='percentage set point from which evaluate the deviation from.')\\n\\n return parser.parse_args()\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description='Some Basic Spark Job doing some stuff on IMDb data stored within HDFS.')\\n return parser.parse_args()\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description='Grab the various stream profile bitrates and resolutions for master m3u8 files')\\n\\n parser.add_argument('-f', '--file',\\n action='store',\\n help='File of URLs to load. This overrides a URL provided on the command-line')\\n\\n parser.add_argument('-o', '--output',\\n action='store',\\n help='Filename to write output to.')\\n\\n parser.add_argument('-a', '--append',\\n action='store_true',\\n default=False,\\n help='Append to the file given with the --output argument as opposed to overwriting the file')\\n\\n parser.add_argument('url',\\n nargs='?', default='NO_URL',\\n action='store',\\n help='The url of the master m3u8 playlist')\\n\\n\\n\\n args = parser.parse_args()\\n if args.url == \\\"NO_URL\\\" and not args.file:\\n print >> sys.stderr, \\\"Error: You must either specify a URL on the command-line or provide a filename via the --file argument\\\\n\\\\n\\\"\\n parser.print_help()\\n exit(1)\\n\\n return args\",\n \"def get_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('color', help='What color would you like for the '\\n 'player?',\\n choices=['blue', 'green', 'magenta'])\\n parser.add_argument('image_folder', help='Folder contains images',\\n type=file_type)\\n parser.add_argument('-f', '--fast', help='Fast or slow game',\\n action='store_true')\\n arguments = parser.parse_args()\\n color = arguments.color\\n image_folder = arguments.image_folder\\n fast = arguments.fast\\n return color, image_folder, fast\",\n \"def args(self):\\n return self._parse_args\",\n \"def get_cmdl_args():\\n parser = argparse.ArgumentParser(description=\\\"Arguments needed to run \\\"\\n \\\"python scripts eg. \\\"\\n \\\"cluster_vip,\\\"\\n \\\"UserName & Password\\\")\\n parser.add_argument(\\\"-i\\\", \\\"--cluster_vip\\\", help=\\\"Cluster VIP to login\\\")\\n parser.add_argument(\\\"-u\\\", \\\"--user\\\", help=\\\"Username to login\\\")\\n parser.add_argument(\\\"-p\\\", \\\"--password\\\", help=\\\"password to login\\\")\\n args = parser.parse_args()\\n return args\",\n \"def getArguments():\\n dfPath = sys.argv[1]\\n if(len(sys.argv) == 4):\\n pop = int(sys.argv[2])\\n gen = int(sys.argv[3])\\n else:\\n pop = 10\\n gen = 2\\n return dfPath, pop, gen\",\n \"def _argsForSubprocess(self) -> list[str]:\\n pass\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description=__doc__)\\n\\n parser.add_argument('--batch_size', type=int, default=64,\\n help='The batch size to load the data. (default: 64)')\\n parser.add_argument('--num_workers', type=int, default=4,\\n help=('The number of worker processes to use in '\\n 'loading the dataset. (default: 4)'))\\n parser.add_argument('--num_epochs', type=int, default=30,\\n help=('The number of training epochs to run. (default:'\\n '30)'))\\n parser.add_argument('--learning_rate', type=float, default=0.1,\\n help='The learning rate for SGD. (default: 0.1)')\\n parser.add_argument('--momentum', type=float, default=0.9,\\n help='The momentum for SGD. (default: 0.9)')\\n parser.add_argument('--checkpoint',\\n help='The path of the checkpoint file to load')\\n parser.add_argument('--cuda', default=False, action='store_true',\\n help='Use GPU if available.')\\n\\n args = parser.parse_args(sys.argv[1:])\\n\\n return args\",\n \"def getargs():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"path\\\", type=chkpath, nargs=\\\"?\\\", default=\\\".\\\", help=\\\"a valid path\\\"\\n )\\n parser.add_argument(\\n \\\"-v\\\", \\\"--verbosity\\\", action=\\\"count\\\", default=0, help=\\\"increase output verbosity\\\"\\n )\\n return parser.parse_args()\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description=__doc__.strip())\\n parser.add_argument(\\\"sparkylist\\\", type=str,\\n help=\\\"sparky file to be converted\\\")\\n parser.add_argument(\\\"output\\\", type=str, help=\\\"name of output csv file\\\")\\n parser.add_argument(\\\"--hch\\\", action=\\\"store_true\\\",\\n help=\\\"hch instead of cch\\\")\\n return parser.parse_args()\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description='\\\"Some Input argu for Generate Fragsize Distribution.')\\n parser.add_argument('-i', '--input', required=True, action='store',\\n help=\\\"Input File of .molucule.table\\\")\\n parser.add_argument('-o', '--output', required=True, action='store',\\n help=\\\"Output File of .fragsize_distribution.txt\\\")\\n \\n return parser.parse_args()\",\n \"def get_args():\\n parser = argparse.ArgumentParser('Find a featureclass, database, mxd, or service in ArcGIS Server',\\n epilog='For search strings inlcuding spaces, enclose the query in double-quotes')\\n parser.add_argument('name', help='string for which to search (blank returns info on all services)',\\n nargs='?', default='')\\n parser.add_argument('-q', '--quiet', help='only display service names and URLs', action='store_true')\\n parser.add_argument('-qq', '--veryquiet', help='only display service URLs, comma delimited', action='store_true')\\n parser.add_argument('-cs', '--configstore', help='explicitly provide full path to config store', action='store')\\n parser.add_argument('-csv', '--tocsv', help='create csv output', action='store_true')\\n parser.add_argument('-md', '--markdown', help='create Markdown output', action='store_true')\\n return parser.parse_args()\",\n \"def getPositionalArgs():\",\n \"def get_args( self, ):\\r\\n for iarg in sys.argv[1:]:\\r\\n #print iarg\\r\\n argsplits = iarg.split(\\\"=\\\")\\r\\n parm_name = argsplits[0]\\r\\n parm_value = argsplits[1]\\r\\n\\r\\n # so far only one is captured\\r\\n if parm_name == \\\"parameters\\\":\\r\\n self.parmeters_x = parm_value #\\r\\n msg = \\\"command line arg >>{iarg}\\\" # log file not open but use alt\\r\\n AppGlobal.logger.info( msg )\\r\\n else:\\r\\n msg = \\\"no parmeter extensions\\\"\\r\\n AppGlobal.logger.info( msg )\\r\\n return\",\n \"def parse_cmdline_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-v', '--verbose',\\n action=\\\"store_true\\\",\\n help=\\\"Be chatty\\\")\\n parser.add_argument('-d', '--dryrun',\\n action=\\\"store_true\\\",\\n help=\\\"Do not send emails\\\")\\n foreman_config = ForemanConfig()\\n foreman_config.add_standard_args(parser)\\n parser.add_argument('-e', '--environments', type=str,\\n default=DEFAULT_ENVIRONMENTS_PATH,\\n help=\\\"Clone of it-puppet-environments\\\")\\n args = parser.parse_args()\\n return args\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description='Utterance level classification Leave one '\\n 'speaker out schema pipeline' )\\n parser.add_argument('-i', '--input_features_paths', nargs='+',\\n help='File paths of the features you want to '\\n 'concatenate and the classify')\\n args = parser.parse_args()\\n return args\",\n \"def input_args():\\n return filter(lambda x: len(x) > 0,\\n map(lambda x: x.strip(), sys.argv[1:]))\",\n \"def get_arguments():\\n # Parsing arguments\\n parser = argparse.ArgumentParser(description=__doc__, usage=\\n \\\"{0} -h (see also \\\"\\n \\\"ftp://ftp.ncbi.nih.gov/pub/taxonomy/)\\\"\\n .format(sys.argv[0]))\\n parser.add_argument('-i', dest='blast_output_file', type=isfile,\\n required=True, help=\\\"blast_output_file\\\")\\n parser.add_argument('-d', dest='taxadb_file', type=isfile,\\n required=True, help=\\\"Taxadb file\\\")\\n parser.add_argument('-o', dest='taxonomy_file', type=str, required=True,\\n help=\\\"Output taxonomy_file\\\")\\n return parser.parse_args()\",\n \"def parse_arguments():\\n # shift away script name\\n scriptname=sys.argv[0]\\n shift()\\n ncl_cmd=list()\\n quali_cmd=list()\\n id_cmd=list() \\n while(len(sys.argv)>0):\\n carg = sys.argv[0]\\n shift()\\n if(carg == \\\"--nucleotide\\\"):\\n ncl_cmd = mungeArgs(sys.argv)\\n elif(carg == \\\"--quality\\\"):\\n quali_cmd = mungeArgs(sys.argv)\\n elif(carg == \\\"--id\\\" ):\\n id_cmd = mungeArgs(sys.argv)\\n elif(carg in [\\\"-h\\\", \\\"--help\\\"]):\\n usage()\\n else:\\n usage(error=True)\\n # Excess arguments which are not processed \\n if(len(sys.argv) > 0):\\n sys.stdout.write(\\\"Excess arguments!\\\\n\\\")\\n sys.stdout.flush()\\n usage(error=True)\\n\\n # external modules rely on non-empty argv array, \\n # re-append the script name as first command line argument\\n sys.argv.append(scriptname)\\n return (id_cmd, ncl_cmd, quali_cmd)\",\n \"def get_arguments_from_cmd():\\n\\n parser = argparse.ArgumentParser(description=\\\"\\\\\\n Script for getting the depth of a specific node in a directed \\\\\\n acyclic graph given it root node. \\\\n\\\")\\n\\n parser.add_argument(\\\"-i\\\", type=str, required=True,\\n help=\\\"Path to the CSV or tab delimited file \\\\\\n of graph Adjacency matrix of graph\\\")\\n parser.add_argument(\\\"-r\\\", type=int, required=True,\\n help=\\\"Root node of the graph\\\")\\n parser.add_argument(\\\"-n\\\", type=int, required=True,\\n help=\\\"Node of interest, \\\"\\n \\\"for which we want to know its depth\\\")\\n\\n return parser.parse_args()\",\n \"def get_arguments(args=None):\\n parser = ArgumentParser(prog='rmsd',\\n usage='%(prog)s xyzfile1 xyzfil2 [options] ',\\n description='''Compute rmsd between 2 xyzfiles''',\\n formatter_class=ArgumentDefaultsHelpFormatter\\n )\\n parser.add_argument('xyzfile1', help='xyzfile1')\\n parser.add_argument('xyzfile2', help='xyzfile2')\\n opts = parser.parse_args(args)\\n return opts\",\n \"def get_arguments_from_user() -> list:\\n\\n print(\\\"Für weitere Konfiguration bitte das Programm direkt über eine Konsole starten.\\\\nMit -h können alle Argumente aufgelistet werden\\\\n\\\")\\n code = input(\\\"Impf-Code: \\\")\\n plz = input(\\\"PLZ: \\\")\\n bundesland = input(\\\"Bundesland des Zentrums (zB Baden-Württemberg): \\\")\\n\\n arguments = [\\\"-c\\\", code, \\\"-p\\\", plz, \\\"-b\\\", bundesland]\\n return arguments\",\n \"def getArguments():\\n parser = argparse.ArgumentParser()\\n\\n # Required arguments\\n parser.add_argument('dataset', help='\\\\\\n The directory with the dataset (should have Images/, Annotations/).')\\n \\n # Optional arguments\\n parser.add_argument('--list', default=\\\"all\\\", help='\\\\\\n The list of images (ImageSets/{all ; trainval ; test ; ... }.txt).')\\n \\n return parser.parse_args()\",\n \"def parse_arguments():\\n arguments_parser = argparse.ArgumentParser()\\n add_optional_arguments(arguments_parser)\\n add_positional_arguments(arguments_parser)\\n arguments = arguments_parser.parse_args()\\n return [arguments.paths, _get_options(arguments)]\",\n \"def read_command_line_arguments() -> Tuple[\\n LocalConfig, AuthConfig, Optional[List[str]]\\n]:\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"config\\\", type=str, help=\\\"Path to the main config file\\\"\\n )\\n parser.add_argument(\\n \\\"auth\\\", type=str, help=\\\"Path to the authentication config file\\\"\\n )\\n parser.add_argument(\\n \\\"--execute-now\\\",\\n type=str,\\n help=\\\"\\\"\\\"A set of channel names to execute immediately, or none to\\n determine automatically based on the current time.\\\"\\\"\\\",\\n nargs=\\\"*\\\",\\n choices=notification_channels.keys(),\\n )\\n args = parser.parse_args()\\n\\n config_file = read_local_config(args.config)\\n auth_file = read_local_auth(args.auth)\\n\\n return config_file, auth_file, args.execute_now\",\n \"def get_command_line_arguments():\\n parser = argparse.ArgumentParser(description='Training script for Lux RL agent.')\\n parser.add_argument('--id', help='Identifier of this run', type=str, default=str(random.randint(0, 10000)))\\n parser.add_argument('--learning_rate', help='Learning rate', type=float, default=0.001)\\n parser.add_argument('--gamma', help='Gamma', type=float, default=0.995)\\n parser.add_argument('--gae_lambda', help='GAE Lambda', type=float, default=0.95)\\n parser.add_argument('--batch_size', help='batch_size', type=int, default=2048) # 64\\n parser.add_argument('--step_count', help='Total number of steps to train', type=int, default=10000000)\\n parser.add_argument('--n_steps', help='Number of experiences to gather before each learning period', type=int, default=2048*8)\\n parser.add_argument('--path', help='Path to a checkpoint to load to resume training', type=str, default=None)\\n args = parser.parse_args()\\n\\n return args\",\n \"def command_line_parse(iargs=None):\\n\\n parser = create_parser()\\n inps = parser.parse_args(args=iargs)\\n\\n return inps\",\n \"def _get_args(self):\\n parser = ArgumentParser(\\n description=\\\"Dynamically generates Snakefiles for data \\\"\\n \\\"integration and machine learning pipelines.\\\"\\n )\\n\\n parser.add_argument(\\n \\\"-c\\\",\\n \\\"--config\\\",\\n help=(\\n \\\"Configuration filepath. (Will look for file named config.yml \\\"\\n \\\"in current working directory, if none specified.)\\\"\\n ),\\n )\\n\\n parser.add_argument(\\n \\\"-r\\\",\\n \\\"--run\\\",\\n default=False,\\n help=(\\n \\\"Runs pipeline, in addition to generating Snakefile.\\\"\\n ),\\n )\\n\\n # convert command-line args to a dict and return\\n args = parser.parse_args()\\n\\n args = dict(\\n (k, v) for k, v in list(vars(args).items()) if v is not None\\n )\\n\\n return args\",\n \"def getargs():\\r\\n parser = argparse.ArgumentParser(description='fetch all failed unit tests')\\r\\n parser.add_argument('dir_name', help='directory to check the junit results')\\r\\n parser.add_argument('url', help='bitbucket/stash url')\\r\\n args = parser.parse_args()\\r\\n return args\",\n \"def get_args():\\n\\n parser = argparse.ArgumentParser(\\n description=\\\"Script tests the HCSR04 sensor under different configurations\\\"\\n )\\n\\n parser.add_argument(\\n \\\"-t\\\",\\n \\\"--trig\\\",\\n type=int,\\n help=\\\"Trig Pin (Required - must be an integer, must \\\\\\n use BCM pin values)\\\",\\n required=True,\\n )\\n\\n parser.add_argument(\\n \\\"-e\\\",\\n \\\"--echo\\\",\\n type=int,\\n help=\\\"Echo Pin (Required - must be an integer, must \\\\\\n use BCM pin values)\\\",\\n required=True,\\n )\\n\\n parser.add_argument(\\n \\\"-sp\\\",\\n \\\"--speed\\\",\\n type=float,\\n help=\\\"Time between individual reading samples \\\\\\n (Optional - must be a float, default\\\\\\n is 0.1 seconds)\\\",\\n required=False,\\n default=0.1,\\n )\\n\\n parser.add_argument(\\n \\\"-ss\\\",\\n \\\"--samples\\\",\\n type=int,\\n help=\\\"Reading Sample Size (Optional - must be an \\\\\\n integer, default is 11)\\\",\\n required=False,\\n default=11,\\n )\\n\\n args = parser.parse_args()\\n\\n trig = args.trig\\n echo = args.echo\\n speed = args.speed\\n samples = args.samples\\n\\n return trig, echo, speed, samples\",\n \"def get_args():\\n # parse command line args\\n parser = argparse.ArgumentParser(\\n description=HEADER,\\n formatter_class=argparse.RawDescriptionHelpFormatter)\\n parser.add_argument(\\n '-c',\\n '--config-file',\\n default=os.path.join(os.path.dirname(__file__), 'config-user.yml'),\\n help='Configuration file')\\n parser.add_argument(\\n '-r',\\n '--recipe-files',\\n type=str,\\n nargs='+',\\n help='Recipe files (list or single file)')\\n parser.add_argument(\\n '-d',\\n '--main-dir',\\n default=os.path.join(os.environ['HOME'], 'ESMVALTOOL_ROSE'),\\n help='Main analysis directory; default to $HOME/ESMVALTOOL_ROSE')\\n parser.add_argument(\\n '-s',\\n '--suite-dir',\\n default=os.path.join(os.environ['HOME'], 'u-bd684'),\\n help='u-bd684 suite directory; default to $HOME/u-bd684')\\n parser.add_argument(\\n '-n',\\n '--no-submit',\\n action='store_true',\\n help=\\\"Flag to NOT submit the Rose suite.\\\")\\n parser.add_argument(\\n '-l',\\n '--log-level',\\n default='info',\\n choices=['debug', 'info', 'warning', 'error'])\\n args = parser.parse_args()\\n return args\",\n \"def parse_command_line_arguments():\\n parser = argparse.ArgumentParser(\\n description=\\\"Convert dependency files into list of GitHub links.\\\",\\n epilog=\\\"For help with this program, contact John Speed at jmeyers@iqt.org.\\\",\\n )\\n parser.add_argument(\\n \\\"--python\\\",\\n default=False, # default value is False\\n help=\\\"Convert requirements.txt file into GitHub links.\\\",\\n )\\n return parser.parse_args()\",\n \"def parse_arguments(self,parser):\\r\\n return parser.parse_args()\",\n \"def get_arguments():\\n parser = argparse.ArgumentParser(description=\\\"Simple Jarvice CLI\\\",\\n add_help=False)\\n auth_group = parser.add_argument_group('auth', description='Configuration')\\n auth_group.add_argument('-username', help='Jarvice username')\\n auth_group.add_argument('-apikey', help='Jarvice API key')\\n auth_group.add_argument('-apiurl', help='Jarvice API URL',\\n default='https://api.jarvice.com')\\n auth_group.add_argument('-v', help='loglevel',\\n choices=['INFO', 'WARN', 'DEBUG', 'CRITICAL'],\\n dest='loglevel', default='CRITICAL')\\n auth_group.add_argument(\\n 'command',\\n choices=['connect', 'submit', 'info', 'status',\\n 'action', 'terminate', 'shutdown', 'jobs',\\n 'output', 'tail', 'apps', 'machines', 'summary',\\n 'download', 'upload', 'wait_for', 'shutdown_all',\\n 'terminate_all', 'ls'])\\n\\n known, unknown = parser.parse_known_args()\\n return known, unknown, parser\",\n \"def get_arguments():\\n parser = argparse.ArgumentParser(description=\\\"DeepLab-ResNet Network\\\")\\n parser.add_argument(\\\"--mode\\\", choices={\\\"SUM\\\", \\\"VAL\\\"}, default=\\\"VAL\\\", help=\\\"\\\")\\n parser.add_argument(\\\"--sdf-path\\\", type=str, default=SDF_PATH, help=\\\"\\\")\\n parser.add_argument(\\\"--summary-file\\\", type=str, default=SUMMARY_FILE, help=\\\"\\\")\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"auth\\\",\\n help=\\\"authentication string for Infermedica API: \\\"\\n \\\"APP_ID:APP_KEY or path to file containing it.\\\")\\n parser.add_argument(\\\"--model\\\",\\n help=\\\"use non-standard Infermedica model/language, \\\"\\n \\\"e.g. infermedica-es\\\")\\n args = parser.parse_args()\\n return args\",\n \"def get_cmd_args():\\n\\n\\n\\t#Creates the Argument Parser\\n\\tparser = ArgumentParser(description = \\\"ID Lab qPCR Analysis v\\\" + VERSION + \\\" \\\" + QUALITY)\\n\\n\\t#Adds the input file argument\\n\\tparser.add_argument('-f', '--file',\\n\\t\\t\\t\\tnargs = '+',\\n\\t\\t\\t\\ttype = FileType('r'),\\n\\t\\t\\t\\trequired = True)\\n\\n\\t#Adds the output directory\\n\\tparser.add_argument('-o', '--output',\\n\\t\\t\\t\\trequired = True)\\n\\n\\t#Adds the model argument, to select between the three models\\n\\tparser.add_argument('-m', '--mod', '--model',\\n\\t\\t\\t\\tnargs = '?',\\n\\t\\t\\t\\tchoices = ['relative', 'absolute', 'stability'],\\n\\t\\t\\t\\trequired = True)\\n\\n\\t#Adds the control genes argument, taking a list of gene names\\n\\tparser.add_argument('-cg', '--cgenes', '--controlgenes',\\n\\t\\t\\t\\tnargs = '+',\\n\\t\\t\\t\\trequired = True)\\n\\n\\t#Adds the optional control sample argument for the stability model, taking a list of sample names\\n\\tparser.add_argument('-cs', '--csample', '--controlsamples',\\n\\t\\t\\t\\tnargs = '*')\\n\\n\\t#Adds optional outlier cutoff\\n\\tparser.add_argument('-oc', '--ocutoff',\\n\\t\\t\\t\\ttype = float,\\n\\t\\t\\t\\tdefault = 0.3)\\n\\n\\t#Adds optional max outliers\\n\\tparser.add_argument('-om', '--omax',\\n\\t\\t\\t\\ttype = float,\\n\\t\\t\\t\\tdefault = 0.5)\\n\\n\\t#Adds optional encoding \\n\\tparser.add_argument('-e', '--encoding',\\n\\t\\t\\t\\tdefault = 'ISO-8859-1')\\n\\n\\t#Adds optional header size\\n\\tparser.add_argument('-hd', '--header',\\n\\t\\t\\t\\tdefault = 47)\\n\\n\\treturn vars(parser.parse_args())\",\n \"def get_args():\\r\\n if len(sys.argv) < 3:\\r\\n print USAGE\\r\\n sys.exit(1)\\r\\n\\r\\n service_name = sys.argv[1]\\r\\n port_num = sys.argv[2]\\r\\n config_dict = _parse_config_args(sys.argv[3:])\\r\\n\\r\\n if service_name not in SERVICES:\\r\\n print \\\"Unrecognized service '{0}'. Valid choices are: {1}\\\".format(\\r\\n service_name, \\\", \\\".join(SERVICES.keys()))\\r\\n sys.exit(1)\\r\\n\\r\\n try:\\r\\n port_num = int(port_num)\\r\\n if port_num < 0:\\r\\n raise ValueError\\r\\n\\r\\n except ValueError:\\r\\n print \\\"Port '{0}' must be a positive integer\\\".format(port_num)\\r\\n sys.exit(1)\\r\\n\\r\\n return service_name, port_num, config_dict\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description=\\\"NGINX Log Parser\\\")\\n parser.add_argument(\\\"log\\\", type=str, help=\\\"Log file\\\")\\n parser.add_argument(\\\"--output\\\", \\\"-o\\\", type=str, default=\\\"log.csv\\\",\\n help=\\\"Path to output csv file (default: log.csv)\\\")\\n args = parser.parse_args()\\n return args\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser(prog='scoring')\\n parser.add_argument(\\\"pdb_list\\\", help=\\\"list of PDB structures\\\")\\n script_args = parser.parse_args()\\n return script_args\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77721745","0.76546174","0.7628115","0.75778574","0.75472254","0.7456921","0.74439055","0.7440344","0.74382585","0.7389421","0.7364026","0.73364145","0.73019594","0.7261001","0.72259796","0.722258","0.71752733","0.7173149","0.7171823","0.71440315","0.71353924","0.71323377","0.7123979","0.71085274","0.71054393","0.71053886","0.7097643","0.7085653","0.708279","0.70799494","0.70770085","0.7051927","0.70505786","0.70416015","0.70303714","0.7030135","0.7001182","0.6997773","0.6997732","0.6987876","0.698162","0.6975362","0.6974991","0.6973788","0.69608766","0.69598365","0.6945265","0.6940093","0.6939215","0.6939079","0.69341356","0.6932113","0.6931646","0.69244385","0.6913973","0.69138485","0.6904243","0.6897759","0.68959683","0.68912226","0.6885276","0.6881347","0.6881274","0.6880959","0.6879582","0.6878349","0.6864254","0.68601674","0.6859833","0.6858854","0.68587285","0.685651","0.6854422","0.68513405","0.68477035","0.68471897","0.6840727","0.6840553","0.68300503","0.68241686","0.6823307","0.68212086","0.68197656","0.681927","0.68177223","0.6813528","0.6813141","0.68058777","0.6804912","0.6801733","0.6798842","0.6797431","0.6795881","0.67954725","0.6795348","0.679523","0.67945755","0.6772794","0.67721105","0.6762428","0.67612755"],"string":"[\n \"0.77721745\",\n \"0.76546174\",\n \"0.7628115\",\n \"0.75778574\",\n \"0.75472254\",\n \"0.7456921\",\n \"0.74439055\",\n \"0.7440344\",\n \"0.74382585\",\n \"0.7389421\",\n \"0.7364026\",\n \"0.73364145\",\n \"0.73019594\",\n \"0.7261001\",\n \"0.72259796\",\n \"0.722258\",\n \"0.71752733\",\n \"0.7173149\",\n \"0.7171823\",\n \"0.71440315\",\n \"0.71353924\",\n \"0.71323377\",\n \"0.7123979\",\n \"0.71085274\",\n \"0.71054393\",\n \"0.71053886\",\n \"0.7097643\",\n \"0.7085653\",\n \"0.708279\",\n \"0.70799494\",\n \"0.70770085\",\n \"0.7051927\",\n \"0.70505786\",\n \"0.70416015\",\n \"0.70303714\",\n \"0.7030135\",\n \"0.7001182\",\n \"0.6997773\",\n \"0.6997732\",\n \"0.6987876\",\n \"0.698162\",\n \"0.6975362\",\n \"0.6974991\",\n \"0.6973788\",\n \"0.69608766\",\n \"0.69598365\",\n \"0.6945265\",\n \"0.6940093\",\n \"0.6939215\",\n \"0.6939079\",\n \"0.69341356\",\n \"0.6932113\",\n \"0.6931646\",\n \"0.69244385\",\n \"0.6913973\",\n \"0.69138485\",\n \"0.6904243\",\n \"0.6897759\",\n \"0.68959683\",\n \"0.68912226\",\n \"0.6885276\",\n \"0.6881347\",\n \"0.6881274\",\n \"0.6880959\",\n \"0.6879582\",\n \"0.6878349\",\n \"0.6864254\",\n \"0.68601674\",\n \"0.6859833\",\n \"0.6858854\",\n \"0.68587285\",\n \"0.685651\",\n \"0.6854422\",\n \"0.68513405\",\n \"0.68477035\",\n \"0.68471897\",\n \"0.6840727\",\n \"0.6840553\",\n \"0.68300503\",\n \"0.68241686\",\n \"0.6823307\",\n \"0.68212086\",\n \"0.68197656\",\n \"0.681927\",\n \"0.68177223\",\n \"0.6813528\",\n \"0.6813141\",\n \"0.68058777\",\n \"0.6804912\",\n \"0.6801733\",\n \"0.6798842\",\n \"0.6797431\",\n \"0.6795881\",\n \"0.67954725\",\n \"0.6795348\",\n \"0.679523\",\n \"0.67945755\",\n \"0.6772794\",\n \"0.67721105\",\n \"0.6762428\",\n \"0.67612755\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":10498,"cells":{"query":{"kind":"string","value":"Calculate pairwise correlation between features. Extra arguments are passed on to DataFrame.corr()"},"document":{"kind":"string","value":"def correlations(data,data_type, **kwds):\n # simply call df.corr() to get a table of\n # correlation values if you do not need\n # the fancy plotting\n corrmat = data.corr(**kwds)\n\n fig, ax1 = plt.subplots(ncols=1, figsize=(6,5))\n \n opts = {'cmap': plt.get_cmap(\"RdBu\"),\n 'vmin': -1, 'vmax': +1}\n heatmap1 = ax1.pcolor(corrmat, **opts)\n plt.colorbar(heatmap1, ax=ax1)\n\n ax1.set_title(\"Correlations \"+data_type)\n\n labels = corrmat.columns.values\n for ax in (ax1,):\n # shift location of ticks to center of the bins\n ax.set_xticks(np.arange(len(labels))+0.5, minor=False)\n ax.set_yticks(np.arange(len(labels))+0.5, minor=False)\n ax.set_xticklabels(labels, minor=False, ha='right', rotation=70)\n ax.set_yticklabels(labels, minor=False)\n \n plt.tight_layout()\n plt.savefig(\"Correlations_\"+data_type+\".pdf\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def pairwise_corr(df1, df2):\n res = []\n for i in range(df2.shape[1]):\n res.append(df1.corrwith(df2.ix[:, i]))\n res = pd.concat(res, axis=1)\n res.columns = df2.columns\n return res","def calculate_feature_corr(self):\n \n return self.train_data.astype(float).corr(method='kendall')","def crosscorr(datax, datay, lag=0):\n return datax.corr(datay.shift(lag))","def df_corrwith(df, other, axis=0, drop=False, method=\"pearson\"):\n axis = validate_axis(axis, df)\n if drop:\n # TODO implement with df.align(method='inner')\n raise NotImplementedError(\"drop=True not implemented\")\n op = DataFrameCorr(other=other, method=method, axis=axis, drop=drop)\n return op(df)","def df_corr(df, method=\"pearson\", min_periods=1):\n op = DataFrameCorr(method=method, min_periods=min_periods)\n return op(df)","def crosscorr(datax, datay, lag=0):\n return datax.corr(datay.shift(lag))","def crosscorrelation(x, y, nlags = 0):\n return [x.corr(y.shift(lag)) for lag in range(nlags + 1)]","def corr(self, **kwargs): # noqa: PR02\n return DataFrameDefault.register(pandas.DataFrame.corr)(self, **kwargs)","def pair_corr(X,\n weights=None,\n concat=False,\n exclude_empty=False,\n subtract_mean=False,\n laplace_count=False):\n\n assert frozenset(np.unique(X))<=frozenset([-1,0,1])\n S, N = X.shape\n \n if exclude_empty and not laplace_count:\n # count all nonzero entries for every pair\n weights = 1/(X!=0).sum(0), 1./( (X!=0).astype(int).T.dot(X!=0)[np.triu_indices(X.shape[1],k=1)] )\n elif exclude_empty and laplace_count:\n weights = ( 1/((X!=0).sum(0)+2),\n 1./( (X!=0).astype(int).T.dot(X!=0)[np.triu_indices(X.shape[1],k=1)] + 4 ) )\n elif weights is None:\n # for taking simple average\n weights = np.ones(len(X))/len(X)\n elif type(weights) is tuple:\n assert len(weights[0])==X.shape[1]\n assert len(weights[1])==(X.shape[1]*(X.shape[1]-1)//2)\n elif type(weights) is np.ndarray:\n assert len(weights)==len(X)\n else:\n weights = np.zeros(len(X))+weights\n \n # Calculate pairwise correlations depending on whether or not exclude_empty was set or not.\n if type(weights) is tuple:\n si = X.sum(0) * weights[0]\n sisj = (X.T.dot(X))[np.triu_indices(X.shape[1],k=1)] * weights[1]\n else:\n si = (X*weights[:,None]).sum(0)\n sisj = (X.T.dot(X*weights[:,None]))[np.triu_indices(X.shape[1],k=1)]\n\n if subtract_mean:\n sisj = np.array([sisj[i]-si[ix[0]]*si[ix[1]] for i,ix in enumerate(combinations(list(range(N)),2))])\n \n if concat:\n return np.concatenate((si,sisj))\n return si, sisj","def get_correlation(df):\n frame_correlation = df.corr()\n return frame_correlation","def calculate_correlation(df, vars_to_corr, target_var) :\n\n\n mean = df[target_var].mean()\n sigma = df[target_var].std()\n\n correlation = []\n error = []\n\n for j in vars_to_corr :\n mean_j = df[j].mean()\n sigma_j = df[j].std()\n\n cov = (df[j] - mean_j) * (df[target_var] - mean) / (sigma*sigma_j)\n correlation.append(cov.mean())\n error.append(sem(cov))\n\n return correlation, error","def calculate_correlation(data):\n pass","def correlation(data, method, caption):\n columns = list(data)\n coefficients = data.astype(float).corr(method=method)\n results = []\n for i in range(len(columns)):\n for j in range(i + 1, len(columns)):\n coefficient = coefficients[columns[i]][columns[j]]\n results.append((\n abs(coefficient), coefficient,\n columns[i] + ' x ' + columns[j]))\n print('# ' + caption + ', ' + method)\n for result in reversed(sorted(results)):\n abs_coefficient, coefficient, columns_pair = result\n print (coefficient, columns_pair)","def Corr(x,y):\n \n cocoeff1 = np.empty((y.shape[1],y.shape[2]))\n cocoeff2 = np.empty((y.shape[1],y.shape[2]))\n for i in xrange(y.shape[1]):\n for j in xrange(y.shape[2]):\n cocoeff1[i,j],cocoeff2[i,j] = sts.pearsonr(x[:,i,j],y[:,i,j])\n \n print 'Completed: Correlation calculations!'\n \n return cocoeff1, cocoeff2","def cor(x, y):\n scaler = TimeSeriesScalerMeanVariance()\n x_norm = scaler.fit_transform(x)\n y_norm = scaler.fit_transform(y)\n pcc = np.mean(x_norm * y_norm) # Pearson correlation coefficients\n d = np.sqrt(2.0 * (1.0 - pcc + 1e-9)) # correlation-based similarities\n return np.sum(d)","def correlation_test(x1, x2):\r\n x = pd.DataFrame([x1, x2]).T.dropna().values\r\n return pearsonr(x[:, 0], x[:, 1])","def correlation(data):\n return corrcoef(np.transpose(np.reshape(data, ((data.shape[0] * data.shape[1]), data.shape[2]))))","def series_corr(series, other, method=\"pearson\", min_periods=None):\n op = DataFrameCorr(other=other, method=method, min_periods=min_periods)\n return op(series)","def corrwith(self, **kwargs): # noqa: PR01\n return DataFrameDefault.register(pandas.DataFrame.corrwith)(self, **kwargs)","def calculate_correlation(self):\n self.network.index_nodes()\n self._calculate_dist()\n pearson_correlation, pearson_pvalue = scipy.stats.pearsonr(self.dist[:,0], self.dist[:,1])\n spearman_correlation, spearman_pvalue = scipy.stats.spearmanr(self.dist[:,0], self.dist[:,1])\n return pearson_correlation, pearson_pvalue, spearman_correlation, spearman_pvalue","def correlation_and_distribution(pairs: pd.DataFrame, features: list, target: list):\r\n # Correlation between all features and predicted binary target\r\n ax = sns.heatmap(pairs[features + target].corr(),\r\n center=0, annot=True, cmap='RdBu_r')\r\n l, r = ax.get_ylim()\r\n ax.set_ylim(l + 0.5, r - 0.5)\r\n plt.yticks(rotation=0)\r\n plt.title('Correlation matrix')\r\n plt.show()\r\n\r\n # Distribution of feature values for two classes\r\n similar = pairs[pairs['true_match'] == 1]\r\n different = pairs[pairs['true_match'] == 0]\r\n\r\n for feature in features:\r\n plt.figure(figsize=(10, 5))\r\n plt.subplot(1, 2, 1)\r\n plt.hist(similar[feature], bins=30)\r\n plt.title(f'{feature} in similar samples')\r\n plt.subplot(1, 2, 2)\r\n plt.hist(different[feature], bins=30)\r\n plt.title(f'{feature} in different samples')\r\n plt.show()","def correlateX(X, y, corr=\"spearman\"):\n \n X = np.array(X)\n y = np.array(y)\n ## Force... just in case\n \n checkX(X)\n\n if corr == \"pearson\":\n corrf = pearsonr\n elif corr == \"spearman\":\n corrf = spearmanr\n else:\n raise ValueError(\"stat was not valid.\")\n \n corrs = []\n ps = []\n for jj in range(X.shape[1]):\n r, p = corrf(X[:,jj], y)\n corrs.append(r)\n ps.append(p)\n \n return np.array(corrs), np.array(ps)","def crosscorr(x, y, **kwargs):\r\n # just make the same computation as the crosscovariance,\r\n # but without subtracting the mean\r\n kwargs['debias'] = False\r\n rxy = crosscov(x, y, **kwargs)\r\n return rxy","def pairwise_correlations(self, views: Iterable[np.ndarray], **kwargs):\n transformed_views = self.transform(views, **kwargs)\n all_corrs = []\n for x, y in itertools.product(transformed_views, repeat=2):\n all_corrs.append(\n np.diag(\n np.corrcoef(x.T, y.T)[\n : self.latent_dimensions, self.latent_dimensions :\n ]\n )\n )\n try:\n all_corrs = np.array(all_corrs).reshape(\n (self.n_views_, self.n_views_, self.latent_dimensions)\n )\n except:\n print()\n return all_corrs","def determine_correlation(var1,var2):\n v1 = np.array(var1)\n v2 = np.array(var2)\n mat = np.c_[(v1,v2)]# np.vstack((v1,v2)) #\n corr = np.corrcoef(mat.T)\n return corr[0][1]","def corr(A,B):\n\n # Rowwise mean of input arrays & subtract from input arrays themeselves\n A_mA = A - A.mean(1)[:,None]\n B_mB = B - B.mean(1)[:,None]\n\n # Sum of squares across rows\n ssA = (A_mA**2).sum(1);\n ssB = (B_mB**2).sum(1);\n\n # Finally get corr coeff\n return np.dot(A_mA,B_mB.T)/np.sqrt(np.dot(ssA[:,None],ssB[None]))","def corr_with(self, other):\n return self.data.corrwith(other)","def cross_correlation(values1, values2, lags=100):\n lags, corr, line, x = pl.xcorr( values1, values2, maxlags=lags, usevlines=False, marker=None)\n return lags, corr","def correlation(x_items, y_items):\r\n return correlation_test(x_items, y_items, method='pearson', tails=None,\r\n permutations=0)[:2]","def corr(arr1, arr2):\n\n\n X = []\n Y = []\n for index in range(len(arr1)):\n if arr1[index] == None or arr2[index] == None:\n continue\n X.append(arr1[index])\n Y.append(arr2[index])\n\n\n r = np.corrcoef(X, Y)[0,1]\n f = 0.5*np.log((1+r)/(1-r))\n se = 1/np.sqrt(len(X)-3)\n ucl = f + 2*se\n lcl = f - 2*se\n\n lcl = (np.exp(2*lcl) - 1) / (np.exp(2*lcl) + 1)\n ucl = (np.exp(2*ucl) - 1) / (np.exp(2*ucl) + 1)\n\n return r,lcl,ucl","def _pearson_correlation_coeff(x_data, y_data):\n reg = linregress(x_data, y_data)\n return reg.rvalue","def crosscorr(datax, datay, lag=0, wrap=False):\n if wrap:\n shiftedy = datay.shift(lag)\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\n return datax.corr(shiftedy)\n else: \n return datax.corr(datay.shift(lag))","def mcorr(x,y):\n return ((np.ma.dot(x,y) / (x.shape[0] - 1) / y.std(axis=0)) / x.std())","def pairwise_correlation_difference(self):\r\n\r\n real_cat, synth_cat = self.to_cat(self.origdst, self.synthdst)\r\n\r\n real_cat_dem = self.get_demographics(real_cat)\r\n synth_cat_dem = self.get_demographics(synth_cat)\r\n\r\n corr_real_obj = associations(real_cat_dem, theil_u=True, bias_correction=False, plot=False)\r\n corr_synth_obj = associations(synth_cat_dem, theil_u=True, bias_correction=False, plot=False)\r\n\r\n corr_real = corr_real_obj['corr']\r\n corr_rand = corr_synth_obj['corr']\r\n\r\n substract_m = np.subtract(corr_real, corr_rand)\r\n prwcrdst = LA.norm(substract_m)\r\n\r\n return prwcrdst, substract_m","def crosscorr(datax, datay, lag=0, wrap=False):\n if wrap:\n shiftedy = datay.shift(lag)\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\n return datax.corr(shiftedy)\n else:\n return datax.corr(datay.shift(lag))","def crosscorr(datax, datay, lag=0, wrap=False):\n if wrap:\n shiftedy = datay.shift(lag)\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\n return datax.corr(shiftedy)\n else:\n return datax.corr(datay.shift(lag))","def crosscorr(datax, datay, lag=0, wrap=False):\r\n if wrap:\r\n shiftedy = datay.shift(lag)\r\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\r\n return datax.corr(shiftedy)\r\n else: \r\n return datax.corr(datay.shift(lag))","def cross_correlation(arr1, arr2):\n faxes = lambda x: tuple(np.arange(x.ndim - 1) + 1)\n\n return pipe(\n arr1,\n dafftn(axes=faxes(arr1)),\n lambda x: daconj(x) * dafftn(arr2, axes=faxes(arr2)),\n daifftn(axes=faxes(arr1)),\n dafftshift(axes=faxes(arr1)),\n lambda x: x.real / arr1[0].size,\n )","def compute_correlations(struc_df, option, gamma, alpha):\n n_states = len(np.unique(struc_df.objnum))\n nodes = network.temp_node_info()\n adjacency = network.adjacency_mat(nodes)\n L = compute_limit_matrix(0.5, adjacency, n_states)\n L_vector = L.flatten()\n M = learn_sr(struc_df, gamma, alpha)\n M = M[2, 6]\n M_vector = M.flatten()\n\n if option == \"norm\":\n print(\"Norm of L - M: \")\n print(la.norm(L_vector - M_vector, np.inf))\n\n if option == \"correlation\":\n print(\"Correlation of L, M: \")\n print(np.dot(L_vector, M_vector) /\n (la.norm(L_vector) * la.norm(M_vector)))","def crosscorr(datax, datay, lag=0, wrap=False):\n \n if wrap:\n shiftedy = datay.shift(lag)\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\n return datax.corr(shiftedy)\n else:\n return datax.corr(datay.shift(lag))","def get_correlation(outcome_vectors, s_hat):\n\n outcome_vectors2 = np.asfortranarray(outcome_vectors.data)\n ldl_shat = np.asfortranarray(s_hat)\n return fast_corr.manual_corr(outcome_vectors2.T, ldl_shat.T)","def _compute_correlations(self, data):\n mappings = self.mappings_\n n_channels, n_times = data.shape\n\n # get the predictions\n y_pred = data.T.dot(mappings.T)\n y_pred = y_pred.reshape((n_times, len(self.picks),\n self.n_resample), order='F')\n # pool them using median\n # XXX: weird that original implementation sorts and takes middle value.\n # Isn't really the median if n_resample even\n y_pred = np.median(y_pred, axis=-1)\n # compute correlation\n num = np.sum(data.T * y_pred, axis=0)\n denom = (np.sqrt(np.sum(data.T ** 2, axis=0)) *\n np.sqrt(np.sum(y_pred ** 2, axis=0)))\n\n corr = num / denom\n return corr","def CORR(A: pd.DataFrame, B: pd.DataFrame, n) -> pd.DataFrame:\r\n A = A.unstack()\r\n B = B.unstack()\r\n res = A.rolling(n).corr(B)\r\n return res.stack()","def custom_corrcoef(X, Y=None):\n if Y is None:\n Y = X\n \n if X.shape[0] != Y.shape[0]:\n raise Exception(\"X and Y must have the same number of rows.\")\n \n X = X.astype(float)\n Y = Y.astype(float)\n \n X -= X.mean(axis=0)[np.newaxis,...]\n Y -= Y.mean(axis=0)\n \n xx = np.sum(X**2, axis=0)\n yy = np.sum(Y**2, axis=0)\n \n r = np.dot(X.T, Y)/np.sqrt(np.multiply.outer(xx,yy))\n \n return r","def calculate_correlation_coefficient(column1: pd.Series, column2: pd.Series) -> np.float64:\n\n corr = column1.corr(column2)\n return corr","def test_compute_correlation_paired(self):\r\n # Verified using R's cor.test function.\r\n exp = ((0.90243902439024193, 0.013812916237431808, 0.03,\r\n (0.33958335414859975, 0.98938788428012969)), None)\r\n \r\n np.random.seed(self.value_for_seed)\r\n obs = _compute_correlation(self.taxa_summary_paired1,\r\n self.taxa_summary_paired2, 'paired', 'pearson', 'two-sided',\r\n 999, 0.95)\r\n self.compare_multiple_level_array(obs, exp)","def correlation(self, other):\n dates=self.get_dates(other.get_dates())\n #print(len(self.get_values(dates)))\n #print(len(other.get_values(dates)))\n #print(self.get_values(dates))\n r,p=stats.pearsonr(self.get_values(dates), other.get_values(dates))\n return r","def corr(self) -> 'DataFrame':\n if self._is_string():\n raise TypeError('DataFrame consists only of strings. Must have int, float, '\n 'or bool columns')\n\n x: ndarray = self._values_number()\n if x.dtype.kind == 'i':\n x0: ndarray = x[0]\n x_diff: ndarray = x - x0\n Exy: ndarray = (x_diff.T @ x_diff)\n Ex: ndarray = x_diff.sum(0)[np.newaxis, :]\n ExEy: ndarray = Ex.T @ Ex\n counts: Union[int, ndarray] = len(x)\n Ex2: ndarray = (x_diff ** 2).sum(0)\n\n else:\n x0 = _math.get_first_non_nan(x)\n x_diff = x - x0\n x_not_nan: ndarray = (~np.isnan(x)).astype(int)\n\n # get index of first non nan too and check for nan here\n x_diff_0: ndarray = np.nan_to_num(x_diff)\n counts = (x_not_nan.T @ x_not_nan)\n Exy = (x_diff_0.T @ x_diff_0)\n Ex = (x_diff_0.T @ x_not_nan)\n ExEy = Ex * Ex.T\n Ex2 = (x_diff_0.T ** 2 @ x_not_nan)\n\n with np.errstate(invalid='ignore'):\n cov: ndarray = (Exy - ExEy / counts) / (counts - 1)\n stdx: ndarray = (Ex2 - Ex ** 2 / counts) / (counts - 1)\n stdxy: ndarray = stdx * stdx.T\n corr: ndarray = cov / np.sqrt(stdxy)\n\n new_data: Dict[str, ndarray] = {'f': np.asfortranarray(corr)}\n new_column_info: ColInfoT = {'Column Name': utils.Column('S', 0, 0)}\n new_columns: ndarray = np.empty(x.shape[1] + 1, dtype='O')\n new_columns[0] = 'Column Name'\n\n i: int = 0\n for col, dtype, loc in self._col_info_iter(): # type: str, str, int\n if dtype not in 'ifb':\n continue\n new_column_info[col] = utils.Column('f', i, i + 1)\n new_columns[i + 1] = col\n i += 1\n new_data['S'] = np.asfortranarray(new_columns[1:])[:, np.newaxis]\n return self._construct_from_new(new_data, new_column_info,\n np.asarray(new_columns, dtype='O'))","def crosscov(x, y, axis=-1, all_lags=False, debias=True, normalize=True,\n\t\t\t corr=False):\n\tif x.shape[ axis ] != y.shape[ axis ]:\n\t\traise ValueError(\n\t\t\t\t'crosscov() only works on same-length sequences for now'\n\t\t)\n\tif debias:\n\t\tx = _remove_bias(x, axis)\n\t\ty = _remove_bias(y, axis)\n\tslicing = [ slice(d) for d in x.shape ]\n\tslicing[ axis ] = slice(None, None, -1)\n\tcxy = fftconvolve(x, y[ tuple(slicing) ].conj(), axis=axis, mode='full')\n\tN = x.shape[ axis ]\n\tif normalize:\n\t\tcxy /= N\n\tif all_lags:\n\t\treturn cxy\n\tslicing[ axis ] = slice(N - 1, 2 * N - 1)\n\treturn cxy[ tuple(slicing) ]","def corr_iter(df, method='spearman', multi='median', TH=1, normalize=False, normalize_kw=None, **kwargs):\n # Normalize\n if normalize_kw is None:\n normalize_kw = {}\n\n if normalize:\n _df = normalize(df, **normalize_kw)\n else:\n _df = df.copy()\n\n columns = _df.columns\n\n # Filter out low expressing genes\n mask = _df.sum(axis = 1) > TH\n _df = _df[mask]\n\n # Either compare to median or pairwise.\n if multi == 'median':\n _df['med'] = _df.median(axis=1)\n combos = product(columns, ['med'])\n else:\n combos = combinations(columns, 2)\n\n # Which correlation to calculate\n if method =='spearman':\n func = scipy.stats.spearmanr\n elif method == 'pearson':\n func = scipy.stats.pearsonr\n\n for x1, x2 in combos:\n score = func(_df[x1], _df[x2])[0]\n yield '{}:{}'.format(x1, x2), score","def study_correlation(data: np.array, labels: np.array)->None:\n n_rows = np.size(data, 0)\n n_cols = np.size(data, 1)\n\n fig, ax = plt.subplots(n_cols, n_cols)\n\n for i in range(n_cols):\n for j in range(n_cols):\n if i != j: ax[i][j].scatter(data[:,j], data[:,i], c = labels)\n else: ax[i][j].annotate(\"series \" + str(i), (0.5, 0.5), xycoords = 'axes fraction', ha = \"center\", va = \"center\")\n\n if i < n_cols-1: ax[i][j].xaxis.set_visible(False)\n if j > 0: ax[i][j].yaxis.set_visible(False)\n\n ax[-1][-1].set_xlim(ax[0][-1].get_xlim())\n ax[0][0].set_ylim(ax[0][1].get_ylim())\n\n plt.show()\n plt.close()\n\n #print(\"Correlation between features {} and {} is {}\".format(1, 2, 3))","def run_r_corr(df, corr_type='spearman', p_correction='BH'):\r\n num_cols = len(df.columns.values)\r\n r_dataframe = pandas2ri.py2ri(df)\r\n r_as = r['as.matrix']\r\n rcorr = r['rcorr'] \r\n r_p_adjust = r['p.adjust']\r\n result = rcorr(r_as(r_dataframe), type=corr_type)\r\n rho = result[0]\r\n n = result[1]\r\n p = result[2]\r\n \r\n if p_correction is not None:\r\n p = r_p_adjust(p, p_correction)\r\n r_corrs = pandas2ri.ri2py(rho)\r\n r_p_vals = pandas2ri.ri2py(p)\r\n r_counts = pandas2ri.ri2py(n)\r\n r_p_vals = np.reshape(r_p_vals, (num_cols,num_cols))\r\n return r_corrs, r_counts, r_p_vals","def correlation(result, reference):\n \n r = np.corrcoef(result, reference)[0,1]\n \n return r","def fast_corr(df, col_name):\n\n if not isinstance(df, pd.DataFrame):\n raise TypeError(\"The type of the input data must be dataframe.\")\n\n if not isinstance(col_name, list):\n raise TypeError(\"The col_name must be list.\")\n\n if all(isinstance(item, str) for item in col_name) is False and all(\n isinstance(item, int) for item in col_name) is False:\n raise ValueError(\n \"The col_name must be a list of strings or a list of integers.\")\n\n if len(col_name) < 2:\n raise ValueError(\n \"At least two columns must be selected for correlation analysis.\")\n\n if all(isinstance(item, str) for item in col_name) is True and all(\n elem in df.columns.to_list() for elem in col_name) is False:\n raise ValueError(\"The column names were not found.\")\n\n if all(isinstance(item, int) for item in col_name) is True and max(\n col_name) > (df.shape[1] - 1):\n raise ValueError(\"The column indexes were out of range.\")\n\n if all(isinstance(item, str) for item in col_name):\n data = df.loc[:, col_name]\n else:\n data = df.iloc[:, col_name]\n\n data2 = data._get_numeric_data()\n rm_n = data.shape[1] - data2.shape[1]\n print(\"Removed\", rm_n, \"non-numberical columns from your selected columns\")\n\n sns.set(style=\"white\")\n corr = data2.corr()\n mask = np.triu(np.ones_like(corr, dtype=np.bool))\n f, ax = plt.subplots(figsize=(9, 11))\n ax.set_title('Correlation Matrix', size=20)\n ax.tick_params(axis='x', labelsize=15)\n ax.tick_params(axis='y', labelsize=15)\n\n cmap = sns.diverging_palette(220, 20, as_cmap=True)\n p = sns.heatmap(corr, mask=mask, cmap=cmap, vmin=-1, vmax=1, center=0,\n square=True, linewidths=.5, cbar_kws={\"shrink\": .5})\n p.set_yticklabels(p.get_yticklabels(), rotation=360)\n return p","def corrcoef(self):\r\n return np.corrcoef(self.input.data)","def correlation(x: pd.Series, y: pd.Series, d: int) -> pd.Series:\n # todo multiindex\n if isinstance(d, float):\n d = math.floor(d)\n if isinstance(x.index, pd.MultiIndex):\n x.name = 'x'\n y.name = 'y'\n j = x.to_frame().join(y.to_frame())\n res = []\n\n for g in j.groupby(level=1):\n\n a = g[1][x.name]\n b = g[1][y.name]\n r = a.rolling(window=d).corr(b)\n res.append(r)\n return pd.concat(res).reorder_levels([1, 0])\n else:\n return x.rolling(window=d).corr(y)","def cross_correlation(field1, field2):\n array_len = len(field1)\n # Take the index of the largest value in the array of correlation values calculated via a full convolve\n # cross correlation.\n arg_max = np.argmax((np.correlate([float(i) for i in field1], [float(i) for i in field2], mode='full')))\n # Map the index of the largest correlation value to that of the season lag between metrics\n return -(int(np.arange(-array_len+1, array_len)[arg_max]))","def show_correlations(regressors, features, targets):\r\n \r\n def mae(v1, v2):\r\n #\"\"\"Return the MAE (mean absolute error) of v1 & v2.\"\"\"\r\n return mean(abs(v1 - v2))\r\n\t\r\n from sklearn.metrics import matthews_corrcoef\r\n from scipy.stats import pearsonr\r\n\t\r\n for regressor in regressors:\r\n regressor['preds'] = regressor['regressor'].predict(features)\r\n \r\n print('=============== MAE Comparison =================')\r\n for regressor in regressors:\r\n print('{} : {}'.format(regressor['name'], mae(regressor['preds'], targets)))\r\n \r\n print(\"=============== Pearson's Correlation Comparison =================\")\r\n for regressor in regressors:\r\n print('{} : {}'.format(regressor['name'], pearsonr(regressor['preds'], targets)))","def corrcoef(X, Y, shape, use_full_fft=False):\n if len(X.shape) != 2:\n raise ValueError(\"X is not a two-dimensional array\")\n\n if len(Y.shape) != 2:\n raise ValueError(\"Y is not a two-dimensional array\")\n\n if X.shape != Y.shape:\n raise ValueError(\n \"dimension mismatch between X and Y: \"\n + \"X.shape=%d,%d , \" % (X.shape[0], X.shape[1])\n + \"Y.shape=%d,%d\" % (Y.shape[0], Y.shape[1])\n )\n\n n = np.real(np.sum(X * np.conj(Y))) - np.real(X[0, 0] * Y[0, 0])\n d1 = np.sum(np.abs(X) ** 2) - np.real(X[0, 0]) ** 2\n d2 = np.sum(np.abs(Y) ** 2) - np.real(Y[0, 0]) ** 2\n\n if not use_full_fft:\n if shape[1] % 2 == 1:\n n += np.real(np.sum(X[:, 1:] * np.conj(Y[:, 1:])))\n d1 += np.sum(np.abs(X[:, 1:]) ** 2)\n d2 += np.sum(np.abs(Y[:, 1:]) ** 2)\n else:\n n += np.real(np.sum(X[:, 1:-1] * np.conj(Y[:, 1:-1])))\n d1 += np.sum(np.abs(X[:, 1:-1]) ** 2)\n d2 += np.sum(np.abs(Y[:, 1:-1]) ** 2)\n\n return n / np.sqrt(d1 * d2)","def corr(a, b):\n ma = np.mean(a)\n mb = np.mean(b)\n\n a_ = a - ma\n b_ = b - mb\n\n norma = np.sqrt(np.sum(a_ ** 2, axis=0))\n normb = np.sqrt(np.sum(b_ ** 2, axis=0))\n\n norma[norma < TOLERANCE] = 1.0\n normb[normb < TOLERANCE] = 1.0\n\n a_ *= 1.0 / norma\n b_ *= 1.0 / normb\n\n ip = np.dot(a_.T, b_)\n\n if ip.shape == (1, 1):\n return ip[0, 0]\n else:\n return ip","def r2(preds, actual):\n preds = np.reshape(preds, (-1,))\n r = np.corrcoef(preds, actual)[0,1]\n rsq = r ** 2\n return r,rsq","def correlations_multiple(data, correlations, periodic_boundary=True, cutoff=None):\n\n return pipe(\n range(data.shape[-1]),\n map_(lambda x: (0, x)),\n lambda x: correlations if correlations else x,\n map_(\n lambda x: two_point_stats(\n data[..., x[0]],\n data[..., x[1]],\n periodic_boundary=periodic_boundary,\n cutoff=cutoff,\n )\n ),\n list,\n lambda x: da.stack(x, axis=-1),\n lambda x: da.rechunk(x, x.chunks[:-1] + (-1,)),\n )","def compute_clf_based_correlation_score(stats, columns, col_name):\n full_col_data = columns[col_name]\n\n dt_clf = DecisionTreeClassifier()\n\n other_feature_names = []\n other_features = []\n for other_col_name in columns.columns:\n if other_col_name == col_name:\n continue\n\n other_feature_names.append(other_col_name)\n le = LabelEncoder()\n _stringified_col = list(map(str,columns[other_col_name]))\n le.fit(_stringified_col)\n other_features.append(list(le.transform(_stringified_col)))\n\n other_features_t = np.array(other_features, dtype=object).transpose()\n\n le = LabelEncoder()\n _stringified_col = list(map(str,full_col_data))\n le.fit(_stringified_col)\n y = le.transform(_stringified_col)\n dt_clf.fit(other_features_t,y)\n prediction_score = dt_clf.score(other_features_t,y)\n corr_scores = list(dt_clf.feature_importances_)\n highest_correlated_column = max(corr_scores)\n return {\n 'correlation_score': round(10 * (1 - prediction_score * highest_correlated_column))\n ,'highest_correlation': max(corr_scores)\n ,'most_correlated_column': other_feature_names[corr_scores.index(max(corr_scores))]\n ,'similarity_score_description':\"\"\"\n A high value for this score means that two of your columns are highly similar. This is done by trying to predict one column using the other via a simple DT.\n \"\"\"\n }","def concordance_correlation_coefficient(y_true, y_pred,\n sample_weight=None,\n multioutput='uniform_average'):\n cor=np.corrcoef(y_true,y_pred)[0][1]\n \n mean_true=np.mean(y_true)\n mean_pred=np.mean(y_pred)\n \n var_true=np.var(y_true)\n var_pred=np.var(y_pred)\n \n sd_true=np.std(y_true)\n sd_pred=np.std(y_pred)\n \n numerator=2*cor*sd_true*sd_pred\n \n denominator=var_true+var_pred+(mean_true-mean_pred)**2\n\n return numerator/denominator","def _compute_corr(fmap):\n fmap = fmap.view(fmap.size(0), fmap.size(1), -1)\n fmap = nn.functional.normalize(fmap, dim=2, eps=1e-08)\n corr = torch.bmm(fmap.permute(0, 2, 1), fmap)\n return corr.view(corr.size(0), -1)","def correlation_distribution(df: pd.DataFrame):\n # Correlation heatmap\n ax = sns.heatmap(df.corr(),\n center=0, annot=True, cmap='RdBu_r')\n l, r = ax.get_ylim()\n ax.set_ylim(l + 0.5, r - 0.5)\n plt.yticks(rotation=0)\n plt.title('Correlation matrix')\n plt.show()\n\n # Individual correlations between features and the target\n for feature in features:\n print(f'{feature}: {df[feature].min()} - {df[feature].max()}, '\n f'mean = {df[feature].mean()}, median = {df[feature].median()}')\n plt.figure(figsize=(14, 5))\n plt.subplot(1, 2, 1)\n plt.scatter(df[feature], df[target])\n plt.xlabel(feature)\n plt.ylabel(target)\n plt.title(f'{feature} correlation')\n plt.subplot(1, 2, 2)\n plt.hist(df[feature], bins=20)\n plt.title(f'{feature} distribution')\n plt.show()\n\n # Distribution of target values and standard errors\n for par in ('target', 'standard_error'):\n print(f'{par}: {df[par].min()} - {df[par].max()}, mean = {df[par].mean()}, median = {df[par].median()}')\n plt.hist(df[par], bins=20)\n plt.title(f'{par} distribution')\n plt.show()","def compute_correlations(dataset,\n encode=False,\n columns_nominal='auto',\n columns_dichotomous='auto',\n columns_ordinal=None,\n mark_columns=False,\n theils=False,\n clustering=False,\n bias_correction=True,\n nan_strategy=_REPLACE,\n nan_replace_value=_DEFAULT_REPLACE_VALUE):\n dataset = convert(dataset, 'dataframe') # TODO implement encoding\n\n if nan_strategy == _REPLACE:\n dataset.fillna(nan_replace_value, inplace=True)\n elif nan_strategy == _DROP_SAMPLES:\n dataset.dropna(axis=0, inplace=True)\n elif nan_strategy == _DROP_FEATURES:\n dataset.dropna(axis=1, inplace=True)\n\n columns = dataset.columns\n\n if columns_nominal is None:\n columns_nominal = list()\n elif columns_nominal == 'all':\n columns_nominal = columns\n elif columns_nominal == 'auto':\n columns_nominal = identify_nominal_columns(dataset)\n\n if columns_dichotomous is None:\n columns_dichotomous = list()\n elif columns_dichotomous == 'all':\n columns_dichotomous = columns\n elif columns_dichotomous == 'auto':\n columns_dichotomous = identify_dichotomous_columns(dataset, columns_nominal)\n\n if columns_ordinal is None:\n columns_ordinal = list()\n elif columns_ordinal == 'all':\n columns_ordinal = columns\n elif columns_ordinal == 'auto':\n columns_ordinal = identify_ordinal_columns(dataset, columns_nominal, columns_dichotomous)\n\n corr = pd.DataFrame(index=columns, columns=columns)\n sign = pd.DataFrame(index=columns, columns=columns)\n coef = pd.DataFrame(index=columns, columns=columns)\n\n columns_single_value = []\n\n inf_nan_corr = pd.DataFrame(data=np.zeros_like(corr),\n columns=columns,\n index=columns)\n\n inf_nan_sign = pd.DataFrame(data=np.zeros_like(corr),\n columns=columns,\n index=columns)\n\n for c in columns:\n # Test if column only contains single value\n if dataset[c].unique().size == 1:\n # Column only contains a single value, prepare for no calculation to be done\n columns_single_value.append(c)\n\n for i in range(0, len(columns)):\n\n if columns[i] in columns_single_value:\n # If column only contains a single value, not correlation calculation necessary\n corr.loc[:, columns[i]] = 0.0\n corr.loc[columns[i], :] = 0.0\n continue\n\n for j in range(i, len(columns)):\n\n if columns[j] in columns_single_value:\n continue\n\n elif i == j:\n # Correlation to itself is always 1.0\n corr.loc[columns[i], columns[j]] = 1.0\n sign.loc[columns[i], columns[j]] = _SIGN_NAN\n inf_nan_sign.loc[columns[i], columns[j]] = _inf_nan_str(_SIGN_NAN)\n\n else:\n # print('Processing ' + columns[i] + ' and ' + columns[j])\n if columns[i] in columns_nominal or columns[i] in columns_dichotomous or columns[i] in columns_ordinal:\n # i is categorical\n if columns[j] in columns_nominal or columns[j] in columns_dichotomous or columns[\n j] in columns_ordinal:\n # i and j are categorical\n if theils:\n # Because Theil's U is asymmetrical, calculate both directions separately\n ij, p, c = theils_u(dataset[columns[i]], dataset[columns[j]]) # TODO handle two p values\n ji, p, c = theils_u(dataset[columns[j]], dataset[columns[i]]) # TODO handle two p values\n else:\n cell, p, c = cramers_v(dataset[columns[i]], dataset[columns[j]],\n bias_correction=bias_correction)\n ij = cell\n ji = cell\n else:\n # i is categorical, j is continuous\n if columns[i] in columns_ordinal:\n # i is ordinal, j is continuous\n cell, p, c = kendall(dataset[columns[j]], dataset[columns[i]])\n elif columns[i] in columns_dichotomous:\n # i is dichotomous, j is continuous\n cell, p, c = point_biserial(dataset[columns[j]], dataset[columns[i]])\n else:\n # i is nominal, j is continuous\n cell, p, c = eta(dataset[columns[j]], dataset[columns[i]])\n\n ij = cell\n ji = cell\n\n elif columns[j] in columns_nominal or columns[j] in columns_dichotomous or columns[\n j] in columns_ordinal:\n # j is categorical, i is continuous\n if columns[j] in columns_ordinal:\n # j is ordinal, i is continuous\n cell, p, c = kendall(dataset[columns[i]], dataset[columns[j]])\n\n elif columns[j] in columns_dichotomous:\n # j is dichotomous, i is continuous\n cell, p, c = point_biserial(dataset[columns[i]], dataset[columns[j]])\n else:\n # j is nominal, i is continuous\n cell, p, c = eta(dataset[columns[i]], dataset[columns[j]])\n\n ij = cell\n ji = cell\n\n else:\n # i and j are continuous\n assert columns[i] not in columns_nominal or columns[i] not in columns_dichotomous or columns[\n i] not in columns_ordinal, columns[i] + ' should not be here'\n assert columns[j] not in columns_nominal or columns[j] not in columns_dichotomous or columns[\n j] not in columns_ordinal, columns[j] + ' should not be here'\n cell, p, c = pearsons(dataset[columns[i]], dataset[columns[j]])\n\n ij = cell\n ji = cell\n\n corr.loc[columns[i], columns[j]] = round(ij, 2) if not np.isnan(ij) and abs(ij) < np.inf else 0.0\n corr.loc[columns[j], columns[i]] = round(ji, 2) if not np.isnan(ji) and abs(ji) < np.inf else 0.0\n sign.loc[columns[i], columns[j]] = round(p, 4) if not np.isnan(p) and abs(p) < np.inf else _SIGN_NAN\n sign.loc[columns[j], columns[i]] = round(p, 4) if not np.isnan(p) and abs(p) < np.inf else _SIGN_NAN\n coef.loc[columns[i], columns[j]] = c\n coef.loc[columns[j], columns[i]] = c\n inf_nan_corr.loc[columns[i], columns[j]] = _inf_nan_str(ij)\n inf_nan_corr.loc[columns[j], columns[i]] = _inf_nan_str(ji)\n inf_nan_sign.loc[columns[i], columns[j]] = _inf_nan_str(p)\n inf_nan_sign.loc[columns[j], columns[i]] = _inf_nan_str(p)\n\n corr.fillna(value=np.nan, inplace=True)\n sign.fillna(value=np.nan, inplace=True)\n\n if mark_columns:\n marked_columns = [\n '{} (nom)'.format(col)\n if col in columns_nominal else '{} (con)'.format(col)\n for col in columns\n ]\n corr.columns = marked_columns\n corr.index = marked_columns\n inf_nan_corr.columns = marked_columns\n inf_nan_corr.index = marked_columns\n\n if clustering:\n corr, p = cluster_correlations(corr)\n columns = corr.columns\n\n return {\n 'correlation': corr,\n 'significance': sign,\n 'coefficient': coef,\n 'columns': columns,\n 'columns_nominal': columns_nominal,\n 'columns_dichotomous': columns_dichotomous,\n 'columns_ordinal': columns_ordinal,\n 'inf_nan_corr': inf_nan_corr,\n 'inf_nan_sign': inf_nan_sign,\n 'columns_single_value': columns_single_value}","def associations(dataset, nominal_columns=None, mark_columns=False, theil_u=False, plot=True,\n return_results = False, **kwargs):\n\n dataset = convert(dataset, 'dataframe')\n columns = dataset.columns\n if nominal_columns is None:\n nominal_columns = list()\n elif nominal_columns == 'all':\n nominal_columns = columns\n corr = pd.DataFrame(index=columns, columns=columns)\n for i in range(0,len(columns)):\n for j in range(i,len(columns)):\n if i == j:\n corr[columns[i]][columns[j]] = 1.0\n else:\n if columns[i] in nominal_columns:\n if columns[j] in nominal_columns:\n if theil_u:\n corr[columns[j]][columns[i]] = theils_u(dataset[columns[i]],dataset[columns[j]])\n corr[columns[i]][columns[j]] = theils_u(dataset[columns[j]],dataset[columns[i]])\n else:\n cell = cramers_v(dataset[columns[i]],dataset[columns[j]])\n corr[columns[i]][columns[j]] = cell\n corr[columns[j]][columns[i]] = cell\n else:\n cell = correlation_ratio(dataset[columns[i]], dataset[columns[j]])\n corr[columns[i]][columns[j]] = cell\n corr[columns[j]][columns[i]] = cell\n else:\n if columns[j] in nominal_columns:\n cell = correlation_ratio(dataset[columns[j]], dataset[columns[i]])\n corr[columns[i]][columns[j]] = cell\n corr[columns[j]][columns[i]] = cell\n else:\n cell, _ = ss.pearsonr(dataset[columns[i]], dataset[columns[j]])\n corr[columns[i]][columns[j]] = cell\n corr[columns[j]][columns[i]] = cell\n corr.fillna(value=np.nan, inplace=True)\n if mark_columns:\n marked_columns = ['{} (nom)'.format(col) if col in nominal_columns else '{} (con)'.format(col) for col in columns]\n corr.columns = marked_columns\n corr.index = marked_columns\n if plot:\n plt.figure(figsize=(20,20))#kwargs.get('figsize',None))\n sns.heatmap(corr, annot=kwargs.get('annot',True), fmt=kwargs.get('fmt','.2f'), cmap='coolwarm')\n plt.show()\n if return_results:\n return corr","def distcorrXY(X, Y):\n X = np.atleast_1d(X)\n Y = np.atleast_1d(Y)\n if np.prod(X.shape) == len(X):\n X = X[:, None]\n if np.prod(Y.shape) == len(Y):\n Y = Y[:, None]\n X = np.atleast_2d(X)\n Y = np.atleast_2d(Y)\n n = X.shape[0]\n if Y.shape[0] != X.shape[0]:\n raise ValueError('Number of samples must match')\n a = squareform(pdist(X))\n b = squareform(pdist(Y))\n A = a - a.mean(axis=0)[None, :] - a.mean(axis=1)[:, None] + a.mean()\n B = b - b.mean(axis=0)[None, :] - b.mean(axis=1)[:, None] + b.mean()\n \n dcov2_xy = (A * B).sum()/float(n * n)\n dcov2_xx = (A * A).sum()/float(n * n)\n dcov2_yy = (B * B).sum()/float(n * n)\n dcor = np.sqrt(dcov2_xy)/np.sqrt(np.sqrt(dcov2_xx) * np.sqrt(dcov2_yy))\n return dcor","def pearson_correlation(X, Y):\n # should not need X_norm_squared because if you could precompute that as\n # well as Y, then you should just pre-compute the output and not even\n # call this function.\n if X is Y:\n X = Y = np.asanyarray(X)\n else:\n X = np.asanyarray(X)\n Y = np.asanyarray(Y)\n\n if X.shape[1] != Y.shape[1]:\n raise ValueError(\"Incompatible dimension for X and Y matrices\")\n\n XY = ssd.cdist(X, Y, 'correlation', 2)\n\n return 1 - XY","def coupling_coef_corrs(coupling_coefs1, coupling_coefs2, correlation='pearson'):\n n_neurons = coupling_coefs1.shape[0]\n correlations = np.zeros(n_neurons)\n\n for neuron in range(n_neurons):\n ccs1 = coupling_coefs1[neuron]\n ccs2 = coupling_coefs2[neuron]\n\n if np.array_equal(ccs1, ccs2):\n correlations[neuron] = 1.\n elif np.all(ccs1 == 0) or np.all(ccs2 == 0):\n correlations[neuron] = 0\n else:\n if correlation == 'pearson':\n correlations[neuron] = np.corrcoef(ccs1, ccs2)[0, 1]\n elif correlation == 'spearman':\n correlations[neuron] = spearmanr(ccs1, ccs2).correlation\n elif correlation == 'cosine':\n correlations[neuron] = cosine_similarity(ccs1, ccs2)\n\n return correlations","def auto_correlation(arr):\n return cross_correlation(arr, arr)","def corr():\n\n @sinks\n def _dagpype_internal_fn_act(target):\n c = dagpype_c.Correlator()\n try:\n while True:\n x, y = (yield)\n c.push(float(x), float(y))\n except GeneratorExit:\n target.send(c.corr())\n target.close()\n return _dagpype_internal_fn_act","def correlation_1D2D_datainput(df1, df2): # correlation function from Rémi (local.py)\n\n df2 = df2.transpose() # sigs_2D.transpose()\n cov = np.dot(df1 - df1.mean(), df2 - df2.mean(axis=0)) / (df2.shape[0] - 1)\n # ddof=1 necessary because covariance estimate is unbiased (divided by n-1)\n p_var = np.sqrt(np.var(df1, ddof=1) * np.var(df2, axis=0, ddof=1))\n r = cov / p_var\n return r","def _listcorr(a):\n corrs = np.zeros((a[0].shape[1], len(a), len(a)))\n for i in range(len(a)):\n for j in range(len(a)):\n if j > i:\n corrs[:, i, j] = [np.nan_to_num(np.corrcoef(ai, aj)[0, 1])\n for (ai, aj) in zip(a[i].T, a[j].T)]\n return corrs","def test_compute_correlation_paired_detailed(self):\r\n # Verified using R's cor.test function.\r\n exp = ((0.90243902439024193, 0.013812916237431808, 0.038,\r\n (0.33958335414859975, 0.98938788428012969)),\r\n [('S1', 'S1', 1.0, 0, 0, 0.373, 0.746, (None, None)),\r\n ('S2', 'S2', 0.94491118252306538, 0.21229561500966185,\r\n 0.4245912300193237, 0.342, 0.684, (None, None))])\r\n\r\n np.random.seed(self.value_for_seed)\r\n obs = _compute_correlation(self.taxa_summary_paired1,\r\n self.taxa_summary_paired2, 'paired', 'pearson', 'two-sided',\r\n 999, 0.95, True)\r\n\r\n self.compare_multiple_level_array(obs, exp)","def correlation_matrix(series, as_rows=True):\r\n return corrcoef(series, rowvar=as_rows)\r\n # unused codes below\r\n if as_rows:\r\n return corrcoef(transpose(array(series)))\r\n else:\r\n return corrcoef(array(series))","def cross_correlations(df1,df2,subject_ID_col):\n n_roi = len(df1.columns)-1 #cols=subject_ID + roi_cols\n\n col_rename_dict = {} #Only need to rename on df\n \n for col in df1.columns:\n col_rename_dict[col] = str(col) + '_df2'\n\n df2 = df2.rename(columns=col_rename_dict)\n df2 = df2.rename(columns={'{}_df2'.format(subject_ID_col):subject_ID_col})\n\n concat_df = df1.merge(df2, on=subject_ID_col)\n corr_mat = concat_df.corr()\n xcorr_dig = corr_mat.values[:n_roi,n_roi:2*n_roi].diagonal()\n xcorr_df = pd.DataFrame(columns=['ROI','correlation'])\n xcorr_df['ROI'] = corr_mat.columns[:n_roi] \n xcorr_df['correlation'] = xcorr_dig\n\n return xcorr_df","def cross_correlation(f, g):\n\n out = None\n k = np.flip(np.flip(g, 0), 1)\n out = conv_fast(f, k)\n\n return out","def computeCorr(pred_act,responses):\n\n num_pres,num_neurons = np.shape(responses)\n corr=np.zeros(num_neurons)\n \n for i in xrange(0,num_neurons):\n if np.all(pred_act[:,i]==0) & np.all(responses[:,i]==0):\n corr[i]=1.\n elif not(np.all(pred_act[:,i]==0) | np.all(responses[:,i]==0)):\n # /!\\ To prevent errors due to very low values during computation of correlation\n if abs(pred_act[:,i]).max()<1:\n pred_act[:,i]=pred_act[:,i]/abs(pred_act[:,i]).max()\n if abs(responses[:,i]).max()<1:\n responses[:,i]=responses[:,i]/abs(responses[:,i]).max() \n corr[i]=pearsonr(np.array(responses)[:,i].flatten(),np.array(pred_act)[:,i].flatten())[0]\n \n return corr","def pearsonCorrelation(x, y):\n\tsum_sq_x = 0\n\tsum_sq_y = 0\n\tsum_coproduct = 0\n\tmean_x = x[0]\n\tmean_y = y[0]\n\tif len(x) != len(y):\n\t\traise StatsError(\"Data sets are of different lengths.\")\n\tn = len(x)\n\tfor i in range(1,n):\n\t\tsweep = i / (i+1.0)\n\t\tdelta_x = x[i] - mean_x\n\t\tdelta_y = y[i] - mean_y\n\t\tsum_sq_x += delta_x * delta_x * sweep\n\t\tsum_sq_y += delta_y * delta_y * sweep\n\t\tsum_coproduct += delta_x * delta_y * sweep\n\t\tmean_x += delta_x / (i+1.0)\n\t\tmean_y += delta_y / (i+1.0)\n\tpop_sd_x = math.sqrt( sum_sq_x / n )\n\tpop_sd_y = math.sqrt( sum_sq_y / n )\n\tcov_x_y = sum_coproduct / n\n\tr = cov_x_y / (pop_sd_x * pop_sd_y)\n\tz = math.fabs(r) * math.sqrt(n) / math.sqrt(2.0)\n\tp = Prob_Z(z)\n\tif not (0.0 <= p <= 1.0):\n\t\traise StatsError(\"Invalid P-value of %r.\" % r)\n\treturn (r, p, n)","def get_corr(self):\r\n cov = self.data.values\r\n with np.errstate(divide='ignore', invalid='ignore'):\r\n coeff = np.true_divide(1, self.get_std().values)\r\n coeff[~ np.isfinite(coeff)] = 0 # -inf inf NaN\r\n corr = np.multiply(np.multiply(cov, coeff).T, coeff)\r\n df = pd.DataFrame(\r\n corr,\r\n index=self.data.index,\r\n columns=self.data.columns,\r\n )\r\n return self.__class__(df)","def _c_correlation(cls, X, y):\n su = np.zeros(X.shape[1])\n for i in np.arange(X.shape[1]):\n su[i] = cls._symmetrical_uncertainty(X[:, i], y)\n return su","def features_correlation(df, cols, target, fig_size=(6,6), path=None):\n f, ax = plt.subplots(1, figsize=fig_size)\n ax.set_xlabel(\"Feature Correlation\")\n visualizer = FeatureCorrelation(labels=list(cols))\n visualizer.fit(df[cols], df[target])\n f.tight_layout()\n if(path != None):\n f.savefig(path+'/features_correlation.png')","def compute_corr(self):\n self.corr_ = cov_to_corr(self.cov_)\n return self","def corr(x, y, pX, pY, pxy):\n return cov(x, y, pxy) / (mystd(x, pX) * mystd(y, pY))","def correlation_with_indices(*, index_filename, pc_df):\n index_df = pd.read_csv(index_filename,\n parse_dates=['date'], index_col=0)\n # Keep only data common to both time series\n merged = pd.merge(pc_df.dropna(), index_df.dropna(), on='date',\n how='inner')\n\n index_cols = merged.filter(regex='AE|AO|AU|AL|Dst|PCN|PCS|Em',\n axis=1).columns\n coeffs = []\n for index in index_cols:\n # Calculate correlation coefficient between principal component and\n # index\n coeff = np.corrcoef(merged.proxy, merged[index])\n coeffs.append(coeff.data[0, 1])\n return index_cols, coeffs","def combine_for_correlation(df1=get_us_ridership(), df2=get_sales_data()):\n df1.index.astype(int)\n df2.index.astype(int)\n temp = pd.concat([df1, df2], axis=1)\n return temp.dropna()","def test_compute_correlation_paired_no_permutations(self):\r\n # Verified using R's cor.test function.\r\n exp = ((0.90243902439024193, 0.013812916237431808, None,\r\n (0.48961251524616184, 0.98476601971494115)),\r\n [('S1', 'E1', 1.0, 0, 0, None, None, (None, None)),\r\n ('S2', 'E1', 0.94491118252306538, 0.21229561500966185,\r\n 0.4245912300193237, None, None, (None, None))])\r\n obs = _compute_correlation(self.taxa_summary_paired1,\r\n self.taxa_summary_paired3, 'paired', 'pearson', 'two-sided',\r\n 0, 0.90, True)\r\n self.compare_multiple_level_array(obs, exp)","def _cont_cat_corr_features_anova(self, p_val = 0.01, subsamplesize = 100, p_seed = 0):\n \"\"\" Use ICC to define correlations, give box-plots for highly correlated pairs \"\"\"\n # TODO add option to do Bonferroni correction to adjust p-value depending on number of variables\n \n warnings.filterwarnings('ignore')\n # List of pairs along with correlation above threshold\n cont_cat_corr_list = []\n \n seed(p_seed)\n rand_vals = sample(range(self._n_rows), k=subsamplesize)\n \n # Search for the highly correlated pairs\n for i in self._cont_index_predictors: \n for j in self._cat_index_predictors:\n formula = self._dataset.columns[i] + \" ~ \" + self._dataset.columns[j] \n model_fit = ols(formula, data=self._dataset.iloc[rand_vals,:]).fit()\n anova_model = anova_lm(model_fit)\n p = anova_model.iloc[0,4]\n if p < p_val:\n cont_cat_corr_list.append([p,i,j]) #store correlation and columns index\n \n # Order variables by level of correlation \n s_cont_cat_corr_list = sorted(cont_cat_corr_list,key=lambda x: abs(x[0]))\n \n cont_cat_corr_features = []\n\n for v,i,j in s_cont_cat_corr_list:\n cont_cat_corr_features.append([self._dataset.columns[i],self._dataset.columns[j],v])\n \n return cont_cat_corr_features","def get_corr(self):\n return self.corr_matrix, self.corr_signature","def find_correlation(df, method=\"pearson\", threshold=0.9):\n corr_matrix = df.corr(method=method).abs()\n corr_means = {k: corr_matrix[k].mean()\n for k in corr_matrix.columns.tolist()}\n corr_matrix.loc[:, :] = np.tril(corr_matrix, k=-1)\n\n correlated = {}\n for col in corr_matrix:\n corr_cols = corr_matrix[col][corr_matrix[col]\n >= threshold].index.tolist()\n corr_cols.append(col)\n\n if len(corr_cols) > 1:\n selected_cols = {k: corr_means[k] for k in corr_cols}\n\n selected_col = max(selected_cols, key=lambda k: selected_cols[k])\n correlated_col = corr_matrix.transpose()[selected_col].idxmax()\n correlated[selected_col] = (correlated_col,\n corr_matrix[correlated_col][selected_col])\n return correlated","def calculate_correlations(input_data, index_col, cat_features, exclu_elements): \r\n try:\r\n # encode the categorical features\r\n encoded_data = pd.get_dummies(input_data,columns=cat_features,drop_first=True)\r\n\r\n pd_transposed_data = encoded_data.set_index('Style_display_code').T\r\n\r\n # get the number of items\r\n items_list = [str(a) for a in pd_transposed_data.columns]\r\n\r\n print(\"Number of items to correlate :{}_Timestamp:{}\".format(str(len(items_list)), \r\n format(str(datetime.now()))))\r\n \r\n\r\n #compute correlations and save the pickle file\r\n# matrix = pd_transposed_data.corr().values\r\n# pickle.dump(matrix, open(staging_dir+ '/corr_matrix_output_py3.p', 'wb'))\r\n \r\n # read from the saved pickle file - ONLY FOR CONSECUTIVE RUNS, TO SAVE TIME\r\n matrix = pickle.load(open(staging_dir+ '/corr_matrix_output_py3.p', \"rb\" ) )\r\n\r\n print(\"Corr Matrix size:{}_Timestamp:{}\".format(str(matrix.size),\r\n format(str(datetime.now()))))\r\n\r\n except Exception as e:\r\n print(\" Error !!\", e)\r\n \r\n # return the top correlated items\r\n return top_correlateditems(items_list,matrix, index_col, exclu_elements)","def correlation(G, variables = [], conditionants = []):\n \n cov = covariance(G, variables = variables, \n conditionants = conditionants)\n k = cov.shape[0]\n sds = sp.Matrix([1/sp.sqrt(cov[i, i]) for i \n in range(0, k)]*k).reshape(k, k)\n \n cor = cov.multiply_elementwise(sds).multiply_elementwise(sds.T)\n return cor.applyfunc(sp.simplify)","def test_distance_correlation_fast(self):\n arr1 = np.array(((1,), (2,), (3,), (4,), (5,), (6,)))\n arr2 = np.array(((1,), (7,), (5,), (5,), (6,), (2,)))\n\n covariance = dcor_internals._u_distance_covariance_sqr_fast(\n arr1, arr2)\n self.assertAlmostEqual(covariance, -0.88889, places=5)\n\n correlation = dcor_internals._u_distance_correlation_sqr_fast(\n arr1, arr2)\n self.assertAlmostEqual(correlation, -0.41613, places=5)\n\n covariance = dcor_internals._u_distance_covariance_sqr_fast(\n arr1, arr1)\n self.assertAlmostEqual(covariance, 1.5556, places=4)\n\n correlation = dcor_internals._u_distance_correlation_sqr_fast(\n arr1, arr1)\n self.assertAlmostEqual(correlation, 1, places=5)","def correlation(row):\n return row['correlation']","def continous_correlation(independent, dependent):\n\n # Init of resulting DataFrame\n corr_data = pd.DataFrame()\n for indep_var in independent.columns:\n # Drop nans\n combined = pd.concat([independent[indep_var], dependent], axis=1).dropna()\n # Write down sample size\n corr_data.loc[indep_var, \"sample_size\"] = len(combined)\n # Calculate correlations with scipy methods\n corr_data.loc[indep_var, 'pearson_rho'], corr_data.loc[indep_var, 'pearson'] = pearsonr(combined[indep_var],\n combined[\n dependent.name])\n corr, corr_data.loc[indep_var, 'kendall'] = kendalltau(combined[indep_var], combined[dependent.name])\n corr_data.loc[indep_var, 'log_pearson_rho'], corr_data.loc[indep_var, 'log_pearson'] = nan, nan\n corr_data.loc[indep_var, f'log({indep_var})_{dependent.name}_rho'], \\\n corr_data.loc[indep_var, f'log({indep_var})_{dependent.name}_pearson'] = nan, nan\n return corr_data","def coupling_coef_corrs(fits_path, dataset1, dataset2):\n fits = h5py.File(fits_path, 'r')\n coefs1 = np.median(fits[dataset1]['coupling_coefs'][:], axis=0)\n coefs2 = np.median(fits[dataset2]['coupling_coefs'][:], axis=0)\n\n n_neurons = coefs1.shape[0]\n corrs = np.zeros(n_neurons)\n\n for neuron in range(n_neurons):\n corrs[neuron] = np.corrcoef(coefs1[neuron], coefs2[neuron])[0, 1]\n\n return corrs","def pearson_r(x, y):\r\n # Compute correlation matrix: corr_mat\r\n \r\n corr_mat=np.corrcoef(x,y)\r\n\r\n # Return entry [0,1]\r\n return corr_mat[0,1]","def get_correlated_data_stats(\n data: np.array\n) -> Dict[str, float]:\n n_features = data.shape[1]\n corr = pd.DataFrame(data).corr()\n corr = np.array(corr)\n\n assert corr.shape[0] == corr.shape[1] == n_features\n\n pair_correlations = []\n for i in range(n_features):\n for j in range(n_features):\n if i > j:\n pair_correlations.append(corr[i, j])\n abs_pair_correlations = [abs(c) for c in pair_correlations]\n\n assert len(pair_correlations) == (n_features * n_features - n_features) / 2\n\n data_corr_stats = {\n \"correlation_min\": np.min(pair_correlations),\n \"correlation_max\": np.max(pair_correlations),\n \"correlation_median\": np.median(pair_correlations),\n \"correlation_mean\": np.mean(pair_correlations),\n \"correlation_std\": np.std(pair_correlations),\n\n \"abs_correlation_min\": np.min(abs_pair_correlations),\n \"abs_correlation_max\": np.max(abs_pair_correlations),\n \"abs_correlation_median\": np.median(abs_pair_correlations),\n \"abs_correlation_mean\": np.mean(abs_pair_correlations),\n \"abs_correlation_std\": np.std(abs_pair_correlations)\n }\n return data_corr_stats","def xcorr(x, y, maxlag=None):\n xl = x.size\n yl = y.size\n if xl != yl:\n raise ValueError('x and y must be equal length')\n\n if maxlag is None:\n maxlag = xl - 1\n else:\n maxlag = int(maxlag)\n if maxlag >= xl or maxlag < 1:\n raise ValueError('maglags must be None or strictly positive')\n\n if xl > 500: # Rough estimate of speed crossover\n c = sig.fftconvolve(x, y[::-1])\n c = c[xl - 1 - maxlag:xl + maxlag]\n else:\n c = np.zeros(2*maxlag + 1)\n for i in range(maxlag+1):\n c[maxlag-i] = np.correlate(x[0:min(xl, yl-i)],\n y[i:i+min(xl, yl-i)])\n c[maxlag+i] = np.correlate(x[i:i+min(xl-i, yl)],\n y[0:min(xl-i, yl)])\n return c"],"string":"[\n \"def pairwise_corr(df1, df2):\\n res = []\\n for i in range(df2.shape[1]):\\n res.append(df1.corrwith(df2.ix[:, i]))\\n res = pd.concat(res, axis=1)\\n res.columns = df2.columns\\n return res\",\n \"def calculate_feature_corr(self):\\n \\n return self.train_data.astype(float).corr(method='kendall')\",\n \"def crosscorr(datax, datay, lag=0):\\n return datax.corr(datay.shift(lag))\",\n \"def df_corrwith(df, other, axis=0, drop=False, method=\\\"pearson\\\"):\\n axis = validate_axis(axis, df)\\n if drop:\\n # TODO implement with df.align(method='inner')\\n raise NotImplementedError(\\\"drop=True not implemented\\\")\\n op = DataFrameCorr(other=other, method=method, axis=axis, drop=drop)\\n return op(df)\",\n \"def df_corr(df, method=\\\"pearson\\\", min_periods=1):\\n op = DataFrameCorr(method=method, min_periods=min_periods)\\n return op(df)\",\n \"def crosscorr(datax, datay, lag=0):\\n return datax.corr(datay.shift(lag))\",\n \"def crosscorrelation(x, y, nlags = 0):\\n return [x.corr(y.shift(lag)) for lag in range(nlags + 1)]\",\n \"def corr(self, **kwargs): # noqa: PR02\\n return DataFrameDefault.register(pandas.DataFrame.corr)(self, **kwargs)\",\n \"def pair_corr(X,\\n weights=None,\\n concat=False,\\n exclude_empty=False,\\n subtract_mean=False,\\n laplace_count=False):\\n\\n assert frozenset(np.unique(X))<=frozenset([-1,0,1])\\n S, N = X.shape\\n \\n if exclude_empty and not laplace_count:\\n # count all nonzero entries for every pair\\n weights = 1/(X!=0).sum(0), 1./( (X!=0).astype(int).T.dot(X!=0)[np.triu_indices(X.shape[1],k=1)] )\\n elif exclude_empty and laplace_count:\\n weights = ( 1/((X!=0).sum(0)+2),\\n 1./( (X!=0).astype(int).T.dot(X!=0)[np.triu_indices(X.shape[1],k=1)] + 4 ) )\\n elif weights is None:\\n # for taking simple average\\n weights = np.ones(len(X))/len(X)\\n elif type(weights) is tuple:\\n assert len(weights[0])==X.shape[1]\\n assert len(weights[1])==(X.shape[1]*(X.shape[1]-1)//2)\\n elif type(weights) is np.ndarray:\\n assert len(weights)==len(X)\\n else:\\n weights = np.zeros(len(X))+weights\\n \\n # Calculate pairwise correlations depending on whether or not exclude_empty was set or not.\\n if type(weights) is tuple:\\n si = X.sum(0) * weights[0]\\n sisj = (X.T.dot(X))[np.triu_indices(X.shape[1],k=1)] * weights[1]\\n else:\\n si = (X*weights[:,None]).sum(0)\\n sisj = (X.T.dot(X*weights[:,None]))[np.triu_indices(X.shape[1],k=1)]\\n\\n if subtract_mean:\\n sisj = np.array([sisj[i]-si[ix[0]]*si[ix[1]] for i,ix in enumerate(combinations(list(range(N)),2))])\\n \\n if concat:\\n return np.concatenate((si,sisj))\\n return si, sisj\",\n \"def get_correlation(df):\\n frame_correlation = df.corr()\\n return frame_correlation\",\n \"def calculate_correlation(df, vars_to_corr, target_var) :\\n\\n\\n mean = df[target_var].mean()\\n sigma = df[target_var].std()\\n\\n correlation = []\\n error = []\\n\\n for j in vars_to_corr :\\n mean_j = df[j].mean()\\n sigma_j = df[j].std()\\n\\n cov = (df[j] - mean_j) * (df[target_var] - mean) / (sigma*sigma_j)\\n correlation.append(cov.mean())\\n error.append(sem(cov))\\n\\n return correlation, error\",\n \"def calculate_correlation(data):\\n pass\",\n \"def correlation(data, method, caption):\\n columns = list(data)\\n coefficients = data.astype(float).corr(method=method)\\n results = []\\n for i in range(len(columns)):\\n for j in range(i + 1, len(columns)):\\n coefficient = coefficients[columns[i]][columns[j]]\\n results.append((\\n abs(coefficient), coefficient,\\n columns[i] + ' x ' + columns[j]))\\n print('# ' + caption + ', ' + method)\\n for result in reversed(sorted(results)):\\n abs_coefficient, coefficient, columns_pair = result\\n print (coefficient, columns_pair)\",\n \"def Corr(x,y):\\n \\n cocoeff1 = np.empty((y.shape[1],y.shape[2]))\\n cocoeff2 = np.empty((y.shape[1],y.shape[2]))\\n for i in xrange(y.shape[1]):\\n for j in xrange(y.shape[2]):\\n cocoeff1[i,j],cocoeff2[i,j] = sts.pearsonr(x[:,i,j],y[:,i,j])\\n \\n print 'Completed: Correlation calculations!'\\n \\n return cocoeff1, cocoeff2\",\n \"def cor(x, y):\\n scaler = TimeSeriesScalerMeanVariance()\\n x_norm = scaler.fit_transform(x)\\n y_norm = scaler.fit_transform(y)\\n pcc = np.mean(x_norm * y_norm) # Pearson correlation coefficients\\n d = np.sqrt(2.0 * (1.0 - pcc + 1e-9)) # correlation-based similarities\\n return np.sum(d)\",\n \"def correlation_test(x1, x2):\\r\\n x = pd.DataFrame([x1, x2]).T.dropna().values\\r\\n return pearsonr(x[:, 0], x[:, 1])\",\n \"def correlation(data):\\n return corrcoef(np.transpose(np.reshape(data, ((data.shape[0] * data.shape[1]), data.shape[2]))))\",\n \"def series_corr(series, other, method=\\\"pearson\\\", min_periods=None):\\n op = DataFrameCorr(other=other, method=method, min_periods=min_periods)\\n return op(series)\",\n \"def corrwith(self, **kwargs): # noqa: PR01\\n return DataFrameDefault.register(pandas.DataFrame.corrwith)(self, **kwargs)\",\n \"def calculate_correlation(self):\\n self.network.index_nodes()\\n self._calculate_dist()\\n pearson_correlation, pearson_pvalue = scipy.stats.pearsonr(self.dist[:,0], self.dist[:,1])\\n spearman_correlation, spearman_pvalue = scipy.stats.spearmanr(self.dist[:,0], self.dist[:,1])\\n return pearson_correlation, pearson_pvalue, spearman_correlation, spearman_pvalue\",\n \"def correlation_and_distribution(pairs: pd.DataFrame, features: list, target: list):\\r\\n # Correlation between all features and predicted binary target\\r\\n ax = sns.heatmap(pairs[features + target].corr(),\\r\\n center=0, annot=True, cmap='RdBu_r')\\r\\n l, r = ax.get_ylim()\\r\\n ax.set_ylim(l + 0.5, r - 0.5)\\r\\n plt.yticks(rotation=0)\\r\\n plt.title('Correlation matrix')\\r\\n plt.show()\\r\\n\\r\\n # Distribution of feature values for two classes\\r\\n similar = pairs[pairs['true_match'] == 1]\\r\\n different = pairs[pairs['true_match'] == 0]\\r\\n\\r\\n for feature in features:\\r\\n plt.figure(figsize=(10, 5))\\r\\n plt.subplot(1, 2, 1)\\r\\n plt.hist(similar[feature], bins=30)\\r\\n plt.title(f'{feature} in similar samples')\\r\\n plt.subplot(1, 2, 2)\\r\\n plt.hist(different[feature], bins=30)\\r\\n plt.title(f'{feature} in different samples')\\r\\n plt.show()\",\n \"def correlateX(X, y, corr=\\\"spearman\\\"):\\n \\n X = np.array(X)\\n y = np.array(y)\\n ## Force... just in case\\n \\n checkX(X)\\n\\n if corr == \\\"pearson\\\":\\n corrf = pearsonr\\n elif corr == \\\"spearman\\\":\\n corrf = spearmanr\\n else:\\n raise ValueError(\\\"stat was not valid.\\\")\\n \\n corrs = []\\n ps = []\\n for jj in range(X.shape[1]):\\n r, p = corrf(X[:,jj], y)\\n corrs.append(r)\\n ps.append(p)\\n \\n return np.array(corrs), np.array(ps)\",\n \"def crosscorr(x, y, **kwargs):\\r\\n # just make the same computation as the crosscovariance,\\r\\n # but without subtracting the mean\\r\\n kwargs['debias'] = False\\r\\n rxy = crosscov(x, y, **kwargs)\\r\\n return rxy\",\n \"def pairwise_correlations(self, views: Iterable[np.ndarray], **kwargs):\\n transformed_views = self.transform(views, **kwargs)\\n all_corrs = []\\n for x, y in itertools.product(transformed_views, repeat=2):\\n all_corrs.append(\\n np.diag(\\n np.corrcoef(x.T, y.T)[\\n : self.latent_dimensions, self.latent_dimensions :\\n ]\\n )\\n )\\n try:\\n all_corrs = np.array(all_corrs).reshape(\\n (self.n_views_, self.n_views_, self.latent_dimensions)\\n )\\n except:\\n print()\\n return all_corrs\",\n \"def determine_correlation(var1,var2):\\n v1 = np.array(var1)\\n v2 = np.array(var2)\\n mat = np.c_[(v1,v2)]# np.vstack((v1,v2)) #\\n corr = np.corrcoef(mat.T)\\n return corr[0][1]\",\n \"def corr(A,B):\\n\\n # Rowwise mean of input arrays & subtract from input arrays themeselves\\n A_mA = A - A.mean(1)[:,None]\\n B_mB = B - B.mean(1)[:,None]\\n\\n # Sum of squares across rows\\n ssA = (A_mA**2).sum(1);\\n ssB = (B_mB**2).sum(1);\\n\\n # Finally get corr coeff\\n return np.dot(A_mA,B_mB.T)/np.sqrt(np.dot(ssA[:,None],ssB[None]))\",\n \"def corr_with(self, other):\\n return self.data.corrwith(other)\",\n \"def cross_correlation(values1, values2, lags=100):\\n lags, corr, line, x = pl.xcorr( values1, values2, maxlags=lags, usevlines=False, marker=None)\\n return lags, corr\",\n \"def correlation(x_items, y_items):\\r\\n return correlation_test(x_items, y_items, method='pearson', tails=None,\\r\\n permutations=0)[:2]\",\n \"def corr(arr1, arr2):\\n\\n\\n X = []\\n Y = []\\n for index in range(len(arr1)):\\n if arr1[index] == None or arr2[index] == None:\\n continue\\n X.append(arr1[index])\\n Y.append(arr2[index])\\n\\n\\n r = np.corrcoef(X, Y)[0,1]\\n f = 0.5*np.log((1+r)/(1-r))\\n se = 1/np.sqrt(len(X)-3)\\n ucl = f + 2*se\\n lcl = f - 2*se\\n\\n lcl = (np.exp(2*lcl) - 1) / (np.exp(2*lcl) + 1)\\n ucl = (np.exp(2*ucl) - 1) / (np.exp(2*ucl) + 1)\\n\\n return r,lcl,ucl\",\n \"def _pearson_correlation_coeff(x_data, y_data):\\n reg = linregress(x_data, y_data)\\n return reg.rvalue\",\n \"def crosscorr(datax, datay, lag=0, wrap=False):\\n if wrap:\\n shiftedy = datay.shift(lag)\\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\\n return datax.corr(shiftedy)\\n else: \\n return datax.corr(datay.shift(lag))\",\n \"def mcorr(x,y):\\n return ((np.ma.dot(x,y) / (x.shape[0] - 1) / y.std(axis=0)) / x.std())\",\n \"def pairwise_correlation_difference(self):\\r\\n\\r\\n real_cat, synth_cat = self.to_cat(self.origdst, self.synthdst)\\r\\n\\r\\n real_cat_dem = self.get_demographics(real_cat)\\r\\n synth_cat_dem = self.get_demographics(synth_cat)\\r\\n\\r\\n corr_real_obj = associations(real_cat_dem, theil_u=True, bias_correction=False, plot=False)\\r\\n corr_synth_obj = associations(synth_cat_dem, theil_u=True, bias_correction=False, plot=False)\\r\\n\\r\\n corr_real = corr_real_obj['corr']\\r\\n corr_rand = corr_synth_obj['corr']\\r\\n\\r\\n substract_m = np.subtract(corr_real, corr_rand)\\r\\n prwcrdst = LA.norm(substract_m)\\r\\n\\r\\n return prwcrdst, substract_m\",\n \"def crosscorr(datax, datay, lag=0, wrap=False):\\n if wrap:\\n shiftedy = datay.shift(lag)\\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\\n return datax.corr(shiftedy)\\n else:\\n return datax.corr(datay.shift(lag))\",\n \"def crosscorr(datax, datay, lag=0, wrap=False):\\n if wrap:\\n shiftedy = datay.shift(lag)\\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\\n return datax.corr(shiftedy)\\n else:\\n return datax.corr(datay.shift(lag))\",\n \"def crosscorr(datax, datay, lag=0, wrap=False):\\r\\n if wrap:\\r\\n shiftedy = datay.shift(lag)\\r\\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\\r\\n return datax.corr(shiftedy)\\r\\n else: \\r\\n return datax.corr(datay.shift(lag))\",\n \"def cross_correlation(arr1, arr2):\\n faxes = lambda x: tuple(np.arange(x.ndim - 1) + 1)\\n\\n return pipe(\\n arr1,\\n dafftn(axes=faxes(arr1)),\\n lambda x: daconj(x) * dafftn(arr2, axes=faxes(arr2)),\\n daifftn(axes=faxes(arr1)),\\n dafftshift(axes=faxes(arr1)),\\n lambda x: x.real / arr1[0].size,\\n )\",\n \"def compute_correlations(struc_df, option, gamma, alpha):\\n n_states = len(np.unique(struc_df.objnum))\\n nodes = network.temp_node_info()\\n adjacency = network.adjacency_mat(nodes)\\n L = compute_limit_matrix(0.5, adjacency, n_states)\\n L_vector = L.flatten()\\n M = learn_sr(struc_df, gamma, alpha)\\n M = M[2, 6]\\n M_vector = M.flatten()\\n\\n if option == \\\"norm\\\":\\n print(\\\"Norm of L - M: \\\")\\n print(la.norm(L_vector - M_vector, np.inf))\\n\\n if option == \\\"correlation\\\":\\n print(\\\"Correlation of L, M: \\\")\\n print(np.dot(L_vector, M_vector) /\\n (la.norm(L_vector) * la.norm(M_vector)))\",\n \"def crosscorr(datax, datay, lag=0, wrap=False):\\n \\n if wrap:\\n shiftedy = datay.shift(lag)\\n shiftedy.iloc[:lag] = datay.iloc[-lag:].values\\n return datax.corr(shiftedy)\\n else:\\n return datax.corr(datay.shift(lag))\",\n \"def get_correlation(outcome_vectors, s_hat):\\n\\n outcome_vectors2 = np.asfortranarray(outcome_vectors.data)\\n ldl_shat = np.asfortranarray(s_hat)\\n return fast_corr.manual_corr(outcome_vectors2.T, ldl_shat.T)\",\n \"def _compute_correlations(self, data):\\n mappings = self.mappings_\\n n_channels, n_times = data.shape\\n\\n # get the predictions\\n y_pred = data.T.dot(mappings.T)\\n y_pred = y_pred.reshape((n_times, len(self.picks),\\n self.n_resample), order='F')\\n # pool them using median\\n # XXX: weird that original implementation sorts and takes middle value.\\n # Isn't really the median if n_resample even\\n y_pred = np.median(y_pred, axis=-1)\\n # compute correlation\\n num = np.sum(data.T * y_pred, axis=0)\\n denom = (np.sqrt(np.sum(data.T ** 2, axis=0)) *\\n np.sqrt(np.sum(y_pred ** 2, axis=0)))\\n\\n corr = num / denom\\n return corr\",\n \"def CORR(A: pd.DataFrame, B: pd.DataFrame, n) -> pd.DataFrame:\\r\\n A = A.unstack()\\r\\n B = B.unstack()\\r\\n res = A.rolling(n).corr(B)\\r\\n return res.stack()\",\n \"def custom_corrcoef(X, Y=None):\\n if Y is None:\\n Y = X\\n \\n if X.shape[0] != Y.shape[0]:\\n raise Exception(\\\"X and Y must have the same number of rows.\\\")\\n \\n X = X.astype(float)\\n Y = Y.astype(float)\\n \\n X -= X.mean(axis=0)[np.newaxis,...]\\n Y -= Y.mean(axis=0)\\n \\n xx = np.sum(X**2, axis=0)\\n yy = np.sum(Y**2, axis=0)\\n \\n r = np.dot(X.T, Y)/np.sqrt(np.multiply.outer(xx,yy))\\n \\n return r\",\n \"def calculate_correlation_coefficient(column1: pd.Series, column2: pd.Series) -> np.float64:\\n\\n corr = column1.corr(column2)\\n return corr\",\n \"def test_compute_correlation_paired(self):\\r\\n # Verified using R's cor.test function.\\r\\n exp = ((0.90243902439024193, 0.013812916237431808, 0.03,\\r\\n (0.33958335414859975, 0.98938788428012969)), None)\\r\\n \\r\\n np.random.seed(self.value_for_seed)\\r\\n obs = _compute_correlation(self.taxa_summary_paired1,\\r\\n self.taxa_summary_paired2, 'paired', 'pearson', 'two-sided',\\r\\n 999, 0.95)\\r\\n self.compare_multiple_level_array(obs, exp)\",\n \"def correlation(self, other):\\n dates=self.get_dates(other.get_dates())\\n #print(len(self.get_values(dates)))\\n #print(len(other.get_values(dates)))\\n #print(self.get_values(dates))\\n r,p=stats.pearsonr(self.get_values(dates), other.get_values(dates))\\n return r\",\n \"def corr(self) -> 'DataFrame':\\n if self._is_string():\\n raise TypeError('DataFrame consists only of strings. Must have int, float, '\\n 'or bool columns')\\n\\n x: ndarray = self._values_number()\\n if x.dtype.kind == 'i':\\n x0: ndarray = x[0]\\n x_diff: ndarray = x - x0\\n Exy: ndarray = (x_diff.T @ x_diff)\\n Ex: ndarray = x_diff.sum(0)[np.newaxis, :]\\n ExEy: ndarray = Ex.T @ Ex\\n counts: Union[int, ndarray] = len(x)\\n Ex2: ndarray = (x_diff ** 2).sum(0)\\n\\n else:\\n x0 = _math.get_first_non_nan(x)\\n x_diff = x - x0\\n x_not_nan: ndarray = (~np.isnan(x)).astype(int)\\n\\n # get index of first non nan too and check for nan here\\n x_diff_0: ndarray = np.nan_to_num(x_diff)\\n counts = (x_not_nan.T @ x_not_nan)\\n Exy = (x_diff_0.T @ x_diff_0)\\n Ex = (x_diff_0.T @ x_not_nan)\\n ExEy = Ex * Ex.T\\n Ex2 = (x_diff_0.T ** 2 @ x_not_nan)\\n\\n with np.errstate(invalid='ignore'):\\n cov: ndarray = (Exy - ExEy / counts) / (counts - 1)\\n stdx: ndarray = (Ex2 - Ex ** 2 / counts) / (counts - 1)\\n stdxy: ndarray = stdx * stdx.T\\n corr: ndarray = cov / np.sqrt(stdxy)\\n\\n new_data: Dict[str, ndarray] = {'f': np.asfortranarray(corr)}\\n new_column_info: ColInfoT = {'Column Name': utils.Column('S', 0, 0)}\\n new_columns: ndarray = np.empty(x.shape[1] + 1, dtype='O')\\n new_columns[0] = 'Column Name'\\n\\n i: int = 0\\n for col, dtype, loc in self._col_info_iter(): # type: str, str, int\\n if dtype not in 'ifb':\\n continue\\n new_column_info[col] = utils.Column('f', i, i + 1)\\n new_columns[i + 1] = col\\n i += 1\\n new_data['S'] = np.asfortranarray(new_columns[1:])[:, np.newaxis]\\n return self._construct_from_new(new_data, new_column_info,\\n np.asarray(new_columns, dtype='O'))\",\n \"def crosscov(x, y, axis=-1, all_lags=False, debias=True, normalize=True,\\n\\t\\t\\t corr=False):\\n\\tif x.shape[ axis ] != y.shape[ axis ]:\\n\\t\\traise ValueError(\\n\\t\\t\\t\\t'crosscov() only works on same-length sequences for now'\\n\\t\\t)\\n\\tif debias:\\n\\t\\tx = _remove_bias(x, axis)\\n\\t\\ty = _remove_bias(y, axis)\\n\\tslicing = [ slice(d) for d in x.shape ]\\n\\tslicing[ axis ] = slice(None, None, -1)\\n\\tcxy = fftconvolve(x, y[ tuple(slicing) ].conj(), axis=axis, mode='full')\\n\\tN = x.shape[ axis ]\\n\\tif normalize:\\n\\t\\tcxy /= N\\n\\tif all_lags:\\n\\t\\treturn cxy\\n\\tslicing[ axis ] = slice(N - 1, 2 * N - 1)\\n\\treturn cxy[ tuple(slicing) ]\",\n \"def corr_iter(df, method='spearman', multi='median', TH=1, normalize=False, normalize_kw=None, **kwargs):\\n # Normalize\\n if normalize_kw is None:\\n normalize_kw = {}\\n\\n if normalize:\\n _df = normalize(df, **normalize_kw)\\n else:\\n _df = df.copy()\\n\\n columns = _df.columns\\n\\n # Filter out low expressing genes\\n mask = _df.sum(axis = 1) > TH\\n _df = _df[mask]\\n\\n # Either compare to median or pairwise.\\n if multi == 'median':\\n _df['med'] = _df.median(axis=1)\\n combos = product(columns, ['med'])\\n else:\\n combos = combinations(columns, 2)\\n\\n # Which correlation to calculate\\n if method =='spearman':\\n func = scipy.stats.spearmanr\\n elif method == 'pearson':\\n func = scipy.stats.pearsonr\\n\\n for x1, x2 in combos:\\n score = func(_df[x1], _df[x2])[0]\\n yield '{}:{}'.format(x1, x2), score\",\n \"def study_correlation(data: np.array, labels: np.array)->None:\\n n_rows = np.size(data, 0)\\n n_cols = np.size(data, 1)\\n\\n fig, ax = plt.subplots(n_cols, n_cols)\\n\\n for i in range(n_cols):\\n for j in range(n_cols):\\n if i != j: ax[i][j].scatter(data[:,j], data[:,i], c = labels)\\n else: ax[i][j].annotate(\\\"series \\\" + str(i), (0.5, 0.5), xycoords = 'axes fraction', ha = \\\"center\\\", va = \\\"center\\\")\\n\\n if i < n_cols-1: ax[i][j].xaxis.set_visible(False)\\n if j > 0: ax[i][j].yaxis.set_visible(False)\\n\\n ax[-1][-1].set_xlim(ax[0][-1].get_xlim())\\n ax[0][0].set_ylim(ax[0][1].get_ylim())\\n\\n plt.show()\\n plt.close()\\n\\n #print(\\\"Correlation between features {} and {} is {}\\\".format(1, 2, 3))\",\n \"def run_r_corr(df, corr_type='spearman', p_correction='BH'):\\r\\n num_cols = len(df.columns.values)\\r\\n r_dataframe = pandas2ri.py2ri(df)\\r\\n r_as = r['as.matrix']\\r\\n rcorr = r['rcorr'] \\r\\n r_p_adjust = r['p.adjust']\\r\\n result = rcorr(r_as(r_dataframe), type=corr_type)\\r\\n rho = result[0]\\r\\n n = result[1]\\r\\n p = result[2]\\r\\n \\r\\n if p_correction is not None:\\r\\n p = r_p_adjust(p, p_correction)\\r\\n r_corrs = pandas2ri.ri2py(rho)\\r\\n r_p_vals = pandas2ri.ri2py(p)\\r\\n r_counts = pandas2ri.ri2py(n)\\r\\n r_p_vals = np.reshape(r_p_vals, (num_cols,num_cols))\\r\\n return r_corrs, r_counts, r_p_vals\",\n \"def correlation(result, reference):\\n \\n r = np.corrcoef(result, reference)[0,1]\\n \\n return r\",\n \"def fast_corr(df, col_name):\\n\\n if not isinstance(df, pd.DataFrame):\\n raise TypeError(\\\"The type of the input data must be dataframe.\\\")\\n\\n if not isinstance(col_name, list):\\n raise TypeError(\\\"The col_name must be list.\\\")\\n\\n if all(isinstance(item, str) for item in col_name) is False and all(\\n isinstance(item, int) for item in col_name) is False:\\n raise ValueError(\\n \\\"The col_name must be a list of strings or a list of integers.\\\")\\n\\n if len(col_name) < 2:\\n raise ValueError(\\n \\\"At least two columns must be selected for correlation analysis.\\\")\\n\\n if all(isinstance(item, str) for item in col_name) is True and all(\\n elem in df.columns.to_list() for elem in col_name) is False:\\n raise ValueError(\\\"The column names were not found.\\\")\\n\\n if all(isinstance(item, int) for item in col_name) is True and max(\\n col_name) > (df.shape[1] - 1):\\n raise ValueError(\\\"The column indexes were out of range.\\\")\\n\\n if all(isinstance(item, str) for item in col_name):\\n data = df.loc[:, col_name]\\n else:\\n data = df.iloc[:, col_name]\\n\\n data2 = data._get_numeric_data()\\n rm_n = data.shape[1] - data2.shape[1]\\n print(\\\"Removed\\\", rm_n, \\\"non-numberical columns from your selected columns\\\")\\n\\n sns.set(style=\\\"white\\\")\\n corr = data2.corr()\\n mask = np.triu(np.ones_like(corr, dtype=np.bool))\\n f, ax = plt.subplots(figsize=(9, 11))\\n ax.set_title('Correlation Matrix', size=20)\\n ax.tick_params(axis='x', labelsize=15)\\n ax.tick_params(axis='y', labelsize=15)\\n\\n cmap = sns.diverging_palette(220, 20, as_cmap=True)\\n p = sns.heatmap(corr, mask=mask, cmap=cmap, vmin=-1, vmax=1, center=0,\\n square=True, linewidths=.5, cbar_kws={\\\"shrink\\\": .5})\\n p.set_yticklabels(p.get_yticklabels(), rotation=360)\\n return p\",\n \"def corrcoef(self):\\r\\n return np.corrcoef(self.input.data)\",\n \"def correlation(x: pd.Series, y: pd.Series, d: int) -> pd.Series:\\n # todo multiindex\\n if isinstance(d, float):\\n d = math.floor(d)\\n if isinstance(x.index, pd.MultiIndex):\\n x.name = 'x'\\n y.name = 'y'\\n j = x.to_frame().join(y.to_frame())\\n res = []\\n\\n for g in j.groupby(level=1):\\n\\n a = g[1][x.name]\\n b = g[1][y.name]\\n r = a.rolling(window=d).corr(b)\\n res.append(r)\\n return pd.concat(res).reorder_levels([1, 0])\\n else:\\n return x.rolling(window=d).corr(y)\",\n \"def cross_correlation(field1, field2):\\n array_len = len(field1)\\n # Take the index of the largest value in the array of correlation values calculated via a full convolve\\n # cross correlation.\\n arg_max = np.argmax((np.correlate([float(i) for i in field1], [float(i) for i in field2], mode='full')))\\n # Map the index of the largest correlation value to that of the season lag between metrics\\n return -(int(np.arange(-array_len+1, array_len)[arg_max]))\",\n \"def show_correlations(regressors, features, targets):\\r\\n \\r\\n def mae(v1, v2):\\r\\n #\\\"\\\"\\\"Return the MAE (mean absolute error) of v1 & v2.\\\"\\\"\\\"\\r\\n return mean(abs(v1 - v2))\\r\\n\\t\\r\\n from sklearn.metrics import matthews_corrcoef\\r\\n from scipy.stats import pearsonr\\r\\n\\t\\r\\n for regressor in regressors:\\r\\n regressor['preds'] = regressor['regressor'].predict(features)\\r\\n \\r\\n print('=============== MAE Comparison =================')\\r\\n for regressor in regressors:\\r\\n print('{} : {}'.format(regressor['name'], mae(regressor['preds'], targets)))\\r\\n \\r\\n print(\\\"=============== Pearson's Correlation Comparison =================\\\")\\r\\n for regressor in regressors:\\r\\n print('{} : {}'.format(regressor['name'], pearsonr(regressor['preds'], targets)))\",\n \"def corrcoef(X, Y, shape, use_full_fft=False):\\n if len(X.shape) != 2:\\n raise ValueError(\\\"X is not a two-dimensional array\\\")\\n\\n if len(Y.shape) != 2:\\n raise ValueError(\\\"Y is not a two-dimensional array\\\")\\n\\n if X.shape != Y.shape:\\n raise ValueError(\\n \\\"dimension mismatch between X and Y: \\\"\\n + \\\"X.shape=%d,%d , \\\" % (X.shape[0], X.shape[1])\\n + \\\"Y.shape=%d,%d\\\" % (Y.shape[0], Y.shape[1])\\n )\\n\\n n = np.real(np.sum(X * np.conj(Y))) - np.real(X[0, 0] * Y[0, 0])\\n d1 = np.sum(np.abs(X) ** 2) - np.real(X[0, 0]) ** 2\\n d2 = np.sum(np.abs(Y) ** 2) - np.real(Y[0, 0]) ** 2\\n\\n if not use_full_fft:\\n if shape[1] % 2 == 1:\\n n += np.real(np.sum(X[:, 1:] * np.conj(Y[:, 1:])))\\n d1 += np.sum(np.abs(X[:, 1:]) ** 2)\\n d2 += np.sum(np.abs(Y[:, 1:]) ** 2)\\n else:\\n n += np.real(np.sum(X[:, 1:-1] * np.conj(Y[:, 1:-1])))\\n d1 += np.sum(np.abs(X[:, 1:-1]) ** 2)\\n d2 += np.sum(np.abs(Y[:, 1:-1]) ** 2)\\n\\n return n / np.sqrt(d1 * d2)\",\n \"def corr(a, b):\\n ma = np.mean(a)\\n mb = np.mean(b)\\n\\n a_ = a - ma\\n b_ = b - mb\\n\\n norma = np.sqrt(np.sum(a_ ** 2, axis=0))\\n normb = np.sqrt(np.sum(b_ ** 2, axis=0))\\n\\n norma[norma < TOLERANCE] = 1.0\\n normb[normb < TOLERANCE] = 1.0\\n\\n a_ *= 1.0 / norma\\n b_ *= 1.0 / normb\\n\\n ip = np.dot(a_.T, b_)\\n\\n if ip.shape == (1, 1):\\n return ip[0, 0]\\n else:\\n return ip\",\n \"def r2(preds, actual):\\n preds = np.reshape(preds, (-1,))\\n r = np.corrcoef(preds, actual)[0,1]\\n rsq = r ** 2\\n return r,rsq\",\n \"def correlations_multiple(data, correlations, periodic_boundary=True, cutoff=None):\\n\\n return pipe(\\n range(data.shape[-1]),\\n map_(lambda x: (0, x)),\\n lambda x: correlations if correlations else x,\\n map_(\\n lambda x: two_point_stats(\\n data[..., x[0]],\\n data[..., x[1]],\\n periodic_boundary=periodic_boundary,\\n cutoff=cutoff,\\n )\\n ),\\n list,\\n lambda x: da.stack(x, axis=-1),\\n lambda x: da.rechunk(x, x.chunks[:-1] + (-1,)),\\n )\",\n \"def compute_clf_based_correlation_score(stats, columns, col_name):\\n full_col_data = columns[col_name]\\n\\n dt_clf = DecisionTreeClassifier()\\n\\n other_feature_names = []\\n other_features = []\\n for other_col_name in columns.columns:\\n if other_col_name == col_name:\\n continue\\n\\n other_feature_names.append(other_col_name)\\n le = LabelEncoder()\\n _stringified_col = list(map(str,columns[other_col_name]))\\n le.fit(_stringified_col)\\n other_features.append(list(le.transform(_stringified_col)))\\n\\n other_features_t = np.array(other_features, dtype=object).transpose()\\n\\n le = LabelEncoder()\\n _stringified_col = list(map(str,full_col_data))\\n le.fit(_stringified_col)\\n y = le.transform(_stringified_col)\\n dt_clf.fit(other_features_t,y)\\n prediction_score = dt_clf.score(other_features_t,y)\\n corr_scores = list(dt_clf.feature_importances_)\\n highest_correlated_column = max(corr_scores)\\n return {\\n 'correlation_score': round(10 * (1 - prediction_score * highest_correlated_column))\\n ,'highest_correlation': max(corr_scores)\\n ,'most_correlated_column': other_feature_names[corr_scores.index(max(corr_scores))]\\n ,'similarity_score_description':\\\"\\\"\\\"\\n A high value for this score means that two of your columns are highly similar. This is done by trying to predict one column using the other via a simple DT.\\n \\\"\\\"\\\"\\n }\",\n \"def concordance_correlation_coefficient(y_true, y_pred,\\n sample_weight=None,\\n multioutput='uniform_average'):\\n cor=np.corrcoef(y_true,y_pred)[0][1]\\n \\n mean_true=np.mean(y_true)\\n mean_pred=np.mean(y_pred)\\n \\n var_true=np.var(y_true)\\n var_pred=np.var(y_pred)\\n \\n sd_true=np.std(y_true)\\n sd_pred=np.std(y_pred)\\n \\n numerator=2*cor*sd_true*sd_pred\\n \\n denominator=var_true+var_pred+(mean_true-mean_pred)**2\\n\\n return numerator/denominator\",\n \"def _compute_corr(fmap):\\n fmap = fmap.view(fmap.size(0), fmap.size(1), -1)\\n fmap = nn.functional.normalize(fmap, dim=2, eps=1e-08)\\n corr = torch.bmm(fmap.permute(0, 2, 1), fmap)\\n return corr.view(corr.size(0), -1)\",\n \"def correlation_distribution(df: pd.DataFrame):\\n # Correlation heatmap\\n ax = sns.heatmap(df.corr(),\\n center=0, annot=True, cmap='RdBu_r')\\n l, r = ax.get_ylim()\\n ax.set_ylim(l + 0.5, r - 0.5)\\n plt.yticks(rotation=0)\\n plt.title('Correlation matrix')\\n plt.show()\\n\\n # Individual correlations between features and the target\\n for feature in features:\\n print(f'{feature}: {df[feature].min()} - {df[feature].max()}, '\\n f'mean = {df[feature].mean()}, median = {df[feature].median()}')\\n plt.figure(figsize=(14, 5))\\n plt.subplot(1, 2, 1)\\n plt.scatter(df[feature], df[target])\\n plt.xlabel(feature)\\n plt.ylabel(target)\\n plt.title(f'{feature} correlation')\\n plt.subplot(1, 2, 2)\\n plt.hist(df[feature], bins=20)\\n plt.title(f'{feature} distribution')\\n plt.show()\\n\\n # Distribution of target values and standard errors\\n for par in ('target', 'standard_error'):\\n print(f'{par}: {df[par].min()} - {df[par].max()}, mean = {df[par].mean()}, median = {df[par].median()}')\\n plt.hist(df[par], bins=20)\\n plt.title(f'{par} distribution')\\n plt.show()\",\n \"def compute_correlations(dataset,\\n encode=False,\\n columns_nominal='auto',\\n columns_dichotomous='auto',\\n columns_ordinal=None,\\n mark_columns=False,\\n theils=False,\\n clustering=False,\\n bias_correction=True,\\n nan_strategy=_REPLACE,\\n nan_replace_value=_DEFAULT_REPLACE_VALUE):\\n dataset = convert(dataset, 'dataframe') # TODO implement encoding\\n\\n if nan_strategy == _REPLACE:\\n dataset.fillna(nan_replace_value, inplace=True)\\n elif nan_strategy == _DROP_SAMPLES:\\n dataset.dropna(axis=0, inplace=True)\\n elif nan_strategy == _DROP_FEATURES:\\n dataset.dropna(axis=1, inplace=True)\\n\\n columns = dataset.columns\\n\\n if columns_nominal is None:\\n columns_nominal = list()\\n elif columns_nominal == 'all':\\n columns_nominal = columns\\n elif columns_nominal == 'auto':\\n columns_nominal = identify_nominal_columns(dataset)\\n\\n if columns_dichotomous is None:\\n columns_dichotomous = list()\\n elif columns_dichotomous == 'all':\\n columns_dichotomous = columns\\n elif columns_dichotomous == 'auto':\\n columns_dichotomous = identify_dichotomous_columns(dataset, columns_nominal)\\n\\n if columns_ordinal is None:\\n columns_ordinal = list()\\n elif columns_ordinal == 'all':\\n columns_ordinal = columns\\n elif columns_ordinal == 'auto':\\n columns_ordinal = identify_ordinal_columns(dataset, columns_nominal, columns_dichotomous)\\n\\n corr = pd.DataFrame(index=columns, columns=columns)\\n sign = pd.DataFrame(index=columns, columns=columns)\\n coef = pd.DataFrame(index=columns, columns=columns)\\n\\n columns_single_value = []\\n\\n inf_nan_corr = pd.DataFrame(data=np.zeros_like(corr),\\n columns=columns,\\n index=columns)\\n\\n inf_nan_sign = pd.DataFrame(data=np.zeros_like(corr),\\n columns=columns,\\n index=columns)\\n\\n for c in columns:\\n # Test if column only contains single value\\n if dataset[c].unique().size == 1:\\n # Column only contains a single value, prepare for no calculation to be done\\n columns_single_value.append(c)\\n\\n for i in range(0, len(columns)):\\n\\n if columns[i] in columns_single_value:\\n # If column only contains a single value, not correlation calculation necessary\\n corr.loc[:, columns[i]] = 0.0\\n corr.loc[columns[i], :] = 0.0\\n continue\\n\\n for j in range(i, len(columns)):\\n\\n if columns[j] in columns_single_value:\\n continue\\n\\n elif i == j:\\n # Correlation to itself is always 1.0\\n corr.loc[columns[i], columns[j]] = 1.0\\n sign.loc[columns[i], columns[j]] = _SIGN_NAN\\n inf_nan_sign.loc[columns[i], columns[j]] = _inf_nan_str(_SIGN_NAN)\\n\\n else:\\n # print('Processing ' + columns[i] + ' and ' + columns[j])\\n if columns[i] in columns_nominal or columns[i] in columns_dichotomous or columns[i] in columns_ordinal:\\n # i is categorical\\n if columns[j] in columns_nominal or columns[j] in columns_dichotomous or columns[\\n j] in columns_ordinal:\\n # i and j are categorical\\n if theils:\\n # Because Theil's U is asymmetrical, calculate both directions separately\\n ij, p, c = theils_u(dataset[columns[i]], dataset[columns[j]]) # TODO handle two p values\\n ji, p, c = theils_u(dataset[columns[j]], dataset[columns[i]]) # TODO handle two p values\\n else:\\n cell, p, c = cramers_v(dataset[columns[i]], dataset[columns[j]],\\n bias_correction=bias_correction)\\n ij = cell\\n ji = cell\\n else:\\n # i is categorical, j is continuous\\n if columns[i] in columns_ordinal:\\n # i is ordinal, j is continuous\\n cell, p, c = kendall(dataset[columns[j]], dataset[columns[i]])\\n elif columns[i] in columns_dichotomous:\\n # i is dichotomous, j is continuous\\n cell, p, c = point_biserial(dataset[columns[j]], dataset[columns[i]])\\n else:\\n # i is nominal, j is continuous\\n cell, p, c = eta(dataset[columns[j]], dataset[columns[i]])\\n\\n ij = cell\\n ji = cell\\n\\n elif columns[j] in columns_nominal or columns[j] in columns_dichotomous or columns[\\n j] in columns_ordinal:\\n # j is categorical, i is continuous\\n if columns[j] in columns_ordinal:\\n # j is ordinal, i is continuous\\n cell, p, c = kendall(dataset[columns[i]], dataset[columns[j]])\\n\\n elif columns[j] in columns_dichotomous:\\n # j is dichotomous, i is continuous\\n cell, p, c = point_biserial(dataset[columns[i]], dataset[columns[j]])\\n else:\\n # j is nominal, i is continuous\\n cell, p, c = eta(dataset[columns[i]], dataset[columns[j]])\\n\\n ij = cell\\n ji = cell\\n\\n else:\\n # i and j are continuous\\n assert columns[i] not in columns_nominal or columns[i] not in columns_dichotomous or columns[\\n i] not in columns_ordinal, columns[i] + ' should not be here'\\n assert columns[j] not in columns_nominal or columns[j] not in columns_dichotomous or columns[\\n j] not in columns_ordinal, columns[j] + ' should not be here'\\n cell, p, c = pearsons(dataset[columns[i]], dataset[columns[j]])\\n\\n ij = cell\\n ji = cell\\n\\n corr.loc[columns[i], columns[j]] = round(ij, 2) if not np.isnan(ij) and abs(ij) < np.inf else 0.0\\n corr.loc[columns[j], columns[i]] = round(ji, 2) if not np.isnan(ji) and abs(ji) < np.inf else 0.0\\n sign.loc[columns[i], columns[j]] = round(p, 4) if not np.isnan(p) and abs(p) < np.inf else _SIGN_NAN\\n sign.loc[columns[j], columns[i]] = round(p, 4) if not np.isnan(p) and abs(p) < np.inf else _SIGN_NAN\\n coef.loc[columns[i], columns[j]] = c\\n coef.loc[columns[j], columns[i]] = c\\n inf_nan_corr.loc[columns[i], columns[j]] = _inf_nan_str(ij)\\n inf_nan_corr.loc[columns[j], columns[i]] = _inf_nan_str(ji)\\n inf_nan_sign.loc[columns[i], columns[j]] = _inf_nan_str(p)\\n inf_nan_sign.loc[columns[j], columns[i]] = _inf_nan_str(p)\\n\\n corr.fillna(value=np.nan, inplace=True)\\n sign.fillna(value=np.nan, inplace=True)\\n\\n if mark_columns:\\n marked_columns = [\\n '{} (nom)'.format(col)\\n if col in columns_nominal else '{} (con)'.format(col)\\n for col in columns\\n ]\\n corr.columns = marked_columns\\n corr.index = marked_columns\\n inf_nan_corr.columns = marked_columns\\n inf_nan_corr.index = marked_columns\\n\\n if clustering:\\n corr, p = cluster_correlations(corr)\\n columns = corr.columns\\n\\n return {\\n 'correlation': corr,\\n 'significance': sign,\\n 'coefficient': coef,\\n 'columns': columns,\\n 'columns_nominal': columns_nominal,\\n 'columns_dichotomous': columns_dichotomous,\\n 'columns_ordinal': columns_ordinal,\\n 'inf_nan_corr': inf_nan_corr,\\n 'inf_nan_sign': inf_nan_sign,\\n 'columns_single_value': columns_single_value}\",\n \"def associations(dataset, nominal_columns=None, mark_columns=False, theil_u=False, plot=True,\\n return_results = False, **kwargs):\\n\\n dataset = convert(dataset, 'dataframe')\\n columns = dataset.columns\\n if nominal_columns is None:\\n nominal_columns = list()\\n elif nominal_columns == 'all':\\n nominal_columns = columns\\n corr = pd.DataFrame(index=columns, columns=columns)\\n for i in range(0,len(columns)):\\n for j in range(i,len(columns)):\\n if i == j:\\n corr[columns[i]][columns[j]] = 1.0\\n else:\\n if columns[i] in nominal_columns:\\n if columns[j] in nominal_columns:\\n if theil_u:\\n corr[columns[j]][columns[i]] = theils_u(dataset[columns[i]],dataset[columns[j]])\\n corr[columns[i]][columns[j]] = theils_u(dataset[columns[j]],dataset[columns[i]])\\n else:\\n cell = cramers_v(dataset[columns[i]],dataset[columns[j]])\\n corr[columns[i]][columns[j]] = cell\\n corr[columns[j]][columns[i]] = cell\\n else:\\n cell = correlation_ratio(dataset[columns[i]], dataset[columns[j]])\\n corr[columns[i]][columns[j]] = cell\\n corr[columns[j]][columns[i]] = cell\\n else:\\n if columns[j] in nominal_columns:\\n cell = correlation_ratio(dataset[columns[j]], dataset[columns[i]])\\n corr[columns[i]][columns[j]] = cell\\n corr[columns[j]][columns[i]] = cell\\n else:\\n cell, _ = ss.pearsonr(dataset[columns[i]], dataset[columns[j]])\\n corr[columns[i]][columns[j]] = cell\\n corr[columns[j]][columns[i]] = cell\\n corr.fillna(value=np.nan, inplace=True)\\n if mark_columns:\\n marked_columns = ['{} (nom)'.format(col) if col in nominal_columns else '{} (con)'.format(col) for col in columns]\\n corr.columns = marked_columns\\n corr.index = marked_columns\\n if plot:\\n plt.figure(figsize=(20,20))#kwargs.get('figsize',None))\\n sns.heatmap(corr, annot=kwargs.get('annot',True), fmt=kwargs.get('fmt','.2f'), cmap='coolwarm')\\n plt.show()\\n if return_results:\\n return corr\",\n \"def distcorrXY(X, Y):\\n X = np.atleast_1d(X)\\n Y = np.atleast_1d(Y)\\n if np.prod(X.shape) == len(X):\\n X = X[:, None]\\n if np.prod(Y.shape) == len(Y):\\n Y = Y[:, None]\\n X = np.atleast_2d(X)\\n Y = np.atleast_2d(Y)\\n n = X.shape[0]\\n if Y.shape[0] != X.shape[0]:\\n raise ValueError('Number of samples must match')\\n a = squareform(pdist(X))\\n b = squareform(pdist(Y))\\n A = a - a.mean(axis=0)[None, :] - a.mean(axis=1)[:, None] + a.mean()\\n B = b - b.mean(axis=0)[None, :] - b.mean(axis=1)[:, None] + b.mean()\\n \\n dcov2_xy = (A * B).sum()/float(n * n)\\n dcov2_xx = (A * A).sum()/float(n * n)\\n dcov2_yy = (B * B).sum()/float(n * n)\\n dcor = np.sqrt(dcov2_xy)/np.sqrt(np.sqrt(dcov2_xx) * np.sqrt(dcov2_yy))\\n return dcor\",\n \"def pearson_correlation(X, Y):\\n # should not need X_norm_squared because if you could precompute that as\\n # well as Y, then you should just pre-compute the output and not even\\n # call this function.\\n if X is Y:\\n X = Y = np.asanyarray(X)\\n else:\\n X = np.asanyarray(X)\\n Y = np.asanyarray(Y)\\n\\n if X.shape[1] != Y.shape[1]:\\n raise ValueError(\\\"Incompatible dimension for X and Y matrices\\\")\\n\\n XY = ssd.cdist(X, Y, 'correlation', 2)\\n\\n return 1 - XY\",\n \"def coupling_coef_corrs(coupling_coefs1, coupling_coefs2, correlation='pearson'):\\n n_neurons = coupling_coefs1.shape[0]\\n correlations = np.zeros(n_neurons)\\n\\n for neuron in range(n_neurons):\\n ccs1 = coupling_coefs1[neuron]\\n ccs2 = coupling_coefs2[neuron]\\n\\n if np.array_equal(ccs1, ccs2):\\n correlations[neuron] = 1.\\n elif np.all(ccs1 == 0) or np.all(ccs2 == 0):\\n correlations[neuron] = 0\\n else:\\n if correlation == 'pearson':\\n correlations[neuron] = np.corrcoef(ccs1, ccs2)[0, 1]\\n elif correlation == 'spearman':\\n correlations[neuron] = spearmanr(ccs1, ccs2).correlation\\n elif correlation == 'cosine':\\n correlations[neuron] = cosine_similarity(ccs1, ccs2)\\n\\n return correlations\",\n \"def auto_correlation(arr):\\n return cross_correlation(arr, arr)\",\n \"def corr():\\n\\n @sinks\\n def _dagpype_internal_fn_act(target):\\n c = dagpype_c.Correlator()\\n try:\\n while True:\\n x, y = (yield)\\n c.push(float(x), float(y))\\n except GeneratorExit:\\n target.send(c.corr())\\n target.close()\\n return _dagpype_internal_fn_act\",\n \"def correlation_1D2D_datainput(df1, df2): # correlation function from Rémi (local.py)\\n\\n df2 = df2.transpose() # sigs_2D.transpose()\\n cov = np.dot(df1 - df1.mean(), df2 - df2.mean(axis=0)) / (df2.shape[0] - 1)\\n # ddof=1 necessary because covariance estimate is unbiased (divided by n-1)\\n p_var = np.sqrt(np.var(df1, ddof=1) * np.var(df2, axis=0, ddof=1))\\n r = cov / p_var\\n return r\",\n \"def _listcorr(a):\\n corrs = np.zeros((a[0].shape[1], len(a), len(a)))\\n for i in range(len(a)):\\n for j in range(len(a)):\\n if j > i:\\n corrs[:, i, j] = [np.nan_to_num(np.corrcoef(ai, aj)[0, 1])\\n for (ai, aj) in zip(a[i].T, a[j].T)]\\n return corrs\",\n \"def test_compute_correlation_paired_detailed(self):\\r\\n # Verified using R's cor.test function.\\r\\n exp = ((0.90243902439024193, 0.013812916237431808, 0.038,\\r\\n (0.33958335414859975, 0.98938788428012969)),\\r\\n [('S1', 'S1', 1.0, 0, 0, 0.373, 0.746, (None, None)),\\r\\n ('S2', 'S2', 0.94491118252306538, 0.21229561500966185,\\r\\n 0.4245912300193237, 0.342, 0.684, (None, None))])\\r\\n\\r\\n np.random.seed(self.value_for_seed)\\r\\n obs = _compute_correlation(self.taxa_summary_paired1,\\r\\n self.taxa_summary_paired2, 'paired', 'pearson', 'two-sided',\\r\\n 999, 0.95, True)\\r\\n\\r\\n self.compare_multiple_level_array(obs, exp)\",\n \"def correlation_matrix(series, as_rows=True):\\r\\n return corrcoef(series, rowvar=as_rows)\\r\\n # unused codes below\\r\\n if as_rows:\\r\\n return corrcoef(transpose(array(series)))\\r\\n else:\\r\\n return corrcoef(array(series))\",\n \"def cross_correlations(df1,df2,subject_ID_col):\\n n_roi = len(df1.columns)-1 #cols=subject_ID + roi_cols\\n\\n col_rename_dict = {} #Only need to rename on df\\n \\n for col in df1.columns:\\n col_rename_dict[col] = str(col) + '_df2'\\n\\n df2 = df2.rename(columns=col_rename_dict)\\n df2 = df2.rename(columns={'{}_df2'.format(subject_ID_col):subject_ID_col})\\n\\n concat_df = df1.merge(df2, on=subject_ID_col)\\n corr_mat = concat_df.corr()\\n xcorr_dig = corr_mat.values[:n_roi,n_roi:2*n_roi].diagonal()\\n xcorr_df = pd.DataFrame(columns=['ROI','correlation'])\\n xcorr_df['ROI'] = corr_mat.columns[:n_roi] \\n xcorr_df['correlation'] = xcorr_dig\\n\\n return xcorr_df\",\n \"def cross_correlation(f, g):\\n\\n out = None\\n k = np.flip(np.flip(g, 0), 1)\\n out = conv_fast(f, k)\\n\\n return out\",\n \"def computeCorr(pred_act,responses):\\n\\n num_pres,num_neurons = np.shape(responses)\\n corr=np.zeros(num_neurons)\\n \\n for i in xrange(0,num_neurons):\\n if np.all(pred_act[:,i]==0) & np.all(responses[:,i]==0):\\n corr[i]=1.\\n elif not(np.all(pred_act[:,i]==0) | np.all(responses[:,i]==0)):\\n # /!\\\\ To prevent errors due to very low values during computation of correlation\\n if abs(pred_act[:,i]).max()<1:\\n pred_act[:,i]=pred_act[:,i]/abs(pred_act[:,i]).max()\\n if abs(responses[:,i]).max()<1:\\n responses[:,i]=responses[:,i]/abs(responses[:,i]).max() \\n corr[i]=pearsonr(np.array(responses)[:,i].flatten(),np.array(pred_act)[:,i].flatten())[0]\\n \\n return corr\",\n \"def pearsonCorrelation(x, y):\\n\\tsum_sq_x = 0\\n\\tsum_sq_y = 0\\n\\tsum_coproduct = 0\\n\\tmean_x = x[0]\\n\\tmean_y = y[0]\\n\\tif len(x) != len(y):\\n\\t\\traise StatsError(\\\"Data sets are of different lengths.\\\")\\n\\tn = len(x)\\n\\tfor i in range(1,n):\\n\\t\\tsweep = i / (i+1.0)\\n\\t\\tdelta_x = x[i] - mean_x\\n\\t\\tdelta_y = y[i] - mean_y\\n\\t\\tsum_sq_x += delta_x * delta_x * sweep\\n\\t\\tsum_sq_y += delta_y * delta_y * sweep\\n\\t\\tsum_coproduct += delta_x * delta_y * sweep\\n\\t\\tmean_x += delta_x / (i+1.0)\\n\\t\\tmean_y += delta_y / (i+1.0)\\n\\tpop_sd_x = math.sqrt( sum_sq_x / n )\\n\\tpop_sd_y = math.sqrt( sum_sq_y / n )\\n\\tcov_x_y = sum_coproduct / n\\n\\tr = cov_x_y / (pop_sd_x * pop_sd_y)\\n\\tz = math.fabs(r) * math.sqrt(n) / math.sqrt(2.0)\\n\\tp = Prob_Z(z)\\n\\tif not (0.0 <= p <= 1.0):\\n\\t\\traise StatsError(\\\"Invalid P-value of %r.\\\" % r)\\n\\treturn (r, p, n)\",\n \"def get_corr(self):\\r\\n cov = self.data.values\\r\\n with np.errstate(divide='ignore', invalid='ignore'):\\r\\n coeff = np.true_divide(1, self.get_std().values)\\r\\n coeff[~ np.isfinite(coeff)] = 0 # -inf inf NaN\\r\\n corr = np.multiply(np.multiply(cov, coeff).T, coeff)\\r\\n df = pd.DataFrame(\\r\\n corr,\\r\\n index=self.data.index,\\r\\n columns=self.data.columns,\\r\\n )\\r\\n return self.__class__(df)\",\n \"def _c_correlation(cls, X, y):\\n su = np.zeros(X.shape[1])\\n for i in np.arange(X.shape[1]):\\n su[i] = cls._symmetrical_uncertainty(X[:, i], y)\\n return su\",\n \"def features_correlation(df, cols, target, fig_size=(6,6), path=None):\\n f, ax = plt.subplots(1, figsize=fig_size)\\n ax.set_xlabel(\\\"Feature Correlation\\\")\\n visualizer = FeatureCorrelation(labels=list(cols))\\n visualizer.fit(df[cols], df[target])\\n f.tight_layout()\\n if(path != None):\\n f.savefig(path+'/features_correlation.png')\",\n \"def compute_corr(self):\\n self.corr_ = cov_to_corr(self.cov_)\\n return self\",\n \"def corr(x, y, pX, pY, pxy):\\n return cov(x, y, pxy) / (mystd(x, pX) * mystd(y, pY))\",\n \"def correlation_with_indices(*, index_filename, pc_df):\\n index_df = pd.read_csv(index_filename,\\n parse_dates=['date'], index_col=0)\\n # Keep only data common to both time series\\n merged = pd.merge(pc_df.dropna(), index_df.dropna(), on='date',\\n how='inner')\\n\\n index_cols = merged.filter(regex='AE|AO|AU|AL|Dst|PCN|PCS|Em',\\n axis=1).columns\\n coeffs = []\\n for index in index_cols:\\n # Calculate correlation coefficient between principal component and\\n # index\\n coeff = np.corrcoef(merged.proxy, merged[index])\\n coeffs.append(coeff.data[0, 1])\\n return index_cols, coeffs\",\n \"def combine_for_correlation(df1=get_us_ridership(), df2=get_sales_data()):\\n df1.index.astype(int)\\n df2.index.astype(int)\\n temp = pd.concat([df1, df2], axis=1)\\n return temp.dropna()\",\n \"def test_compute_correlation_paired_no_permutations(self):\\r\\n # Verified using R's cor.test function.\\r\\n exp = ((0.90243902439024193, 0.013812916237431808, None,\\r\\n (0.48961251524616184, 0.98476601971494115)),\\r\\n [('S1', 'E1', 1.0, 0, 0, None, None, (None, None)),\\r\\n ('S2', 'E1', 0.94491118252306538, 0.21229561500966185,\\r\\n 0.4245912300193237, None, None, (None, None))])\\r\\n obs = _compute_correlation(self.taxa_summary_paired1,\\r\\n self.taxa_summary_paired3, 'paired', 'pearson', 'two-sided',\\r\\n 0, 0.90, True)\\r\\n self.compare_multiple_level_array(obs, exp)\",\n \"def _cont_cat_corr_features_anova(self, p_val = 0.01, subsamplesize = 100, p_seed = 0):\\n \\\"\\\"\\\" Use ICC to define correlations, give box-plots for highly correlated pairs \\\"\\\"\\\"\\n # TODO add option to do Bonferroni correction to adjust p-value depending on number of variables\\n \\n warnings.filterwarnings('ignore')\\n # List of pairs along with correlation above threshold\\n cont_cat_corr_list = []\\n \\n seed(p_seed)\\n rand_vals = sample(range(self._n_rows), k=subsamplesize)\\n \\n # Search for the highly correlated pairs\\n for i in self._cont_index_predictors: \\n for j in self._cat_index_predictors:\\n formula = self._dataset.columns[i] + \\\" ~ \\\" + self._dataset.columns[j] \\n model_fit = ols(formula, data=self._dataset.iloc[rand_vals,:]).fit()\\n anova_model = anova_lm(model_fit)\\n p = anova_model.iloc[0,4]\\n if p < p_val:\\n cont_cat_corr_list.append([p,i,j]) #store correlation and columns index\\n \\n # Order variables by level of correlation \\n s_cont_cat_corr_list = sorted(cont_cat_corr_list,key=lambda x: abs(x[0]))\\n \\n cont_cat_corr_features = []\\n\\n for v,i,j in s_cont_cat_corr_list:\\n cont_cat_corr_features.append([self._dataset.columns[i],self._dataset.columns[j],v])\\n \\n return cont_cat_corr_features\",\n \"def get_corr(self):\\n return self.corr_matrix, self.corr_signature\",\n \"def find_correlation(df, method=\\\"pearson\\\", threshold=0.9):\\n corr_matrix = df.corr(method=method).abs()\\n corr_means = {k: corr_matrix[k].mean()\\n for k in corr_matrix.columns.tolist()}\\n corr_matrix.loc[:, :] = np.tril(corr_matrix, k=-1)\\n\\n correlated = {}\\n for col in corr_matrix:\\n corr_cols = corr_matrix[col][corr_matrix[col]\\n >= threshold].index.tolist()\\n corr_cols.append(col)\\n\\n if len(corr_cols) > 1:\\n selected_cols = {k: corr_means[k] for k in corr_cols}\\n\\n selected_col = max(selected_cols, key=lambda k: selected_cols[k])\\n correlated_col = corr_matrix.transpose()[selected_col].idxmax()\\n correlated[selected_col] = (correlated_col,\\n corr_matrix[correlated_col][selected_col])\\n return correlated\",\n \"def calculate_correlations(input_data, index_col, cat_features, exclu_elements): \\r\\n try:\\r\\n # encode the categorical features\\r\\n encoded_data = pd.get_dummies(input_data,columns=cat_features,drop_first=True)\\r\\n\\r\\n pd_transposed_data = encoded_data.set_index('Style_display_code').T\\r\\n\\r\\n # get the number of items\\r\\n items_list = [str(a) for a in pd_transposed_data.columns]\\r\\n\\r\\n print(\\\"Number of items to correlate :{}_Timestamp:{}\\\".format(str(len(items_list)), \\r\\n format(str(datetime.now()))))\\r\\n \\r\\n\\r\\n #compute correlations and save the pickle file\\r\\n# matrix = pd_transposed_data.corr().values\\r\\n# pickle.dump(matrix, open(staging_dir+ '/corr_matrix_output_py3.p', 'wb'))\\r\\n \\r\\n # read from the saved pickle file - ONLY FOR CONSECUTIVE RUNS, TO SAVE TIME\\r\\n matrix = pickle.load(open(staging_dir+ '/corr_matrix_output_py3.p', \\\"rb\\\" ) )\\r\\n\\r\\n print(\\\"Corr Matrix size:{}_Timestamp:{}\\\".format(str(matrix.size),\\r\\n format(str(datetime.now()))))\\r\\n\\r\\n except Exception as e:\\r\\n print(\\\" Error !!\\\", e)\\r\\n \\r\\n # return the top correlated items\\r\\n return top_correlateditems(items_list,matrix, index_col, exclu_elements)\",\n \"def correlation(G, variables = [], conditionants = []):\\n \\n cov = covariance(G, variables = variables, \\n conditionants = conditionants)\\n k = cov.shape[0]\\n sds = sp.Matrix([1/sp.sqrt(cov[i, i]) for i \\n in range(0, k)]*k).reshape(k, k)\\n \\n cor = cov.multiply_elementwise(sds).multiply_elementwise(sds.T)\\n return cor.applyfunc(sp.simplify)\",\n \"def test_distance_correlation_fast(self):\\n arr1 = np.array(((1,), (2,), (3,), (4,), (5,), (6,)))\\n arr2 = np.array(((1,), (7,), (5,), (5,), (6,), (2,)))\\n\\n covariance = dcor_internals._u_distance_covariance_sqr_fast(\\n arr1, arr2)\\n self.assertAlmostEqual(covariance, -0.88889, places=5)\\n\\n correlation = dcor_internals._u_distance_correlation_sqr_fast(\\n arr1, arr2)\\n self.assertAlmostEqual(correlation, -0.41613, places=5)\\n\\n covariance = dcor_internals._u_distance_covariance_sqr_fast(\\n arr1, arr1)\\n self.assertAlmostEqual(covariance, 1.5556, places=4)\\n\\n correlation = dcor_internals._u_distance_correlation_sqr_fast(\\n arr1, arr1)\\n self.assertAlmostEqual(correlation, 1, places=5)\",\n \"def correlation(row):\\n return row['correlation']\",\n \"def continous_correlation(independent, dependent):\\n\\n # Init of resulting DataFrame\\n corr_data = pd.DataFrame()\\n for indep_var in independent.columns:\\n # Drop nans\\n combined = pd.concat([independent[indep_var], dependent], axis=1).dropna()\\n # Write down sample size\\n corr_data.loc[indep_var, \\\"sample_size\\\"] = len(combined)\\n # Calculate correlations with scipy methods\\n corr_data.loc[indep_var, 'pearson_rho'], corr_data.loc[indep_var, 'pearson'] = pearsonr(combined[indep_var],\\n combined[\\n dependent.name])\\n corr, corr_data.loc[indep_var, 'kendall'] = kendalltau(combined[indep_var], combined[dependent.name])\\n corr_data.loc[indep_var, 'log_pearson_rho'], corr_data.loc[indep_var, 'log_pearson'] = nan, nan\\n corr_data.loc[indep_var, f'log({indep_var})_{dependent.name}_rho'], \\\\\\n corr_data.loc[indep_var, f'log({indep_var})_{dependent.name}_pearson'] = nan, nan\\n return corr_data\",\n \"def coupling_coef_corrs(fits_path, dataset1, dataset2):\\n fits = h5py.File(fits_path, 'r')\\n coefs1 = np.median(fits[dataset1]['coupling_coefs'][:], axis=0)\\n coefs2 = np.median(fits[dataset2]['coupling_coefs'][:], axis=0)\\n\\n n_neurons = coefs1.shape[0]\\n corrs = np.zeros(n_neurons)\\n\\n for neuron in range(n_neurons):\\n corrs[neuron] = np.corrcoef(coefs1[neuron], coefs2[neuron])[0, 1]\\n\\n return corrs\",\n \"def pearson_r(x, y):\\r\\n # Compute correlation matrix: corr_mat\\r\\n \\r\\n corr_mat=np.corrcoef(x,y)\\r\\n\\r\\n # Return entry [0,1]\\r\\n return corr_mat[0,1]\",\n \"def get_correlated_data_stats(\\n data: np.array\\n) -> Dict[str, float]:\\n n_features = data.shape[1]\\n corr = pd.DataFrame(data).corr()\\n corr = np.array(corr)\\n\\n assert corr.shape[0] == corr.shape[1] == n_features\\n\\n pair_correlations = []\\n for i in range(n_features):\\n for j in range(n_features):\\n if i > j:\\n pair_correlations.append(corr[i, j])\\n abs_pair_correlations = [abs(c) for c in pair_correlations]\\n\\n assert len(pair_correlations) == (n_features * n_features - n_features) / 2\\n\\n data_corr_stats = {\\n \\\"correlation_min\\\": np.min(pair_correlations),\\n \\\"correlation_max\\\": np.max(pair_correlations),\\n \\\"correlation_median\\\": np.median(pair_correlations),\\n \\\"correlation_mean\\\": np.mean(pair_correlations),\\n \\\"correlation_std\\\": np.std(pair_correlations),\\n\\n \\\"abs_correlation_min\\\": np.min(abs_pair_correlations),\\n \\\"abs_correlation_max\\\": np.max(abs_pair_correlations),\\n \\\"abs_correlation_median\\\": np.median(abs_pair_correlations),\\n \\\"abs_correlation_mean\\\": np.mean(abs_pair_correlations),\\n \\\"abs_correlation_std\\\": np.std(abs_pair_correlations)\\n }\\n return data_corr_stats\",\n \"def xcorr(x, y, maxlag=None):\\n xl = x.size\\n yl = y.size\\n if xl != yl:\\n raise ValueError('x and y must be equal length')\\n\\n if maxlag is None:\\n maxlag = xl - 1\\n else:\\n maxlag = int(maxlag)\\n if maxlag >= xl or maxlag < 1:\\n raise ValueError('maglags must be None or strictly positive')\\n\\n if xl > 500: # Rough estimate of speed crossover\\n c = sig.fftconvolve(x, y[::-1])\\n c = c[xl - 1 - maxlag:xl + maxlag]\\n else:\\n c = np.zeros(2*maxlag + 1)\\n for i in range(maxlag+1):\\n c[maxlag-i] = np.correlate(x[0:min(xl, yl-i)],\\n y[i:i+min(xl, yl-i)])\\n c[maxlag+i] = np.correlate(x[i:i+min(xl-i, yl)],\\n y[0:min(xl-i, yl)])\\n return c\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74171937","0.71074754","0.6666765","0.66659594","0.6619614","0.6587562","0.6580525","0.6578581","0.65783983","0.65568876","0.6511679","0.6491773","0.6461151","0.6446981","0.64354914","0.63979685","0.6396546","0.6372075","0.6297028","0.6269612","0.62397534","0.6223215","0.6214947","0.62044656","0.6184846","0.6170482","0.6168986","0.6165049","0.61299264","0.6112055","0.60965246","0.6085486","0.60782695","0.6070847","0.6068628","0.6068628","0.60672486","0.60602695","0.6059905","0.60479766","0.6034232","0.59879774","0.59715337","0.5969172","0.59689206","0.59592915","0.5958379","0.5938159","0.59285176","0.5927904","0.5923681","0.5898016","0.5896787","0.58902496","0.58760417","0.5836605","0.58363104","0.5835902","0.5825959","0.58256394","0.5812395","0.58005863","0.5796705","0.5792577","0.57893836","0.57855344","0.5783311","0.5776125","0.57701916","0.5744341","0.57303506","0.5725207","0.5725026","0.571423","0.569523","0.5687164","0.5680524","0.5678777","0.5667842","0.5667618","0.56667334","0.56578046","0.5643155","0.56416273","0.5629903","0.5589752","0.55812126","0.55620223","0.55620193","0.5558786","0.55545735","0.5532266","0.5532101","0.552906","0.55250037","0.55228674","0.5521369","0.55170816","0.55082023","0.5507684","0.54957354"],"string":"[\n \"0.74171937\",\n \"0.71074754\",\n \"0.6666765\",\n \"0.66659594\",\n \"0.6619614\",\n \"0.6587562\",\n \"0.6580525\",\n \"0.6578581\",\n \"0.65783983\",\n \"0.65568876\",\n \"0.6511679\",\n \"0.6491773\",\n \"0.6461151\",\n \"0.6446981\",\n \"0.64354914\",\n \"0.63979685\",\n \"0.6396546\",\n \"0.6372075\",\n \"0.6297028\",\n \"0.6269612\",\n \"0.62397534\",\n \"0.6223215\",\n \"0.6214947\",\n \"0.62044656\",\n \"0.6184846\",\n \"0.6170482\",\n \"0.6168986\",\n \"0.6165049\",\n \"0.61299264\",\n \"0.6112055\",\n \"0.60965246\",\n \"0.6085486\",\n \"0.60782695\",\n \"0.6070847\",\n \"0.6068628\",\n \"0.6068628\",\n \"0.60672486\",\n \"0.60602695\",\n \"0.6059905\",\n \"0.60479766\",\n \"0.6034232\",\n \"0.59879774\",\n \"0.59715337\",\n \"0.5969172\",\n \"0.59689206\",\n \"0.59592915\",\n \"0.5958379\",\n \"0.5938159\",\n \"0.59285176\",\n \"0.5927904\",\n \"0.5923681\",\n \"0.5898016\",\n \"0.5896787\",\n \"0.58902496\",\n \"0.58760417\",\n \"0.5836605\",\n \"0.58363104\",\n \"0.5835902\",\n \"0.5825959\",\n \"0.58256394\",\n \"0.5812395\",\n \"0.58005863\",\n \"0.5796705\",\n \"0.5792577\",\n \"0.57893836\",\n \"0.57855344\",\n \"0.5783311\",\n \"0.5776125\",\n \"0.57701916\",\n \"0.5744341\",\n \"0.57303506\",\n \"0.5725207\",\n \"0.5725026\",\n \"0.571423\",\n \"0.569523\",\n \"0.5687164\",\n \"0.5680524\",\n \"0.5678777\",\n \"0.5667842\",\n \"0.5667618\",\n \"0.56667334\",\n \"0.56578046\",\n \"0.5643155\",\n \"0.56416273\",\n \"0.5629903\",\n \"0.5589752\",\n \"0.55812126\",\n \"0.55620223\",\n \"0.55620193\",\n \"0.5558786\",\n \"0.55545735\",\n \"0.5532266\",\n \"0.5532101\",\n \"0.552906\",\n \"0.55250037\",\n \"0.55228674\",\n \"0.5521369\",\n \"0.55170816\",\n \"0.55082023\",\n \"0.5507684\",\n \"0.54957354\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":10499,"cells":{"query":{"kind":"string","value":"Parse one access line."},"document":{"kind":"string","value":"def ParseLine(line):\n fields = line.split()\n ip = fields[0]\n datestr = ' '.join(fields[3:5])[1:-1]\n timestamp = datetime.strptime(\n datestr, '%d/%b/%Y:%H:%M:%S %z'\n ).timestamp()\n command = fields[5][1:]\n uri = fields[6]\n protocol = fields[7][:-1]\n status = int(fields[8])\n size = int(fields[9])\n meta = [var.strip('\"') for var in fields[11:-1]]\n return {\n 'timestamp': timestamp,\n 'ip': ip,\n 'command': command,\n 'uri': uri,\n 'protocol': protocol,\n 'status': status,\n 'size': size,\n 'meta': meta\n }"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parse_line(self, line):\n raise NotImplementedError","def parse(cls, line):\r\n raise NotImplementedError","def parse_line(self, line, time_shift=0.0):\n # The local variables are rather simple.\n # pylint: disable=too-many-locals\n try:\n (\n mode_string,\n nlink,\n user,\n group,\n size,\n month,\n day,\n year_or_time,\n name,\n ) = self._split_line(line)\n # We can get a `ValueError` here if the name is blank (see ticket #69).\n # This is a strange use case, but at least we should raise the\n # exception the docstring mentions.\n except ValueError as exc:\n raise ftputil.error.ParserError(str(exc))\n # st_mode\n st_mode = self.parse_unix_mode(mode_string)\n # st_ino, st_dev, st_nlink, st_uid, st_gid, st_size, st_atime\n st_ino = None\n st_dev = None\n st_nlink = int(nlink)\n st_uid = user\n st_gid = group\n st_size = int(size)\n st_atime = None\n # st_mtime\n st_mtime, st_mtime_precision = self.parse_unix_time(\n month, day, year_or_time, time_shift, with_precision=True\n )\n # st_ctime\n st_ctime = None\n # st_name\n if name.count(\" -> \") > 1:\n # If we have more than one arrow we can't tell where the link name\n # ends and the target name starts.\n raise ftputil.error.ParserError(\n '''name '{}' contains more than one \"->\"'''.format(name)\n )\n elif name.count(\" -> \") == 1:\n st_name, st_target = name.split(\" -> \")\n else:\n st_name, st_target = name, None\n stat_result = StatResult(\n (\n st_mode,\n st_ino,\n st_dev,\n st_nlink,\n st_uid,\n st_gid,\n st_size,\n st_atime,\n st_mtime,\n st_ctime,\n )\n )\n # These attributes are kind of \"half-official\". I'm not sure whether\n # they should be used by ftputil client code.\n # pylint: disable=protected-access\n stat_result._st_mtime_precision = st_mtime_precision\n stat_result._st_name = st_name\n stat_result._st_target = st_target\n return stat_result","def parse_line(self, line: str) -> None:\n self._count += 1","def parseline(self, line):\n line = line.strip()\n\n if not line:\n # Deal with empty line or all whitespace line\n return None, None, line\n\n # Expand command shortcuts to the full command name\n for (shortcut, expansion) in self.shortcuts:\n if line.startswith(shortcut):\n line = line.replace(shortcut, expansion + ' ', 1)\n break\n\n i, n = 0, len(line)\n while i < n and line[i] in self.identchars:\n i += 1\n command, arg = line[:i], line[i:].strip()\n return command, arg, line","def _parse_record(line):\n fields = line.split()\n if len(fields) < 6:\n raise ParseError(\"Less than six fields found in PED/FAM file\")\n individual_id, paternal_id, maternal_id = fields[1:4]\n if paternal_id == \"0\":\n paternal_id = None\n if maternal_id == \"0\":\n maternal_id = None\n return Trio(child=individual_id, father=paternal_id, mother=maternal_id)","def _ParseAsanLogLine(line):\n m = re.match(_RE_ASAN, line)\n if not m:\n return None\n return AsanParsedLine(prefix=m.group('prefix'),\n library=m.group('lib'),\n pos=m.group('pos'),\n rel_address=int(m.group('addr'), 16))","def parse_line(self, line):\n success = self.parser.handle_line(line)\n if success:\n self.data.update()\n else:\n self.bot.log(\"didn't handle line: '{}'\".format(line))","def parse(self, filehandle):\n l = filehandle.readline()\n if l.split()[0] != '##maf':\n return\n else:\n self.setpar(l.split()[1:])\n\n l=filehandle.readline()\n while l:\n la = l.split()\n## print la\n if(len(la)==0 or la[0]=='#'):\n## print \"skipping\"\n 1\n elif(la[0]=='a'):\n## print \"reading alignment\"\n self.readalign(la[1:], filehandle)\n else:\n## print \"end of records\"\n return\n\n l=filehandle.readline()","def doomed_parser(line):\n raise exceptions.LineParseException('Error occurred')","def parse_line(self, line):\n\t\tif line[0] == \"#\":\n\t\t\treturn False\n\t\tparts = [x.strip() for x in line.strip().split(\",\")]\n\t\tself.unix_time = int(parts[0])\n\t\tself.cycles_done = int(parts[1])\n\t\tself.cur_path = int(parts[2])\n\t\tself.paths_total = int(parts[3])\n\t\tself.pending_total = int(parts[4])\n\t\tself.pending_favs = int(parts[5])\n\t\tself.map_size = float(parts[6].replace(\"%\",\"\"))\n\t\tself.unique_crashes = int(parts[7])\n\t\tself.unique_hangs = int(parts[8])\n\t\tself.max_depth = int(parts[9])\n\t\tself.execs_per_sec = float(parts[10])\n\t\treturn True","def __init__(self, line):\n # Throw an exception if we don't see the parenthesis that mark a history entry\n if not line[108] == '(':\n raise ParsingException\n if not line[138:139] == ')':\n raise ParsingException\n\n self.status = line[109:122].strip()\n self.time_stamp = datetime.strptime(line[122:138], '%m/%d/%Y %H:%M')","def GetLine(line):\r\n pass","def parse(self,att_line):\r\n att_line = {item.split('=')[0]:item.split('=')[1] for item in att_line.split(';')}\r\n if 'ID' in att_line:\r\n self.id = att_line.pop('ID',None)\r\n if 'Name' in att_line:\r\n self.name = att_line.pop('Name',None)\r\n if 'Alias' in att_line:\r\n self.alias = att_line.pop('Alias',None)\r\n if 'Parent' in att_line:\r\n self.parent = att_line.pop('Parent',None)\r\n if 'Target' in att_line:\r\n self.target = att_line.pop('Target',None)\r\n if 'Gap' in att_line:\r\n self.gap = att_line.pop('Gap',None)\r\n if 'Derives_from' in att_line:\r\n self.derives_from = att_line.pop('Derives_from',None)\r\n if 'Note' in att_line:\r\n self.note = att_line.pop('Note',None)\r\n if 'Dbxref' in att_line:\r\n self.dbxref = att_line.pop('Dbxref',None)\r\n if 'Ontology_term' in att_line:\r\n self.ontology_term = att_line.pop('Ontology_term',None)\r\n if 'Is_circular' in att_line:\r\n self.is_circular = att_line.pop('Is_circular',None)\r\n if self.allele_key in att_line:\r\n self.allele = att_line.pop(self.allele_key,None).split(',')\r\n if self.discovered_key in att_line:\r\n discovered_val = att_line.pop(self.discovered_key,None)\r\n if discovered_val in self.enabled:\r\n self.discovered = True\r\n elif discovered_val in self.disabled:\r\n self.discovered = False\r\n if self.validated_key in att_line:\r\n validated_val = att_line.pop(self.validated_key,None)\r\n if validated_val in self.enabled:\r\n self.validated = True\r\n elif validated_val in self.disabled:\r\n self.validated = False\r\n if self.active_key in att_line:\r\n active_val = att_line.pop(self.active_key,None)\r\n if active_val in self.enabled:\r\n self.active = False\r\n elif active_val in self.disabled:\r\n self.active = True\r\n else:\r\n pass#print(\"{} is not a valid entry for {}\".format(active_val,self.active_key))\r\n else:\r\n #TODO this will make every element withought existing value active.\r\n self.active = True\r\n rest_dict = {}\r\n for key,value in att_line.items():\r\n if self.history_key in key:\r\n parts = att_line[key].split(',')\r\n if len(parts) == 3:\r\n self.add_history(*parts)\r\n else:\r\n reason = '.'.join(parts[2:])\r\n self.add_history(parts[0],parts[1],reason)\r\n else:\r\n rest_dict[key] = value\r\n if rest_dict != {}:\r\n #TODO: maybe add this to a logger instead\r\n #print(\"attributes put in other: {}\".format(', '.join(att_line.keys())))\r\n self.other = att_line\r\n return self","def parseLine(self, line):\n\n # Bail out on lines with a malformed timestamp\n try:\n timestamp = time.mktime(time.strptime(line[1:25], \"%a %b %d %H:%M:%S %Y\"))\n except:\n return\n \n text = line[27:]\n \n if self.myname: \n self.attendance.mark(timestamp, self.myname)\n text = self.re_myname.sub(self.myname + ' ', text) \n \n damage = self.re_damage.search(text)\n #damage = False\n death = self.re_death.search(text)\n #death = False\n miss = self.re_miss.search(text)\n #miss = False\n #defensive = self.re_defensive.search(text)\n defensive = False\n loot = self.re_loot.search(text)\n attendance = self.re_attendance.search(text)\n if damage:\n (attacker, atktype, defender, amount, nonmelee) = damage.groups()\n if nonmelee:\n atktype = 'non-melee'\n if self.extract and (self.extract == attacker or self.extract == defender):\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, int(amount))\n if attacker.count(' ') == 0:\n self.attendance.mark(timestamp, attacker)\n if defender.count(' ') == 0:\n self.defender.mark(timestamp, defender)\n elif miss:\n (attacker, atktype, defender) = miss.groups()\n if self.extract and (self.extract == attacker or self.extract == defender):\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, 'miss')\n if attacker.count(' ') == 0:\n self.attendance.mark(timestamp, attacker)\n if defender.count(' ') == 0:\n self.defender.mark(timestamp, defender)\n elif defensive:\n (attacker, atktype, defender, defensetype) = defensive.groups()\n if self.extract and (self.extract == attacker or self.extract == defender):\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, defensetype)\n if attacker.count(' ') == 0:\n self.attendance.mark(timestamp, attacker)\n if defender.count(' ') == 0:\n self.defender.mark(timestamp, defender)\n elif death:\n (defender, junk, attacker) = death.groups()\n if junk.count('have slain'):\n (defender, attacker) = (attacker, defender)\n # Use PC deaths to track their attendance\n if defender.count(' ') == 0:\n self.attendance.mark(timestamp, defender)\n elif attacker.count(' ') == 0:\n self.kills.addKill(timestamp, defender)\n if self.extract and (self.extract == attacker or self.extract == defender):\n self.fights.addDeath(timestamp, attacker, defender)\n if attacker.count(' ') == 0:\n self.attendance.mark(timestamp, attacker)\n elif loot:\n (looter, item) = loot.groups()\n self.loot.addLoot(timestamp, looter, item)\n self.attendance.mark(timestamp, looter)\n elif attendance:\n attendee = attendance.group(1)\n self.attendance.mark(timestamp, attendee)","def parse_line(line: str) -> str:\n return line","def parse_line(line: str) -> str:\n return line","def parse_line(line: str) -> str:\n return line","def parse_line(line: str) -> str:\n return line","def parse_movie(self, line):\n pass","def decodeline(self, line):\n result = ApacheLogLine()\n result.full_line = line\n linepatternmatch = self._linepattern.match(line)\n if linepatternmatch:\n result.hostname = linepatternmatch.group(1)\n result.user = linepatternmatch.group(2)\n if result.user == '-':\n result.user = ''\n (result.accesstime_seconds, result.serveroffset) = self.parsedate(linepatternmatch.group(3))\n result.accesstime_string = stringdate(result.accesstime_seconds, offset=result.serveroffset)\n result.file = linepatternmatch.group(4)\n result.code = linepatternmatch.group(5)\n result.code_description = self._codetranslator.get_description(result.code)\n result.size = linepatternmatch.group(6)\n if result.size == '-':\n result.size = 0\n result.referer = linepatternmatch.group(7)\n if result.referer == '-':\n result.referer = ''\n result.browser = linepatternmatch.group(8)\n else:\n self._notparsable += 1\n warn(\"The line '%s' could not be parsed\" % line)\n return None\n if self._line_fits_pattern(result):\n self._acceptedlines += 1\n return result\n else:\n self._rejectedlines += 1\n return None","def parse(line: str) -> \"SeqNode\":\n return MiniParser(Lexer(line)).parse()","def _parse_line(self, line):\n fields = line.split('|', 4) # stop splitting after fourth | found\n line_info = {'raw_message': line}\n if len(fields) == 5:\n line_info.update(dict(zip(self._fieldnames, fields)))\n return line_info","def parse_line(self, line, time_shift=0.0):\n raise NotImplementedError(\"must be defined by subclass\")","def parse_apache_log_line(logline):\n match = re.search(APACHE_ACCESS_LOG_PATTERN, logline)\n if match is None:\n return logline, 0\n size_field = match.group(9)\n if size_field == '-':\n size = long(0)\n else:\n size = long(match.group(9))\n return (Row(\n host=match.group(1),\n client_identd=match.group(2),\n user_id=match.group(3),\n date_time=parse_apache_time(match.group(4)),\n method=match.group(5),\n endpoint=match.group(6),\n protocol=match.group(7),\n response_code=int(match.group(8)),\n content_size=size\n ), 1)","def parse(input_data):\n parser = ACLParser(grammar)\n\n try:\n data = input_data.read()\n except AttributeError:\n data = input_data\n\n ## parse the acl\n success, children, nextchar = parser.parse(data)\n\n if success and nextchar == len(data):\n assert len(children) == 1\n return children[0]\n else:\n line = data[:nextchar].count('\\n') + 1\n column = len(data[data[nextchar].rfind('\\n'):nextchar]) + 1\n raise exceptions.ParseError('Could not match syntax. Please report as a bug.', line, column)","def _parse_line(line):\n if line.startswith('import '):\n line = line.replace('import ', '')\n return line","def parse_line(line):\n num1 = int(line.split(\"-\")[0])\n num2 = int(line.split(\"-\")[1].split(\" \")[0])\n character = line.split(\" \")[1].split(\":\")[0]\n password = line.split(\" \")[2]\n # print(f\"{line} :: ({num1}, {num2}, {character}, {password})\")\n return num1, num2, character, password","def parseApacheLogLine(logline):\n match = re.search(APACHE_ACCESS_LOG_PATTERN, logline)\n if match is None:\n return (logline, 0)\n size_field = match.group(9)\n if size_field == '-':\n size = long(0)\n else:\n size = long(match.group(9))\n return (Row(\n host = match.group(1),\n client_identd = match.group(2),\n user_id = match.group(3),\n date_time = parse_apache_time(match.group(4)),\n method = match.group(5),\n endpoint = match.group(6),\n protocol = match.group(7),\n response_code = int(match.group(8)),\n content_size = size\n ), 1)","def parse_pdb(self, line):\n super().parse_pdb(line)\n self.num_remark = int(line[10:15].strip())\n self.num_het = int(line[20:25].strip())\n self.num_helix = int(line[25:30].strip())\n self.num_sheet = int(line[30:35].strip())\n self.num_turn = int(line[35:40].strip())\n self.num_site = int(line[40:45].strip())\n self.num_xform = int(line[45:50].strip())\n self.num_coord = int(line[50:55].strip())\n self.num_ter = int(line[55:60].strip())\n self.num_conect = int(line[60:65].strip())\n self.num_seq = int(line[65:70].strip())","def read_token(line):\n token = line.strip().split('\\t')\n if len(token) == 6:\n token += ['_', '_', '_', '_']\n id, form, lemma, cpostag, postag, feats, head, deprel, phead, pdeprel = token\n try:\n head = int(head)\n except ValueError:\n head = '_'\n try:\n phead = int(phead)\n except ValueError:\n phead = '_'\n return Token(int(id), form, lemma, cpostag, postag, feats, head, deprel, phead, pdeprel)","def _parse_lladdr(line):\n tokens = line.split()\n return tokens[1]","def parseFileLine(self, line):\n c = line.strip().split(\":\")\n return (c[0], c[1], c[2], c[3])","def _process_line(self, line):\n i = 0\n while True:\n i = self._process_token(line)\n if i == 0:\n break\n line = line[i:]\n if line:\n util.debug('Lexer state:\\n{}'.format(self._debug_lexer_state()))\n raise LexerError('Syntax error (remaining:%r)' % (line,),\n self._cur_lineno + 1,\n self._cur_charno + 1)","def parse_access_log(log_lines):\n matches = [ ACCESS_RE.search(y) for y in log_lines ]\n return [ x.groupdict() for x in matches if x is not None ]","def ParseLine(line):\n words = line.split()\n date = words[0][1:] + \" \" + words[1][:-1]\n parsed_date = parse(date)\n year = parsed_date.year\n month = parsed_date.month\n day = parsed_date.day\n hour = parsed_date.hour\n mins = parsed_date.minute\n\n #print (year, month, day, hour, mins)\n shift_start = False\n guard_id = 0\n falls_asleep = False\n wakes = False\n if (words[2] == \"Guard\"):\n shift_start = True\n guard_id = int(words[3][1:])\n elif (words[2] == \"wakes\"):\n wakes = True\n guard_id = 0\n elif (words[2] == \"falls\"):\n falls_asleep = True\n guard_id = 0\n return Record(date, year, month, day, hour, mins, shift_start, guard_id, falls_asleep, wakes)","def _parse_line(line):\n # Tokenize the line.\n synset_pos, synset_offset, pos_score, neg_score, synset_terms, gloss = line.split('\\t')\n\n # We'll ignore the synset terms and gloss, because the NLTK synset\n # object stored in SWNEntry can get those from WordNet.\n\n return SWNEntry(synset_pos, int(synset_offset), float(pos_score), float(neg_score))","def parse_annotation_line(line, ln):\n fields = [f.strip() for f in line.split('\\t')]\n if len(fields) != 6:\n raise FormatError('Failed to parse line %d: %s' % (ln, line))\n PMID = fields[0]\n try:\n start = int(fields[1])\n end = int(fields[2])\n except:\n raise FormatError('Failed to parse line %d: %s' % (ln, line))\n text = fields[3]\n type_ = fields[4]\n if len(text) != end-start:\n raise FormatError('Text \"%s\" has length %d, end-start (%d-%d) is %s' %\n (text, len(text), end, start, end-start))\n norms = fields[5].split('|')\n return Annotation(PMID, start, end, text, type_, norms)","def parse_line(self, line):\n tokens, permanent, comment = OrdersParser.tokenize(line)\n \n if not tokens:\n if comment:\n self._consumer.comment(permanent=permanent, comment=comment)\n return\n \n order = tokens.popleft().lower()\n \n if order == '#atlantis':\n if not tokens:\n raise SyntaxError('{}: missing faction'.format(line))\n faction = OrdersParser._value(tokens.popleft())\n try:\n password = tokens.popleft()\n except IndexError:\n self._consumer.atlantis(faction=faction)\n else:\n self._consumer.atlantis(faction=faction,\n password=password)\n \n elif order == '#end':\n self._consumer.atlantis_end()\n \n elif order == 'unit':\n if not tokens:\n raise SyntaxError('{}: missing unit'.format(line))\n else:\n unit = OrdersParser._value(tokens.popleft())\n if not unit:\n raise SyntaxError('{}: invalid unit'.format(line))\n self._consumer.unit(unit=unit)\n \n elif order == 'form':\n if not tokens:\n raise SyntaxError('{}: missing alias'.format(line))\n else:\n alias = OrdersParser._value(tokens.popleft())\n if not alias:\n raise SyntaxError('{}: invalid alias'.format(line))\n self._consumer.order_form(alias=alias, permanent=permanent,\n comment=comment)\n elif order == 'end':\n self._consumer.order_end()\n \n elif order == 'turn':\n self._consumer.order_turn(permanent=permanent, comment=comment)\n \n elif order == 'endturn':\n self._consumer.order_endturn()\n \n elif order == 'address':\n if not tokens:\n raise SyntaxError('{}: missing address'.format(line))\n else:\n self._consumer.order_address(address=tokens.popleft(),\n permanent=permanent,\n comment=comment)\n \n elif order == 'advance':\n try:\n dirs = [OrdersParser._parse_dir(d.lower()) for d in tokens]\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n else:\n self._consumer.order_advance(dirs=dirs, permanent=permanent,\n comment=comment)\n \n elif order == 'assassinate':\n try:\n unit = OrdersParser._parse_unit(tokens)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n else:\n self._consumer.order_assassinate(unit=unit,\n permanent=permanent,\n comment=comment)\n \n elif order == 'attack':\n targets = []\n try:\n while tokens:\n targets.append(OrdersParser._parse_unit(tokens))\n except SyntaxError as e:\n self._consumer.order_attack(targets=targets,\n permanent=permanent,\n comment=comment)\n raise SyntaxError('{}: {}'.format(line, e))\n else:\n self._consumer.order_attack(targets=targets,\n permanent=permanent,\n comment=comment)\n \n elif order == 'autotax':\n if not tokens:\n raise SyntaxError('{}: missing value'.format(line))\n try:\n self._consumer.order_autotax(\n flag=OrdersParser._parse_TF(tokens.popleft()),\n permanent=permanent, comment=comment)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n \n elif order == 'avoid':\n if not tokens:\n raise SyntaxError('{}: missing value'.format(line))\n try:\n self._consumer.order_avoid(\n flag=OrdersParser._parse_TF(tokens.popleft()),\n permanent=permanent, comment=comment)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n \n elif order == 'idle':\n self._consumer.order_idle(permanent=permanent, comment=comment)\n \n elif order == 'behind':\n if not tokens:\n raise SyntaxError('{}: missing value'.format(line))\n try:\n self._consumer.order_behind(\n flag=OrdersParser._parse_TF(tokens.popleft()),\n permanent=permanent, comment=comment)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n \n elif order == 'build':\n if not tokens:\n self._consumer.order_build(permanent=permanent, comment=comment)\n else:\n tok = tokens.popleft().lower()\n if tok == 'help':\n try:\n target = OrdersParser._parse_unit(tokens)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n else:\n self._consumer.order_build(target=target,\n permanent=permanent,\n comment=comment)\n else:\n self._consumer.order_build(structure=tok,\n permanent=permanent,\n comment=comment)\n \n elif order == 'buy':\n if not tokens:\n raise SyntaxError('{}: missing amount'.format(line))\n num = tokens.popleft().lower()\n if num == 'all':\n num = OrdersParser.AMT_ALL\n else:\n num = OrdersParser._value(num)\n if not num:\n raise SyntaxError('{}: missing amount'.format(line))\n if not tokens:\n raise SyntaxError('{}: missing item'.format(line))\n self._consumer.order_buy(num=num, item=tokens.popleft().lower(),\n permanent=permanent, comment=comment)\n \n elif order == 'cast':\n if not tokens:\n raise SyntaxError('{}: missing skill'.format(line))\n skill = tokens.popleft().lower()\n params = [p.lower() for p in tokens]\n self._consumer.order_cast(skill=skill, params=params,\n permanent=permanent, comment=comment)\n \n elif order == 'claim':\n if not tokens:\n raise SyntaxError('{}: missing amount'.format(line))\n value = OrdersParser._value(tokens.popleft())\n if not value:\n raise SyntaxError('{}: missing amount'.format(line))\n self._consumer.order_claim(num=value, permanent=permanent,\n comment=comment)\n \n elif order == 'combat':\n if not tokens:\n combat = OrdersParser.IT_NONE\n else:\n combat = tokens.popleft().lower()\n self._consumer.order_combat(skill=combat, permanent=permanent,\n comment=comment)\n \n elif order == 'consume':\n if not tokens:\n consuming = 'none'\n else:\n consuming = tokens.popleft().lower()\n if consuming not in ('unit', 'faction', 'none'):\n raise SyntaxError('{}: invalid value'.format(line))\n self._consumer.order_consume(consuming=consuming,\n permanent=permanent, comment=comment)\n \n elif order == 'declare':\n if not tokens:\n raise SyntaxError('{}: missing faction'.format(line))\n fac = tokens.popleft().lower()\n if fac != 'default':\n fac = OrdersParser._value(fac)\n if not fac:\n raise SyntaxError('{}: missing faction'.format(line))\n if not tokens:\n self._consumer.order_declare(faction=fac, permanent=permanent,\n comment=comment)\n else:\n attitude = tokens.popleft().lower()\n if attitude in ('hostile', 'unfriendly', 'neutral',\n 'friendly', 'ally'):\n self._consumer.order_declare(faction=fac,\n attitude=attitude,\n permanent=permanent,\n comment=comment)\n else:\n raise SyntaxError('{}: invalid attitude'.format(line))\n \n elif order == 'describe':\n if tokens:\n target = tokens.popleft().lower()\n else:\n raise SyntaxError('{}: missing target'.format(line))\n if tokens:\n description = tokens.popleft()\n else:\n description = None\n if target == 'unit':\n self._consumer.order_describe(unit=description,\n permanent=permanent,\n comment=comment)\n elif target in ('ship', 'building', 'object', 'structure'):\n self._consumer.order_describe(structure=description,\n permanent=permanent,\n comment=comment)\n else:\n raise SyntaxError('{}: invalid target'.format(line))\n \n elif order == 'destroy':\n self._consumer.order_destroy(permanent=permanent, comment=comment)\n \n elif order == 'enter':\n if tokens:\n structure = OrdersParser._value(tokens.popleft())\n if dir:\n self._consumer.order_enter(structure=structure,\n permanent=permanent,\n comment=comment)\n else:\n raise SyntaxError('{}: invalid structure'.format(line))\n else:\n raise SyntaxError('{}: missing structure'.format(line))\n \n elif order == 'entertain':\n self._consumer.order_entertain(permanent=permanent, comment=comment)\n \n elif order == 'evict':\n targets = []\n try:\n while tokens:\n targets.append(OrdersParser._parse_unit(tokens))\n except SyntaxError as e:\n self._consumer.order_evict(targets=targets,\n permanent=permanent,\n comment=comment)\n raise SyntaxError('{}: {}'.format(line, e))\n else:\n self._consumer.order_evict(targets=targets,\n permanent=permanent,\n comment=comment)\n \n elif order == 'exchange':\n try:\n target = OrdersParser._parse_unit(tokens, allow_any=True)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n if not tokens:\n raise SyntaxError('{}: missing given amount'.format(line))\n amtGive = OrdersParser._value(tokens.popleft())\n if not tokens:\n raise SyntaxError('{}: missing given item'.format(line))\n itemGive = tokens.popleft().lower()\n if not tokens:\n raise SyntaxError('{}: missing expected amount'.format(line))\n amtExpected = OrdersParser._value(tokens.popleft())\n if not tokens:\n raise SyntaxError('{}: missing expected item'.format(line))\n itemExpected = tokens.popleft().lower()\n self._consumer.order_exchange(\n target=target, give={'amt': amtGive, 'item': itemGive},\n expected={'amt': amtExpected, 'item': itemExpected},\n permanent=permanent, comment=comment)\n \n elif order == 'faction':\n if not tokens:\n raise SyntaxError('{}: missing faction type'.format(line))\n ftype = {}\n while tokens:\n t = tokens.popleft().lower()\n if not tokens:\n raise SyntaxError('{}: invalid value'.format(line))\n ftype[t] = OrdersParser._value(tokens.popleft())\n self._consumer.order_faction(permanent=permanent, comment=comment,\n **ftype)\n \n elif order == 'find':\n if not tokens:\n raise SyntaxError('{}: missing faction'.format(line))\n fac = tokens.popleft().lower()\n if fac != 'all':\n fac = OrdersParser._value(fac)\n if not fac:\n raise SyntaxError('{}: invalid faction'.format(line))\n self._consumer.order_find(permanent=permanent, comment=comment,\n faction=fac)\n \n elif order == 'forget':\n if not tokens:\n raise SyntaxError('{}: missing skill'.format(line))\n self._consumer.order_forget(permanent=permanent, comment=comment,\n skill=tokens.popleft().lower())\n \n elif order == 'withdraw':\n if not tokens:\n raise SyntaxError('{}: missing amount'.format(line))\n tok = tokens.popleft().lower()\n amt = OrdersParser._value(tok)\n if amt < 1:\n amt = 1\n item = tok\n elif tokens:\n item = tokens.popleft().lower()\n else:\n raise SyntaxError('{}: missing item'.format(line))\n self._consumer.order_withdraw(permanent=permanent, comment=comment,\n amt=amt, item=item)\n \n elif order == 'give':\n try:\n target = OrdersParser._parse_unit(tokens)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n if not tokens:\n raise SyntaxError('{}: missing amount'.format(line))\n amt = tokens.popleft().lower()\n if amt == 'unit':\n self._consumer.order_give(permanent=permanent, comment=comment,\n target=target, give=amt)\n else:\n if amt != 'all':\n amt = OrdersParser._value(amt)\n if not amt:\n raise SyntaxError('{}: invalid amount'.format(line))\n try:\n item = tokens.popleft().lower()\n if item == 'unfinished':\n unfinished = True\n item = tokens.popleft().lower()\n else:\n unfinished = False\n except:\n raise SyntaxError('{}: missing item'.format(line))\n \n if tokens and tokens[0].lower() == 'except':\n tok = tokens.popleft().lower()\n if amt != 'all':\n raise SyntaxError(\n '{}: except only valid with all'. format(line))\n if not tokens:\n raise SyntaxError(\n '{}: missing except value'.format(line))\n excpt = OrdersParser._value(tokens.popleft())\n if not excpt:\n raise SyntaxError(\n '{}: invalid except value'.format(line))\n self._consumer.order_give(permanent=permanent,\n comment=comment,\n target=target,\n give={'amt': amt, 'item': item,\n 'unfinished': unfinished,\n 'excpt': excpt})\n else:\n self._consumer.order_give(permanent=permanent,\n comment=comment,\n target=target,\n give={'amt': amt, 'item': item,\n 'unfinished': unfinished})\n \n elif order == 'guard':\n if not tokens:\n raise SyntaxError('{}: invalid value'.format(line))\n try:\n guard = OrdersParser._parse_TF(tokens.popleft())\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n self._consumer.order_guard(flag=guard, permanent=permanent,\n comment=comment)\n \n elif order == 'hold':\n if not tokens:\n raise SyntaxError('{}: invalid value'.format(line))\n try:\n hold = OrdersParser._parse_TF(tokens.popleft())\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n self._consumer.order_hold(flag=hold, permanent=permanent,\n comment=comment)\n \n elif order == 'join':\n try:\n target = OrdersParser._parse_unit(tokens)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n if tokens:\n tok = tokens.popleft().lower()\n if tok == 'nooverload':\n self._consumer.order_join(target=target, nooverload=True,\n permanent=permanent,\n comment=comment)\n elif tok == 'merge':\n self._consumer.order_join(target=target, merge=True,\n permanent=permanent,\n comment=comment)\n else:\n self._consumer.order_join(target=target,\n permanent=permanent,\n comment=comment)\n else:\n self._consumer.order_join(target=target,\n permanent=permanent,\n comment=comment)\n \n elif order == 'leave':\n self._consumer.order_leave(permanent=permanent, comment=comment)\n \n elif order == 'move':\n try:\n dirs = [OrdersParser._parse_dir(d.lower()) for d in tokens]\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n else:\n self._consumer.order_move(dirs=dirs, permanent=permanent,\n comment=comment)\n \n elif order == 'name':\n if len(tokens) < 2:\n raise SyntaxError('{}: missing name'.format(line))\n what, name = tokens.popleft().lower(), tokens.popleft()\n if what == 'faction':\n self._consumer.order_name(permanent=permanent, comment=comment,\n faction=name)\n elif what == 'unit':\n self._consumer.order_name(permanent=permanent, comment=comment,\n unit=name)\n elif what in ('building', 'ship', 'object', 'structure'):\n self._consumer.order_name(permanent=permanent, comment=comment,\n structure=name)\n elif what in ('village', 'town', 'city') and \\\n OrdersParser._get_legal(name):\n self._consumer.order_name(permanent=permanent, comment=comment,\n city=OrdersParser._get_legal(name))\n else:\n raise SyntaxError('{}: invalid argument'.format(line))\n \n elif order == 'noaid':\n if not tokens:\n raise SyntaxError('{}: invalid value'.format(line))\n try:\n noaid = OrdersParser._parse_TF(tokens.popleft())\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n self._consumer.order_noaid(flag=noaid, permanent=permanent,\n comment=comment)\n \n elif order == 'nocross':\n if not tokens:\n raise SyntaxError('{}: invalid value'.format(line))\n try:\n nocross = OrdersParser._parse_TF(tokens.popleft())\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n self._consumer.order_nocross(flag=nocross, permanent=permanent,\n comment=comment)\n \n elif order == 'nospoils':\n if not tokens:\n raise SyntaxError('{}: invalid value'.format(line))\n try:\n spoils_none = OrdersParser._parse_TF(tokens.popleft())\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n if spoils_none:\n self._consumer.order_spoils(spoils='none', permanent=permanent,\n comment=comment)\n else:\n self._consumer.order_spoils(spoils='all', permanent=permanent,\n comment=comment)\n raise DeprecationWarning(\n '{}: deprecated. Use SPOILS instead'.format(line))\n \n elif order == 'option':\n if not tokens:\n raise SyntaxError('{}: missing option'.format(line))\n option = tokens.popleft().lower()\n if option == 'times':\n self._consumer.order_option(times=True, permanent=permanent,\n comment=comment)\n elif option == 'notimes':\n self._consumer.order_option(times=False, permanent=permanent,\n comment=comment)\n elif option == 'showattitudes':\n self._consumer.order_option(showunitattitudes=True,\n permanent=permanent,\n comment=comment)\n elif option == 'dontshowattitudes':\n self._consumer.order_option(showunitattitudes=False,\n permanent=permanent,\n comment=comment)\n elif option == 'template':\n if not tokens:\n raise SyntaxError('{}: missing template type'.format(line))\n temformat = tokens.popleft().lower()\n if temformat in ('off', 'short', 'long', 'map'):\n self._consumer.order_option(temformat=temformat,\n permanent=permanent,\n comment=comment)\n else:\n raise SyntaxError('{}: invalid template type'.format(line))\n else:\n raise SyntaxError('{}: invalid option'.format(line))\n \n elif order == 'password':\n if not tokens:\n self._consumer.order_password(password='none',\n permanent=permanent,\n comment=comment)\n else:\n self._consumer.order_password(password=tokens.popleft(),\n permanent=permanent,\n comment=comment)\n \n elif order == 'pillage':\n self._consumer.order_pillage(permanent=permanent, comment=comment)\n \n elif order == 'prepare':\n if not tokens:\n self._consumer.order_prepare(item=None,\n permanent=permanent,\n comment=comment)\n else:\n self._consumer.order_prepare(item=tokens.popleft().lower(),\n permanent=permanent,\n comment=comment)\n \n elif order == 'weapon':\n self._consumer.order_weapon(permanent=permanent, comment=comment,\n items=[w.lower() for w in tokens])\n \n elif order == 'armor':\n self._consumer.order_armor(permanent=permanent, comment=comment,\n items=[w.lower() for w in tokens])\n \n elif order == 'produce':\n if not tokens:\n raise SyntaxError('{}: missing item'.format(line))\n item = tokens.popleft().lower()\n if OrdersParser._value(item):\n if not tokens:\n raise SyntaxError('{}: missing item'.format(line))\n self._consumer.order_produce(target=OrdersParser._value(item),\n item=tokens.popleft().lower(),\n permanent=permanent,\n comment=comment)\n else:\n self._consumer.order_produce(item=item,\n permanent=permanent,\n comment=comment)\n \n elif order == 'promote':\n try:\n unit = OrdersParser._parse_unit(tokens)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n else:\n self._consumer.order_promote(unit=unit, permanent=permanent,\n comment=comment)\n \n elif order == 'quit':\n if not tokens:\n self._consumer.order_quit(permanent=permanent, comment=comment)\n else:\n self._consumer.order_quit(password=tokens.popleft(),\n permanent=permanent, comment=comment)\n \n elif order == 'restart':\n if not tokens:\n self._consumer.order_restart(permanent=permanent,\n comment=comment)\n else:\n self._consumer.order_restart(password=tokens.popleft(),\n permanent=permanent,\n comment=comment)\n \n elif order == 'reveal':\n if not tokens:\n self._consumer.order_reveal(reveal=None, permanent=permanent,\n comment=comment)\n else:\n tok = tokens.popleft().lower()\n if tok == 'none':\n self._consumer.order_reveal(reveal=None, comment=comment,\n permanent=permanent)\n elif tok in ('unit', 'faction'):\n self._consumer.order_reveal(reveal=tok, comment=comment,\n permanent=permanent)\n else:\n raise SyntaxError('{}: invalid value'.format(line))\n \n elif order == 'sail':\n try:\n dirs = [OrdersParser._parse_dir(d.lower(), allow_enter=False) \\\n for d in tokens]\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n else:\n self._consumer.order_sail(dirs=dirs, permanent=permanent,\n comment=comment)\n \n elif order == 'sell':\n if not tokens:\n raise SyntaxError('{}: missing amount'.format(line))\n num = tokens.popleft().lower()\n if num == 'all':\n num = OrdersParser.AMT_ALL\n else:\n num = OrdersParser._value(num)\n if not num:\n raise SyntaxError('{}: missing amount'.format(line))\n if not tokens:\n raise SyntaxError('{}: missing item'.format(line))\n self._consumer.order_sell(num=num, item=tokens.popleft().lower(),\n permanent=permanent, comment=comment)\n \n elif order == 'share':\n if not tokens:\n raise SyntaxError('{}: invalid value'.format(line))\n try:\n share = OrdersParser._parse_TF(tokens.popleft())\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n self._consumer.order_share(flag=share, permanent=permanent,\n comment=comment)\n \n elif order == 'show':\n try:\n what, item = tokens.popleft().lower(), tokens.popleft().lower()\n except IndexError:\n raise SyntaxError('{}: missing target'.format(line))\n if what == 'skill':\n self._consumer.order_show(permanent=permanent, comment=comment,\n skill=item)\n elif what == 'item':\n self._consumer.order_show(permanent=permanent, comment=comment,\n item=item)\n elif what == 'object':\n self._consumer.order_show(permanent=permanent, comment=comment,\n structure=item)\n else:\n raise SyntaxError('{}: invalid target'.format(line))\n \n elif order == 'spoils':\n if not tokens:\n tok = 'all'\n else:\n tok = tokens.popleft().lower()\n if tok in ('none', 'walk', 'fly', 'swim', 'sail', 'all'):\n self._consumer.order_spoils(spoils=tok, permanent=permanent,\n comment=comment)\n else:\n raise SyntaxError('{}: invalid option'.format(line))\n \n elif order == 'steal':\n try:\n unit = OrdersParser._parse_unit(tokens)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n if not tokens:\n raise SyntaxError('{}: missing item'.format(line))\n else:\n item = tokens.popleft().lower()\n self._consumer.order_steal(target=unit, item=item,\n permanent=permanent, comment=comment)\n \n elif order == 'study':\n if not tokens:\n raise SyntaxError('{}: missing skill'.format(line))\n sk = tokens.popleft().lower()\n if tokens:\n self._consumer.order_study(\n skill=sk, level=OrdersParser._value(tokens.popleft()),\n permanent=permanent, comment=comment)\n else:\n self._consumer.order_study(skill=sk, permanent=permanent,\n comment=comment)\n \n elif order == 'take':\n if not tokens or tokens.popleft().lower() != 'from':\n raise SyntaxError('{}: missing from'.format(line))\n if not tokens:\n raise SyntaxError('{}: missing unit'.format(line))\n unit = OrdersParser._value(tokens.popleft())\n if not unit:\n raise SyntaxError('{}: invalid unit'.format(line))\n target = {'unitnum': unit}\n if not tokens:\n raise SyntaxError('{}: missing amount'.format(line))\n amt = tokens.popleft().lower()\n if amt != 'all':\n amt = OrdersParser._value(amt)\n if not amt:\n raise SyntaxError('{}: invalid amount'.format(line))\n try:\n item = tokens.popleft().lower()\n if item == 'unfinished':\n unfinished = True\n item = tokens.popleft().lower()\n else:\n unfinished = False\n except:\n raise SyntaxError('{}: missing item'.format(line))\n \n if tokens and tokens[0].lower() == 'except':\n tok = tokens.popleft().lower()\n if amt != 'all':\n raise SyntaxError(\n '{}: except only valid with all'. format(line))\n if not tokens:\n raise SyntaxError(\n '{}: missing except value'.format(line))\n excpt = OrdersParser._value(tokens.popleft())\n if not excpt:\n raise SyntaxError(\n '{}: invalid except value'.format(line))\n self._consumer.order_takefrom(permanent=permanent,\n comment=comment,\n target=target,\n give={'amt': amt, 'item': item,\n 'unfinished': unfinished,\n 'excpt': excpt})\n else:\n self._consumer.order_takefrom(permanent=permanent,\n comment=comment,\n target=target,\n give={'amt': amt, 'item': item,\n 'unfinished': unfinished})\n \n elif order == 'tax':\n self._consumer.order_tax(permanent=permanent, comment=comment)\n \n elif order == 'teach':\n if not tokens:\n raise SyntaxError('{}: missing target'.format(line))\n targets = []\n try:\n while tokens:\n targets.append(OrdersParser._parse_unit(tokens))\n except SyntaxError as e:\n self._consumer.order_teach(targets=targets,\n permanent=permanent,\n comment=comment)\n raise SyntaxError('{}: {}'.format(line, e))\n else:\n self._consumer.order_teach(targets=targets,\n permanent=permanent,\n comment=comment)\n \n elif order == 'work':\n self._consumer.order_work(permanent=permanent, comment=comment)\n \n elif order == 'transport':\n try:\n target = OrdersParser._parse_unit(tokens)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n if not tokens:\n raise SyntaxError('{}: missing amount'.format(line))\n amt = tokens.popleft().lower()\n if amt != 'all':\n amt = OrdersParser._value(amt)\n if not amt:\n raise SyntaxError('{}: invalid amount'.format(line))\n try:\n item = tokens.popleft().lower()\n if item == 'unfinished':\n unfinished = True\n item = tokens.popleft().lower()\n else:\n unfinished = False\n except:\n raise SyntaxError('{}: missing item'.format(line))\n\n if tokens and tokens[0].lower() == 'except':\n tok = tokens.popleft().lower()\n if amt != 'all':\n raise SyntaxError(\n '{}: except only valid with all'. format(line))\n if not tokens:\n raise SyntaxError(\n '{}: missing except value'.format(line))\n excpt = OrdersParser._value(tokens.popleft())\n if not excpt:\n raise SyntaxError(\n '{}: invalid except value'.format(line))\n self._consumer.order_transport(permanent=permanent,\n comment=comment,\n target=target,\n give={'amt': amt, 'item': item,\n 'unfinished': unfinished,\n 'excpt': excpt})\n else:\n self._consumer.order_transport(permanent=permanent,\n comment=comment,\n target=target,\n give={'amt': amt, 'item': item,\n 'unfinished': unfinished})\n \n elif order == 'distribute':\n try:\n target = OrdersParser._parse_unit(tokens)\n except SyntaxError as e:\n raise SyntaxError('{}: {}'.format(line, e))\n if not tokens:\n raise SyntaxError('{}: missing amount'.format(line))\n amt = tokens.popleft().lower()\n if amt != 'all':\n amt = OrdersParser._value(amt)\n if not amt:\n raise SyntaxError('{}: invalid amount'.format(line))\n try:\n item = tokens.popleft().lower()\n if item == 'unfinished':\n unfinished = True\n item = tokens.popleft().lower()\n else:\n unfinished = False\n except:\n raise SyntaxError('{}: missing item'.format(line))\n \n if tokens and tokens[0].lower() == 'except':\n tok = tokens.popleft().lower()\n if amt != 'all':\n raise SyntaxError(\n '{}: except only valid with all'. format(line))\n if not tokens:\n raise SyntaxError(\n '{}: missing except value'.format(line))\n excpt = OrdersParser._value(tokens.popleft())\n if not excpt:\n raise SyntaxError(\n '{}: invalid except value'.format(line))\n self._consumer.order_distribute(permanent=permanent,\n comment=comment,\n target=target,\n give={'amt': amt, 'item': item,\n 'unfinished': unfinished,\n 'excpt': excpt})\n else:\n self._consumer.order_distribute(permanent=permanent,\n comment=comment,\n target=target,\n give={'amt': amt, 'item': item,\n 'unfinished': unfinished})","def _parseAttributeString(self, line):\n attribute, value = line.partition(' ')[::2]\n self._setAttribute(attribute, value)","def parse_line(line):\n\tpattern = re.compile(\"\"\"\n\t\t[ \\t]*\n\t\t(private|package|remote|public)*[ ]*\n\t\t(any|string|array|numeric|boolean|component|struct|void)*[ ]*\n\t\t(function[ ]+|\\<cffunction[ ]+name[ ]*=[ ]*\\\"?)([_\\-a-z][a-z0-9_\\-]+)\n\t\t\"\"\", \n\t\tre.VERBOSE|re.MULTILINE|re.IGNORECASE)\n\tm = pattern.match(line)\n\t#return the 5th gouped regex, which should be the function name\n\tret_val = m.group(4) if m else ''\n\treturn ret_val","def parse(self,line,mult,notifies):\n return 0","def _parseLine(self, line, delimiter = \":\"):\r\n\t\tsplt = line.split(delimiter)\r\n\t\tinVec = self._parseVec(splt[0])\r\n\t\toutVec = self._parseVec(splt[1])\r\n\t\tif (len(splt) == 2):\r\n\t\t\tlabel = \"\"\r\n\t\telse:\r\n\t\t\tlabel = splt[2]\r\n\t\tself.data.append({'in':inVec, 'out':outVec, 'label':label})","def parseApacheLogLine(logline):\r\n match = re.search(APACHE_ACCESS_LOG_PATTERN, logline) # Matching pattern with each element\r\n size_field = match.group(9) # Get size fields\r\n if size_field == '-': \r\n size = long(0) # make it zero\r\n else:\r\n size = long(match.group(9)) # else convert it to long format\r\n return (Row( # Return the extracted data in row format for easy access\r\n host = match.group(1),\r\n client_identd = match.group(2),\r\n user_id = match.group(3),\r\n date_time = parse_apache_time(match.group(4)),\r\n method = match.group(5),\r\n endpoint = match.group(6),\r\n protocol = match.group(7),\r\n response_code = int(match.group(8)),\r\n content_size = size\r\n ))","def parse(self, line):\n try:\n (year, month, day, hour, minute, second, microseconds, offset_hour, offset_minute, source, process, logentry) = re.match('^(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)T(\\d\\d):(\\d\\d):(\\d\\d)\\.([\\d]+)\\+(\\d\\d):(\\d\\d) ([a-z]+)\\[([a-zA-Z0-9_.]+)\\]: ([0-9a-z-A-Z\\-_\\.\\[\\]:\\?\\#\\\",/\\ ={}\\'\\(\\)<>]+)$', line).groups()\n except:\n pass\n \n try:\n parsed_data = dict()\n parsed_data['timestamp'] = \" \".join([\"-\".join([year, month, day]), \":\".join([hour, minute, second])])\n parsed_data['log_time'] = datetime.datetime(int(year), int(month), int(day), int(hour), int(minute), int(second))\n parsed_data['log_source'] = source\n parsed_data['log_type'] = process\n except (AttributeError, UnboundLocalError):\n PARSE_ERRORS.append(line)\n return False\n\n #TODO: This still needs work on spaces in values surrounded by \" \" \n if parsed_data['log_source'] == \"heroku\":\n if logentry.__len__() > 1:\n logentry = re.sub(', ', ',', logentry)\n line_chunks = re.split(' ', logentry)\n for chunk in line_chunks:\n line_chunks = re.split('=', chunk)\n if line_chunks.__len__() > 2:\n #fwd and path are a little clunky to parse\n pass\n elif line_chunks.__len__() > 1:\n parsed_data[line_chunks[0]] = line_chunks[1]\n else:\n pass\n else:\n return False\n else:\n # TODO: [app] \n # Needs parsing. Do that here.\n return False\n\n return parsed_data","def parse(self, line):\n\t\n\t# remove trailing newline a-la Perl CHOMP\n\tline = line.rstrip(\"\\n\")\n\n\t\n # correctly formatted PDB files\n # TODO - assuming 80 chars means well formatted is\n # perhaps risky. Need a more robust way to asses\n # formatting validity\n\n if len(line) == 80:\n self.record_name = line[0:6].strip()\n self.atom_id = int(line[6:11].strip())\n self.atom_name = line[12:16].strip()\n self.alt_location = line[16]\n self.res_name = line[17:20].strip()\n self.chain = line[21]\n self.res_id = line[22:26].strip()\n self.res_ins_code = line[26]\n self.coord_X = float(line[30:38].strip())\n self.coord_Y = float(line[38:46].strip())\n self.coord_Z = float(line[46:54].strip())\n self.occupancy = float(line[54:60].strip())\n self.beta = float(line[60:66].strip())\n self.seg_ID = line[72:76].strip()\n self.element = line[76:78].strip()\n\t if line[78:80].strip() == \"\":\n\t\t self.charge=0.0\n\t else:\n\t\t self.charge = float(line[78:80].strip())\n self.chain_local_id = -1\n self.formatted_ok = True\n\n # Heuristic section - split by space and then use\n # errors in casting as flags for things being issues\n # Note this may need to be expanded as malformed edge-cases\n # are identified...\n else:\n rawsplitline = filter(None, line.split(\" \"))\n\t \n\t \n\n splitline = []\n for i in rawsplitline:\n if i == \"\\n\" or i == \"\\t\":\n pass\n else:\n splitline.append(i)\n \n num_cols = len(splitline)\n\n\t print num_cols\n \n try:\n if num_cols == 10:\n self.record_name = splitline[0] \n self.atom_id = int(splitline[1])\n self.atom_name = splitline[2] \n self.alt_location = \"\"\n self.res_name = splitline[3] \n self.chain = \"\"\n self.res_id = int(splitline[4])\n self.res_ins_code = \"\"\n self.coord_X = float(splitline[5]) \n self.coord_Y = float(splitline[6]) \n self.coord_Z = float(splitline[7])\n self.occupancy = float(splitline[8])\n self.beta = float(splitline[9])\n self.seg_ID = \" \"\n self.element = \" \" \n self.charge = \" \"\n self.chain_local_id = -1\n self.formatted_ok = False\n\n elif num_cols == 11:\n self.record_name = splitline[0] \n self.atom_id = int(splitline[1])\n self.atom_name = splitline[2] \n self.alt_location = \" \"\n self.res_name = splitline[3] \n self.chain = splitline[4]\n self.res_id = int(splitline[5])\n self.res_ins_code = \" \"\n self.coord_X = float(splitline[6]) \n self.coord_Y = float(splitline[7]) \n self.coord_Z = float(splitline[8]) \n self.occupancy = float(splitline[9]) \n self.beta = float(splitline[10])\n self.seg_ID = \" \"\n self.element = \" \" \n self.charge = \" \"\n self.chain_local_id = -1\n self.formatted_ok = False\n\n elif num_cols == 12:\n self.record_name = splitline[0] \n self.atom_id = int(splitline[1])\n self.atom_name = splitline[2] \n self.alt_location = \" \"\n self.res_name = splitline[3] \n self.chain = splitline[4]\n self.res_id = int(splitline[5])\n self.res_ins_code = \" \"\n self.coord_X = float(splitline[6]) \n self.coord_Y = float(splitline[7]) \n self.coord_Z = float(splitline[8]) \n self.occupancy = float(splitline[9]) \n self.beta = float(splitline[10])\n self.seg_ID = \" \"\n self.element = splitline[11] \n self.charge = \" \"\n self.chain_local_id = -1\n self.formatted_ok = False\n else:\n raise PDB_atomException(\"Did not match number of columns\")\n except ValueError,e:\n print \"Error with columns (using \" + str(num_cols) + \") columns\"\n print \"Tried to cast string to int/float\"\n raise e","def parse_line(self, line):\n command, _, arg = line.strip().partition(\" \")\n return command, arg.strip()","def parse_line(self, line, time_shift=0.0):\n # The local variables are rather simple.\n # pylint: disable=too-many-locals\n try:\n date, time_, dir_or_size, name = line.split(None, 3)\n except ValueError:\n # \"unpack list of wrong size\"\n raise ftputil.error.ParserError(\"line '{}' can't be parsed\".format(line))\n # st_mode\n # Default to read access only; in fact, we can't tell.\n st_mode = 0o400\n if dir_or_size == \"<DIR>\":\n st_mode = st_mode | stat.S_IFDIR\n else:\n st_mode = st_mode | stat.S_IFREG\n # st_ino, st_dev, st_nlink, st_uid, st_gid\n st_ino = None\n st_dev = None\n st_nlink = None\n st_uid = None\n st_gid = None\n # st_size\n if dir_or_size != \"<DIR>\":\n try:\n st_size = int(dir_or_size)\n except ValueError:\n raise ftputil.error.ParserError(\"invalid size {}\".format(dir_or_size))\n else:\n st_size = None\n # st_atime\n st_atime = None\n # st_mtime\n st_mtime, st_mtime_precision = self.parse_ms_time(\n date, time_, time_shift, with_precision=True\n )\n # st_ctime\n st_ctime = None\n stat_result = StatResult(\n (\n st_mode,\n st_ino,\n st_dev,\n st_nlink,\n st_uid,\n st_gid,\n st_size,\n st_atime,\n st_mtime,\n st_ctime,\n )\n )\n # These attributes are kind of \"half-official\". I'm not sure whether\n # they should be used by ftputil client code.\n # pylint: disable=protected-access\n # _st_name and _st_target\n stat_result._st_name = name\n stat_result._st_target = None\n # mtime precision in seconds\n stat_result._st_mtime_precision = st_mtime_precision\n return stat_result","def parseline(self, line):\n line = line.strip()\n if not line:\n return None, None, line\n elif line[0] == '?':\n line = 'help ' + line[1:]\n elif line[0] == '!':\n if hasattr(self, 'do_shell'):\n line = 'shell ' + line[1:]\n else:\n return None, None, line\n return '', '', line","def __init__(self, line):\n # Throw an exception if we don't see the parenthesis that mark a date entry\n if not line[108] == '(':\n raise ParsingException\n if not line[164:165] == ')':\n raise ParsingException\n\n # Parsing definitions\n self.start_time = datetime.strptime(line[109:125], '%d-%b-%Y %H%M')\n self.end_time = datetime.strptime(line[128:144], '%d-%b-%Y %H%M')\n self.time_stamp = datetime.strptime(line[148:164], '%m/%d/%Y %H:%M')","def next_line(self, context, line):","def parse_line(line):\n return parse('#{id_:d} @ {x:d},{y:d}: {w:d}x{h:d}', line)","def parseLine(line):\n\n\teq = line.find('=')\n\tif eq == -1: raise Exception()\n\tkey = line[:eq].strip()\n\tvalue = line[eq+1:-1].strip()\n\treturn key, parseValue(value)","def process_idx_file_line(self, line):\n pass","def parse_mod_entry(self, line):\n split_line = line.split(' ')\n enable = split_line.pop(0)\n path = split_line.pop()\n version = split_line.pop()\n name = split_line.pop()\n return enable, name, version, path","def _parse(self, line):\n comd, value = cmd.parse(line, CLIENT_PREFIX)\n if comd == 'reg':\n self.peername = value\n elif comd == 'eof':\n self._reset()\n msg = cmd.clientcmd(comd, value)\n msg = cmd.addFirst(msg, self.peername)\n self.sendString(msg)\n elif comd == 'fail':\n self._reset()\n else:\n return False\n return True","def parse_user_dict(self, line):\n pass","def parseLine(self, line):\n # Removes surrounding whitespace\n line = self.separateElements(line)\n if len(line) == 0: return\n # Checks if the line is a label declaration\n if line[0].lower() == \"label\":\n # --Validates the line\n if len(line) != 2: raise Exception(\"Invalid Label\")\n if len(line[1]) < 2: raise Exception(\"Invalid Label\") \n if line[1][-1] != ':': raise Exception(\"Invalid Label\")\n # Gets the label name\n labelName = line[1][:-1]\n\n # Creates a new symbol entry for the label, the pointer refers to the memory location of the label\n # It defaults to the location of the label in the instruction sequence\n self.symbolTable.append({ \"type\": \"LABEL\", \"name\": labelName, \"pointer\": len(self.instructionList) * 4})\n # Checks if the line is data declaration\n elif line[0].lower() == \"data\" or (line[0].lower()[:4] == \"data\" and line[0][4] == \"[\"):\n # Removes the DATA tag from the data\n line[0] = line[0][4:]\n # --Validates the line\n if len(line) < 2: raise Exception(\"Invalid DATA\")\n # Gets the data name\n dataName = line[1]\n # Stores the data length\n dataLength = 4 # A word\n # Gets any default data\n defaultData = 0\n # Stores the data type\n dataType = \"int\"\n if len(line) == 3:\n if line[2][0] == \"\\\"\" and line[2][-1] == \"\\\"\":\n dataType = \"string\"\n defaultData = line[2][1:-1]\n dataLength = len(defaultData)\n elif line[2].isnumeric():\n defaultData = line[2]\n elif line[2][-1] == 'f' and line[2][:-1].isnumeric():\n dataType = \"float\"\n defaultData = line[2][0]\n # Checks if a data length was given\n if len(line[0]) > 2 and (line[0][0] == \"[\" and line[0][-1] == \"]\"):\n data = line[0][1:-1]\n if not data.isnumeric(): raise TypeError(\"Invalid data length type\")\n dataLength = int(data)\n\n # Creates a new symbol entry for the data\n self.symbolTable.append({ \"type\": \"DATA\", \"name\": dataName, \"default\": defaultData, \"dataType\": dataType, \"length\": dataLength})\n # The line is most likely an instruction\n else:\n # --Validates the line\n #Stores the control bits\n controlBits = 1 << 5 # Sets it to 0b100000\n # Checks if the first element is control bits\n if line[0][0] == \"{\" and line[0][-1] == \"}\": # First element is control bits\n # Separates the two sections of the control bits\n controlSections = line[0].split(':')\n #Goes through the characters and constructs the control bits for the instruction\n carryBits = controlSections[0].lower()\n carryFlag = int('c' in carryBits)\n zeroFlag = int('z' in carryBits)\n negativeFlag = int('n' in carryBits)\n signedOverflowFlag = int('s' in carryBits)\n #Gets the conditions bits\n if len(controlSections) == 2:\n conditionBits = controlSections[1].lower()\n isAnd = int('x' in conditionBits)\n isOne = int('1' in conditionBits)\n #Sets the last two bits on controlBits to the conditionBits\n controlBits ^= isAnd << 1\n controlBits ^= isOne\n # Constructs the control bits section\n controlBits ^= carryFlag << 5\n controlBits ^= zeroFlag << 4\n controlBits ^= negativeFlag << 3\n controlBits ^= signedOverflowFlag << 2\n # Removes the control bits section from the line\n line.pop(0)\n # Performs this check as the controlbits element gets removed (if it existed) and so the length of the elments could be zerp\n if len(line) == 0: raise Exception(\"Invalid Instruction\")\n # --The first element is the instruction\n # Identifies the instruction from the mnemonic using the lookup table\n if line[0] in self.InstructionLookupTable:\n ins = self.InstructionLookupTable[line[0]]\n insCode = ins[\"code\"]\n insControlBits = ins['controlBits'] if ins['controlBits'] else controlBits\n # Creates a representation of the instruction, this is stored in the instructionList and is assembled later\n instrucitonRepr = {\n \"code\": insCode,\n \"controlBits\": insControlBits,\n }\n # Parses the arguments given and stores the operandStruct returned in the instruciton representation\n if len(line) > 1: instrucitonRepr[\"operand\"] = self.parseArgs(line[1:], insCode)\n self.instructionList.append(instrucitonRepr)","def _parse(self, line):\n comd, value = cmd.parse(line, SERVER_PREFIX)\n player = self.player\n if comd == 'play':\n audio, seek = cmd.separate(value)\n player.playFile(audio, seek=float(seek))\n newline = 'Player started playing %s' %(value)\n elif comd == 'seek':\n value = float(value)\n player.seekto(value)\n newline = 'Forwared to %d seconds' %(value)\n elif comd == 'pause':\n player.pause()\n newline = 'Player Paused'\n elif comd == 'volume':\n value = float(value)\n player.volume = value\n newline = 'Volume changed to %d' %(value)\n else:\n return line\n return newline","def parse_line(line):\n if len(line) < 11:\n exit(\"invalid Intel HEX line: %s\" % line)\n if line[0] != ':':\n exit(\"invalid Intel HEX line: %s\" % line)\n line = line[1:]\n try:\n int(line, 16)\n except ValueError:\n exit(\"invalid Intel HEX line: %s\" % line)\n line = line.decode('hex')\n return Line(line[0], line[1:3], line[3], line[4:-1], line[-1])","def _parse_line(self, line):\n with open(self._manifest.path, 'r') as manifest_file:\n if isinstance(line, str):\n assert line in self.BASE_INFORMATION.keys(), \\\n 'An attempt to get non-existent information from the manifest'\n for _ in range(self.BASE_INFORMATION[line]):\n fline = manifest_file.readline()\n return json.loads(fline)[line]\n else:\n assert self._index, 'No prepared index'\n offset = self._index[line]\n manifest_file.seek(offset)\n properties = manifest_file.readline()\n return json.loads(properties)","def _parse_general_info(self, line):\n if self._regex_helper.search_compiled(W._re_general_info, line):\n self.current_ret['GENERAL_INFO'].update({\n 'time': datetime.datetime.strptime(self._regex_helper.group(\"TIME\"), '%H:%M:%S').time(),\n 'uptime': self._regex_helper.group(\"UPTIME\"),\n 'user_number': self._regex_helper.group(\"USER_NUMBER\"),\n 'load_average': self._regex_helper.group(\"L_AVERAGE\")\n })\n raise ParsingDone","def getLineInformation(line):\n \n pass","def _parse(line: str) -> Tuple[int, str, str, bool]:\n level, tag, args = None, None, None\n try:\n # Try to split the line into three parts, then try two parts\n try:\n level, tag, args = line.split(' ', maxsplit=2)\n except ValueError:\n try:\n level, tag = line.split(' ', maxsplit=1)\n except ValueError:\n raise InvalidLineException(f'Invalid line: {line}')\n\n # INDI nor FAM should not be the tag\n if tag in ('INDI', 'FAM'):\n raise InvalidLineException(f'Invalid tag {line}')\n\n # If INDI or FAM are args, swap the args and tag\n if args in ('INDI', 'FAM'):\n temp = args\n args = tag\n tag = temp\n\n # Level must be between 0 and 2 inclusive\n if level not in ('0', '1', '2'):\n raise InvalidLineException(f'Invalid level: {level}')\n level = int(level)\n\n # Allow a trailing space\n if args == '':\n args = None\n\n if tag == 'INDI':\n assert level == 0\n assert args is not None\n elif tag == 'NAME':\n assert level == 1\n assert args is not None\n elif tag == 'SEX':\n assert level == 1\n assert args in ('M', 'F')\n elif tag == 'BIRT':\n assert level == 1\n assert args is None\n elif tag == 'DEAT':\n assert level == 1\n assert args is None\n elif tag == 'FAMC':\n assert level == 1\n assert args is not None\n elif tag == 'FAMS':\n assert level == 1\n assert args is not None\n elif tag == 'FAM':\n assert level == 0\n assert args is not None\n elif tag == 'MARR':\n assert level == 1\n assert args is None\n elif tag == 'HUSB':\n assert level == 1\n assert args is not None\n elif tag == 'WIFE':\n assert level == 1\n assert args is not None\n elif tag == 'CHIL':\n assert level == 1\n assert args is not None\n elif tag == 'DIV':\n assert level == 1\n assert args is None\n elif tag == 'DATE':\n assert level == 2\n assert args is not None\n # Date must have valid args\n try:\n day, month, year = args.split(' ', maxsplit=2)\n except ValueError:\n raise InvalidLineException(f'Not enough values for DATE: {args}')\n assert day == '0' or not day[0] == '0' and day.isdigit()\n assert month in ('JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC')\n assert len(year) == 4 and year.isdigit()\n elif tag == 'HEAD':\n assert level == 0\n assert args is None\n elif tag == 'TRLR':\n assert level == 0\n assert args is None\n elif tag == 'NOTE':\n assert level == 0\n else:\n raise InvalidLineException(f'Unknown Tag: {tag}')\n except (AssertionError, InvalidLineException):\n return level, tag, args, False\n\n return level, tag, args, True","def from_line(self, line: str):\n raise NotImplementedError()","def read_line(line):\n label = line[0:11]\n text = line[11:]\n y = 1 if label == '__label__2 ' else 0\n return text, y","def __call__( self, line ):\n return self.__getitem__( line )","def __call__( self, line ):\n return self.__getitem__( line )","def _parse_file_line(line):\n # match initially added ebuilds\n match = ebuild_ADM_regex.match(line)\n if match:\n status = match.group('status')\n category = match.group('category')\n pkg = match.group('P')\n try:\n return atom_cls(f'={category}/{pkg}'), status\n except MalformedAtom:\n return None\n\n # match renamed ebuilds\n match = ebuild_R_regex.match(line)\n if match:\n status = match.group('status')\n category = match.group('category')\n pkg = match.group('P')\n try:\n return atom_cls(f'={category}/{pkg}'), status\n except MalformedAtom:\n return None","def _read_addenda_record(self, line):\n addenda_dict = {'Addenda Type Code:': line[1:3],\n 'Payment Related Info': line[3:83].strip(),\n 'Addenda Sequence Number': line[83:87],\n 'Entry Detail Sequence Number': line[87:94]}\n self.addenda_records.append(addenda_dict)","def parse_line(line, key):\n keys = key.split(', ')\n ParseLine = (line.get(id) for id in keys)\n\n return ParseLine","def __parseLine(line):\n\n # extract name\n name_len = line.index(\" \")\n name = line[:name_len]\n line = line[name_len + 3:]\n\n # array-ize 'electron' val\n elec_pos = line.index(\"electron\") + 9\n line = line[:elec_pos] + '[' + line[elec_pos:].replace(' ', ',') + ']'\n\n # quote 'small' val\n line = line.replace(' ', '')\n line = line.replace('small:', 'small:\"').replace(',molar', '\",molar')\n\n # quote all keys\n for i in [\"position\", \"number\", \"small\", \"molar\", \"electron\"]:\n line = line.replace(i, '\"' + i + '\"')\n\n return eval('{\"name\":\"' + name + '\",' + line + '}')","def parse_line(self, line):\n if self.signal_eof:\n return \"\"\n\n match = re.search(\"^([\\w\\s]+from) ([^:]+):(\\d+)(:|,)$\", line)\n if match:\n return self.parse_line_from(match)\n\n match = re.search(\"^([^:]+):(?:((?:\\d+:)?\\d+):)?(?:(error|warning|note):)?(.+)$\", line)\n if match:\n return self.parse_line_err(match)\n\n return line","def process_line(line: str):\n \n comment_start = line.find(';')\n\n # Remove comments, one comment per line allowed\n if comment_start != -1:\n line = line[:comment_start]\n\n line = line.strip()\n \n # Splits commands such that the command and all details are seperated\n # \"command ...\" -> [command, ...]\n try:\n command, contents = line.split(maxsplit = 1)\n # Deals with function names, two special commands, and empty lines\n except ValueError:\n if line == '':\n return None\n elif line[-1] == ':' or line == 'end' or line == 'ret':\n return (line,)\n\n # Splits depending on command type, some requiring one argument, others two\n try:\n one, two = contents.split(',')\n return command, one.strip(), two.strip()\n except ValueError:\n return command, contents.strip()","def read_line(self, line):\n line_in_asm_array = list()\n documentation = [\"//\" + line]\n line_in_asm_array.extend(documentation)\n command_type = Parser.commandType(line)\n\n # not supposed to happen:\n # if command_type is None:\n # print(\"problem\")\n\n self.update_last_function(line, command_type)\n translated_lines = self.get_correct_lines(command_type, line)\n\n self.label_counter = self.label_counter + 1\n line_in_asm_array.extend(translated_lines)\n self.assembler_lines.append(line_in_asm_array)","def readline(self) -> str | None:","def parse_line(line):\n log_line = LogLine(line)\n dt = datetime.datetime.strptime(log_line.line[0], \"%Y-%m-%d %H:%M:%S\")\n # make a tuple with dt and the rest (splatted)\n return (dt, *log_line.line[1:])","def parser(line):\n # Remove comment and whitespace\n line = re.sub(r'//.*', '' , line) # remove comment\n line = line.strip() # remove whitespace\n\n # Parse A instruction, return int or string\n if line.find('@') == 0:\n try:\n parsed = int(line[1:])\n flag = \"A_DECIMAL\"\n except:\n parsed = line[1:]\n flag = \"A_INSTRUCTION\"\n\n elif line.startswith(\"(\") and line.endswith(\")\"):\n parsed = line[1:-1]\n flag = \"GOTO_INSTRUCTION\"\n else:\n # Parse C instruction, return tuple\n if line.find(';') != -1:\n comp, jump = line.split(';') # comp ; jump\n dest = \"null\"\n if comp.find('=') != -1:\n dest, comp = comp.split('=') # dest = comp ; jump\n parsed = comp, dest, jump\n flag = \"C_INSTRUCTION\"\n\n elif line.find('=') != -1:\n dest, comp = line.split('=') # dest = comp\n jump = \"null\"\n parsed = comp, dest, jump\n flag = \"C_INSTRUCTION\"\n else:\n parsed = None\n flag = None\n\n return parsed, flag","def parse_line(cls, line):\n assert isinstance(line, bytes)\n\n match = HEADER_FIELD_REGEX.match(line)\n\n if not match:\n raise HeaderParseError(line)\n\n name, content = (s.decode(\"ascii\").strip() for s in match.groups(b\"\"))\n name = name.lower()\n\n if name != \"set-cookie\" or is_rfc1123_datetime(content):\n content = cls.split_field_content(content)\n\n return (name, content)","def parseInputLine(self, line):\r\n if line is not None and line is not '':\r\n func = getattr(self, 'cmd_' + line.split()[0].upper(), None)\r\n if func is not None:\r\n func(line.split()[1:])\r\n else:\r\n self.terminal.write('No such command')\r\n self.showPrompt()","def _parse_single_line(self, statement_line: str) -> List[str]:\r\n space_split = statement_line.split(\" \")\r\n\r\n ref = int(space_split[0])\r\n\r\n transaction_date = \" \".join(space_split[1:3])\r\n\r\n post_date = \" \".join(space_split[3:5])\r\n\r\n # find column of the amount\r\n col_amount = -1\r\n while len(space_split[col_amount]) < 1:\r\n col_amount -= 1\r\n amount = space_split[col_amount]\r\n amount = self._convert_amount_to_float(amount=amount)\r\n\r\n details = \" \".join(space_split[5:col_amount])\r\n return ref, transaction_date, post_date, details, amount","def process_line(self, line):\n columns = line.split('|')\n\n if len(line) == 0 or len(columns) < 16:\n return None # empty line or malformed line\n\n cmte_id, name, zip_code = columns[0], columns[7], columns[10][:5]\n transaction_dt, transaction_amt = columns[13], columns[14]\n other_id = columns[15]\n\n if len(other_id) > 0 or len(transaction_amt) == 0 or len(cmte_id) == 0 or len(name) == 0 or len(zip_code) < 5:\n return None # malformed data fields, ignore this line\n transaction_date = string_to_date(transaction_dt)\n if transaction_date is None:\n return None # 'TRANSACTION_DT' is an invalid date\n\n try:\n if self.repeat_donor(name, zip_code, transaction_date.year):\n # this record is from a repeat donor in any prior calendar year\n amount = float(transaction_amt)\n key = RecipientZipYear(cmte_id, zip_code, transaction_date.year)\n if key not in self.running_percentile:\n self.running_percentile[key] = RunningPercentile(self.percentile)\n self.running_percentile[key].add(amount)\n return self.print_record(key)\n else:\n return None # this record is not from a repeat donor\n except:\n return None # exception may comes from malformed line, so just ignore this line","def parse (self, line):\n result = self.program.parseString (line)\n return TranQL_AST (result.asList (), self.backplane)","def _next_record(self, next_line):\n record = self.loader.parse_record_stream(self.reader,\n next_line,\n self.known_format)\n\n self.member_info = None\n\n # Track known format for faster parsing of other records\n self.known_format = record.format\n\n return record","def parse(self, input):\n pass","def parse_line(self, line: str, src_ntypes=None, adj_ntypes=None, etypes=None, prev_data: PrevData = None, verbose=__debug__):\r\n\r\n if prev_data:\r\n prev_src_data, prev_adj_data = prev_data\r\n if not line:\r\n if prev_adj_data:\r\n prev_src_data.update(prev_adj_data)\r\n return prev_src_data\r\n line = line.lstrip()\r\n if line[0].startswith(self.comment_indicator):\r\n return None, prev_data\r\n prev_data = bool(prev_data)\r\n else:\r\n ensure_arg_not_none_or_empty(arg_val=line, arg_name='line', extra_msg='the input graph adjacency/path line to parse is empty')\r\n line = line.lstrip()\r\n if line[0].startswith(self.comment_indicator):\r\n return None\r\n\r\n splits = line.split(self.node_sep)\r\n if len(splits) <= 1:\r\n raise ValueError(f\"the string `{line}` does not seen to describe an adjacency list or a path, while using `{self.node_sep}` as the delimiter\")\r\n try:\r\n data_entry = self._parse_by_format2(key_prefix='src_', format_obj=self.source_node_format, format_type=self._source_node_format_type, text=splits[0])\r\n use_prev_data: bool = prev_data and prev_src_data is not None and data_entry['src_nid'] == prev_src_data['src_nid']\r\n except Exception as err:\r\n raise extra_msg(err,\r\n f\"a source node cannot be parsed from the string `{splits[0]}`; the whole line to parse is `{line}`\")\r\n\r\n if src_ntypes is None or data_entry.get('src_ntype', None) in src_ntypes: # applies the source node type filter\r\n adj_data = prev_adj_data if use_prev_data and prev_adj_data is not None else PaddedListDict()\r\n for adj_node_edge_str in splits[1:]:\r\n cur_adj_data = self._parse_by_format2(key_prefix='adj_', format_obj=self.adj_node_format, format_type=self._adj_node_format_type, text=adj_node_edge_str)\r\n if (adj_ntypes and cur_adj_data.get('adj_ntype', None) not in adj_ntypes) or (etypes and cur_adj_data.get('adj_etype', None) not in etypes):\r\n continue\r\n adj_data += cur_adj_data\r\n\r\n if prev_data:\r\n if use_prev_data:\r\n data_entry.update(prev_src_data)\r\n return None, (data_entry, adj_data)\r\n else:\r\n if prev_adj_data:\r\n prev_src_data.update(prev_adj_data)\r\n return prev_src_data, (data_entry, adj_data)\r\n else:\r\n if adj_data:\r\n data_entry.update(adj_data)\r\n return data_entry\r\n else:\r\n return None\r\n else:\r\n if prev_data:\r\n if use_prev_data:\r\n return None, (prev_src_data, prev_adj_data)\r\n else:\r\n if prev_adj_data:\r\n prev_src_data.update(prev_adj_data)\r\n return prev_src_data, (None, None)\r\n else:\r\n return None","def process_line(self, line):\n for char in line:\n if self.current_state == 1:\n\n if char == \"{\":\n self.current_state = 2 # Comment\n elif char == \":\":\n self.set_type = \", Assign\"\n self.set_value = char\n self.current_state = 3 # Assign\n elif char in self.letters:\n self.set_type = \", Identifier\"\n self.set_value = char\n self.current_state = 4 # Identifier\n elif char in self.digits:\n self.set_type = \", Number\"\n self.set_value = char\n self.current_state = 5 # Number\n elif char in self.special_symbols:\n self.set_type = \", SpecialSymbol\"\n self.set_value = char\n self.tokens.append(self.set_value + self.set_type) # Done\n self.current_state = 1\n elif char != \" \" and char != \"\\n\":\n self.current_state = -1\n elif self.current_state == 2:\n\n if char == \"}\":\n self.current_state = 1\n self.set_value = \"\"\n elif self.current_state == 3:\n\n if char == \"=\":\n self.set_value += char\n self.tokens.append(self.set_value + self.set_type) # Done\n self.current_state = 1\n else:\n self.current_state = -1\n elif self.current_state == 4:\n\n if char in self.letters:\n self.set_value += char\n else: # Done\n self.current_state = 1\n if self.set_value in self.reserverd_words:\n self.set_type = \", Reserverd Word\"\n self.tokens.append(self.set_value + self.set_type) # Done\n elif self.current_state == 5:\n\n if char in self.digits:\n self.set_value += char\n else: # Done\n self.tokens.append(self.set_value + self.set_type)\n self.current_state = 1\n # elif self.current_state == 6:\n #\n #\n # self.tokens.append(self.set_value + self.set_type)\n # self.current_state = 1","def parseMonitorLog(log_file, attack_props):\n if not os.path.exists(log_file):\n return\n report = open(log_file, 'r')\n lines = report.readlines()\n #print lines\n report.close()\n \n readingStations = False\n readingAps = False\n for line in lines:\n line = line.strip()\n #print line\n if not readingStations and not readingAps:\n if line.startswith(\"BSSID\"):\n readingAps = True\n continue\n elif line.startswith(\"Station\"):\n readingStations = True\n continue\n elif readingAps:\n if len(line) < 4:\n readingAps =False\n else:\n fields = line.split(',')\n #print fields\n ap_mac = fields[0].strip()\n if attack_props.hasAP(ap_mac):\n ap = attack_props.getActiveAP(ap_mac)\n else:\n ap = AccessPoint(ap_mac, attack_props.log_path)\n attack_props.addActiveAP(ap)\n ap.update(fields)\n elif readingStations and len(line) > 4:\n fields = line.split(',')\n station_mac = fields[0].strip()\n ap_mac = fields[5].strip()\n if attack_props.hasAP(ap_mac):\n ap = attack_props.getAP(ap_mac) \n if ap.stations.has_key(station_mac):\n station = ap.stations[station_mac]\n else:\n station = Station(station_mac)\n ap.stations[station_mac] = station\n station.ap = station\n station.update(fields)","def parse(lines):\n if len(lines) == 0:\n return (None, lines)\n title = lines[0]\n if len(title) > 0 and \"*\" == title[0]:\n level = 1\n while title[level] == \"*\":\n level = level + 1\n if title[level] != \" \":\n return (None, lines)\n else:\n heading = title[level+1:]\n todo = heading[:4] == \"TODO\"\n done = heading[:4] == \"DONE\"\n if todo or done:\n heading = heading[4:]\n return (ORGSection(heading.strip(), level=level, TODO=todo, DONE=done), lines[1:])\n else:\n return (None, lines)","def _scan_alignment(self,handle, consumer):\n while 1:\n line = handle.readline()\n if not line:\n break\n if is_blank_line(line):\n continue\n else:\n consumer.query_alignment(line)\n read_and_call(handle, consumer.positive_alignment)\n read_and_call(handle, consumer.hit_alignment)","def _read_file_control_record(self, line):\n self.file_control_record = {'Batch Count': int(line[1:7]),\n 'Block Count': int(line[7:13]),\n 'Addenda Count': int(line[13:21]),\n 'Entry Hash': line[21:31],\n 'Total Debit Amount': int(line[31:43]) / 100,\n 'Total Credit Amount': int(line[43:55]) / 100,\n 'Reserved Data': line[55:94].strip()}","def test_parse_consumer_address_1_field(self):\n fields = {'Consumer Address 1': {'offset': 81,\n 'length': 30}}\n p = top.Parser(fields=fields)\n received = p.parse_line(self._line)\n expected = {'Consumer Address 1': '51 Westbourne St.'}\n msg = 'Consumer Address 1 field parse incorrect'\n self.assertEqual(received, expected, msg)","def test_with_one_member_only(self, entries, errors, __):\n self.assertEqualEntries(\"\"\"\n 2011-05-17 open Expenses:Restaurant:Martin\n\n 2011-05-17 * \"Something\"\n Expenses:Restaurant:Martin 2.00 USD\n Assets:Cash -2.00 USD\n \"\"\", entries)","def process_line(line: str) -> Instruction:\n register, op, value, _, base, check, limit = line.split()\n return Instruction(register, op, int(value), base, check, int(limit))","def parse_ability_triggering(line: str):\n return [0, 1]","def _analyzeLine(self, line, date, data):\n user = re.search(': (.*)', line).group().split()[1]\n data[user].add(ConvertTime(date, line))","def parseStmt(line):\n print(\"Statement\")\n index=0\n if line[0] == 's':\n print(\"Set\")\n index += 4\n rest = line[index:]\n cmds = str.split(rest, ',')\n parseSet(cmds)\n elif line[0] == 'h':\n exit()\n elif line[0] == 'j':\n index += 5\n if line[index] == ' ':\n print(\"Jumpt\")\n index += 1\n rest = line[index:]\n cmds = str.split(rest, ',')\n parseJumpt(cmds)\n else:\n print(\"Jump\")\n rest = line[index:]\n cmds = str.split(rest, ',')\n parseJump(cmds)\n else:\n print(\"Invalid Operation\")","def parse(line, half=1):\n line = line.strip()\n logger.debug(\"LINE '%s'\", line)\n\n global aipname, alonging, ats_chapter, coords_wrap, obj, feature\n global features, finalcoord, lastn, laste, lastv, airsport_intable\n global border, re_coord3, country\n global sectors, name_cont, cold_resp\n\n if line==LINEBREAK:\n # drop current feature, if we don't have vertl by now,\n # then this is just an overview polygon\n feature = {\"properties\":{}}\n obj = []\n alonging = False\n coords_wrap = \"\"\n lastv = None\n return\n\n\n if ad_aip and not \"ENNO\" in filename:\n if not ats_chapter:\n # skip to chapter 2.71\n if \"ATS airspace\" in line or \"ATS AIRSPACE\" in line:\n logger.debug(\"Found chapter 2.71\")\n ats_chapter=True\n return\n else:\n # then skip everything after\n if \"AD 2.\" in line or \"ATS COMM\" in line:\n #if \"ATS komm\" in line or \"Kallesignal\" in line:\n logger.debug(\"End chapter 2.71\")\n ats_chapter=False\n\n class_=re_class.search(line) or re_class2.search(line) or re_class_openair.search(line)\n if class_:\n logger.debug(\"Found class in line: %s\", line)\n class_=class_.groupdict()\n feature['properties']['class']=class_.get('class')\n if tia_aip:\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n return\n\n # SPECIAL CASE temporary workaround KRAMFORS\n if aipname and (\"KRAMFORS\" in aipname) and (\"within\" in line):\n return\n # SPECIAL CASE workaround SÄLEN/SAAB CTR sectors\n if aipname and ((\"SÄLEN\" in aipname) or (\"SAAB\" in aipname)) and (\"Sector\" in line):\n logger.debug(\"TEST: Breaking up SÄLEN/SAAB, aipname=.\"+aipname)\n sectors.append((aipname, obj))\n feature, obj = {\"properties\":{}}, []\n if \"SÄLEN\" in aipname:\n aipname = \"SÄLEN CTR \"+line\n else:\n aipname = \"SAAB CTR \"+line\n # SPECIAL CASE check for Valldal AIP names\n if valldal and 'Valldal' in line:\n aipname=\" \".join(line.strip().split()[0:2])\n logger.debug(\"Valldal aipname: '%s'\", aipname)\n feature['properties']['class']='Luftsport'\n feature['properties']['from (ft amsl)']=0\n feature['properties']['from (m amsl)'] =0\n\n coords = re_coord.search(line)\n coords2 = re_coord2.search(line)\n coords3 = re_coord3.findall(line)\n\n if (coords or coords2 or coords3):\n\n logger.debug(\"Found %i coords in line: %s\", coords3 and len(coords3) or 1, line)\n logger.debug(printj(coords3))\n if line.strip()[-1] == \"N\":\n coords_wrap += line.strip() + \" \"\n logger.debug(\"Continuing line after N coordinate: %s\", coords_wrap)\n return\n elif coords_wrap:\n nline = coords_wrap + line\n logger.debug(\"Continued line: %s\", nline)\n coords = re_coord.search(nline)\n coords2 = re_coord2.search(nline)\n coords3 = re_coord3.findall(nline)\n logger.debug(\"Found %i coords in merged line: %s\", coords3 and len(coords3) or '1', nline)\n line = nline\n coords_wrap = \"\"\n\n if coords and not (\"Lyng\" in aipname or \"Halten\" in aipname):\n coords = coords.groupdict()\n n = coords.get('cn') or coords.get('n')\n e = coords.get('ce') or coords.get('e')\n #n = coords.get('n') or coords.get('cn')\n #e = coords.get('e') or coords.get('ce')\n rad = coords.get('rad')\n if not rad:\n rad_m = coords.get('rad_m')\n if rad_m:\n rad = m2nm(rad_m)\n if not n or not e or not rad:\n coords_wrap += line.strip() + \" \"\n # FIXME: incomplete circle continuation is broken\n logger.debug(\"Continuing line after incomplete circle: %s\", coords_wrap)\n return\n lastn, laste = n, e\n logger.debug(\"Circle center is %s %s %s %s\", coords.get('n'), coords.get('e'), coords.get('cn'), coords.get('ce'))\n logger.debug(\"COORDS is %s\", json.dumps(coords))\n c_gen = gen_circle(n, e, rad)\n logger.debug(\"LENS %s %s\", len(obj), len(c_gen))\n obj = merge_poly(obj, c_gen)\n logger.debug(\"LENS %s %s\", len(obj), len(c_gen))\n\n elif coords2:\n coords = coords2.groupdict()\n n = coords.get('n')\n e = coords.get('e')\n if n is None and e is None:\n n,e = lastn, laste\n secfrom = coords.get('secfrom')\n secto = coords.get('secto')\n radfrom = coords.get('radfrom')\n radto = coords.get('rad')\n c_gen = gen_sector(n, e, secfrom, secto, radfrom, radto)\n\n obj = merge_poly(obj, c_gen)\n\n else:\n skip_next = 0\n for blob in coords3:\n ne,n,e,along,arc,rad,cn,ce = blob[:8]\n circle = blob[8] if len(blob)==9 else None\n logger.debug(\"Coords: %s\", (n,e,ne,along,arc,rad,cn,ce,circle))\n if skip_next > 0 and n:\n logger.debug(\"Skipped.\")\n skip_next -= 1\n continue\n if arc:\n arcdata = re_arc.search(line)\n if not arcdata:\n coords_wrap += line.strip() + \" \"\n logger.debug(\"Continuing line after incomplete arc: %s\", coords_wrap)\n return\n arcdata = arcdata.groupdict()\n logger.debug(\"Completed arc: %s\", arcdata)\n n = arcdata['n']\n e = arcdata['e']\n rad = arcdata.get('rad1') or arcdata.get('rad2')\n arc = gen_circle(n, e, rad, convert=False)\n to_n = arcdata['n2']\n to_e = arcdata['e2']\n cw = arcdata['dir']\n logger.debug(\"ARC IS \"+cw)\n fill = fill_along(obj[-1],(to_n,to_e), arc, (cw=='clockwise'))\n lastn, laste = None, None\n\n for apair in fill:\n bn, be = ll2c(apair)\n obj.insert(0,(bn,be))\n skip_next = 1\n elif circle:\n coords_wrap += line.strip() + \" \"\n # FIXME: incomplete circle continuation is broken\n logger.debug(\"Continuing line after incomplete circle (3): %s\", coords_wrap)\n return\n\n\n if alonging:\n if not n and not e:\n n, e = lastn, laste\n fill = fill_along(alonging, (n,e), border)\n alonging = False\n lastn, laste = None, None\n #HACK matching point in the wrong direction - FIXME don't select closest but next point in correct direction\n if \"Sälen TMA b\" in aipname or \"SÄLEN CTR Sector b\" in aipname:\n fill=fill[1:]\n for bpair in fill:\n bn, be = ll2c(bpair)\n obj.insert(0,(bn,be))\n\n if rad and cn and ce:\n c_gen = gen_circle(cn, ce, rad)\n logger.debug(\"Merging circle using cn, ce.\")\n obj = merge_poly(obj, c_gen)\n if n and e:\n lastn, laste = n, e\n obj.insert(0,(n,e))\n if along:\n if not n and not e:\n n, e = lastn, laste\n alonging = (n,e)\n if '(' in ne:\n finalcoord = True\n logger.debug(\"Found final coord.\")\n else:\n finalcoord = False\n if (airsport_aip or aip_sup or military_aip) and finalcoord:\n if feature['properties'].get('from (ft amsl)') is not None:\n logger.debug(\"Finalizing: finalcoord.\")\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n lastv = None\n\n if not valldal:\n return\n\n # IDENTIFY temporary restrictions\n period = re_period.search(line) or re_period2.search(line) or re_period3.search(line)\n\n if cold_resp and not feature.get('properties',{}).get('temporary'):\n logger.debug(\"Adding temporary restriction to cold response airspace.\")\n feature['properties']['temporary'] = True\n feature['properties']['dashArray'] = \"5 5\"\n feature['properties']['Date from'] = [\"14 MAR\"]\n feature['properties']['Date until'] = [\"31 MAR\"]\n feature['properties']['Time from (UTC)'] = \"0000\"\n feature['properties']['Time to (UTC)'] = \"2359\"\n\n # IDENTIFY frequencies\n freq = re_freq.search(line)\n if freq:\n freq = freq.groupdict()\n logger.debug(\"Found FREQUENCY: %s\", freq['freq'])\n feature['properties']['frequency'] = freq.get('freq')\n\n # IDENTIFY altitude limits\n vertl = re_vertl_upper.search(line) or re_vertl_lower.search(line) or re_vertl.search(line) or re_vertl2.search(line) or (military_aip and re_vertl3.search(line))\n\n if vertl:\n vertl = vertl.groupdict()\n logger.debug(\"Found vertl in line: %s\", vertl)\n fromamsl, toamsl = None, None\n\n v = vertl.get('ftamsl')\n flfrom = vertl.get('flfrom')\n flto = vertl.get('flto')\n fl = vertl.get('fl')\n rmk = vertl.get('rmk')\n\n if rmk is not None:\n v = 14999 # HACK: rmk = \"Lower limit of controlled airspace -> does not affect us\"\n if fl is not None:\n v = int(fl) * 100\n\n if flto is not None:\n toamsl = int(flto) * 100\n if flfrom:\n fromamsl = v or (int(flfrom) * 100)\n fl = fl or flfrom\n elif flfrom is not None:\n fromamsl = int(flfrom) * 100\n fl = fl or flfrom\n elif v is not None:\n if lastv is None:\n toamsl = v\n if fl is not None:\n flto = fl\n else:\n fromamsl = v\n else:\n fromamsl = vertl.get('msl',vertl.get('gnd',vertl.get('from')))\n if fromamsl == \"GND\": fromamsl = 0\n if fromamsl == \"MSL\": fromamsl = 0\n toamsl = vertl.get('unl',vertl.get('to'))\n if toamsl == \"UNL\": toamsl = 999999\n\n if toamsl is not None:\n lastv = toamsl\n currentv = feature['properties'].get('to (ft amsl)')\n if currentv is not None and currentv != toamsl:\n logger.warning(\"attempt to overwrite vertl_to %s with %s.\" % (currentv, toamsl))\n if int(currentv) > int(toamsl):\n logger.warning(\"skipping.\")\n return\n logger.warning(\"ok.\")\n if flto is not None:\n feature['properties']['to (fl)']=flto\n feature['properties']['to (ft amsl)']=toamsl\n feature['properties']['to (m amsl)'] = ft2m(toamsl)\n if valldal:\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n lastv = None\n if fromamsl is not None:\n currentv = feature['properties'].get('from (ft amsl)')\n if currentv is not None and currentv != fromamsl:\n logger.warning(\"attempt to overwrite vertl_from %s with %s.\" % (currentv, fromamsl))\n if int(currentv) < int(fromamsl):\n logger.warning(\"skipping.\")\n return\n logger.warning(\"ok.\")\n if fl is not None:\n feature['properties']['from (fl)']=fl\n feature['properties']['from (ft amsl)']=fromamsl\n feature['properties']['from (m amsl)'] = ft2m(fromamsl)\n lastv = None\n if (((cta_aip or airsport_aip or aip_sup or tia_aip or (aipname and (\"TIZ\" in aipname))) and (finalcoord or tia_aip_acc)) or country != 'EN'):\n logger.debug(\"Finalizing poly: Vertl complete.\")\n if aipname and ((\"SÄLEN\" in aipname) or (\"SAAB\" in aipname)) and len(sectors)>0:\n for x in sectors[1:]: # skip the first sector, which is the union of the other sectors in Swedish docs\n aipname_, obj_ = x\n logger.debug(\"Restoring \"+aipname_+\" \"+str(len(sectors)))\n feature_ = deepcopy(feature)\n logger.debug(\"Finalizing SAAB/SÄLEN: \" + aipname_)\n finalize(feature_, features, obj_, source, aipname_, cta_aip, restrict_aip, aip_sup, tia_aip)\n sectors = []\n logger.debug(\"Finalizing last poly as .\"+aipname)\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n\n logger.debug(\"From %s to %s\", feature['properties'].get('from (ft amsl)'), feature['properties'].get('to (ft amsl)'))\n return\n\n # IDENTIFY airspace naming\n name = re_name.search(line) or re_name2.search(line) or re_name3.search(line) or re_name4.search(line) or \\\n re_miscnames.search(line) or re_name5.search(line) or re_name_cr.search(line) or re_name6.search(line) or \\\n re_name_openair.search(line)\n\n if name_cont and not 'Real time' in line:\n aipname = aipname + \" \" + line\n logger.debug(\"Continuing name as \"+aipname)\n if line == '' or 'EN D' in aipname:\n name_cont = False\n\n if name:\n named=name.groupdict()\n if en_enr_5_1 or \"Hareid\" in line:\n logger.debug(\"RESTRICT/HAREID\")\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n lastv = None\n\n name=named.get('name')\n if 'polaris' in name.lower() and 'norway' in name.lower():\n pos = name.lower().index('norway')\n name = name[:pos]\n\n if name[:6]==\"Sector\" and \"ACC\" in aipname:\n return\n\n if named.get('name_cont'):\n name += ' '+named.get('name_cont')\n name_cont=True\n\n if (name == \"Sector a\") or (name == \"Sector b\") or (aipname and (\"Sector\" in aipname) and ((\"SÄLEN\" in aipname) or (\"SAAB\" in aipname))):\n return\n if \"ES R\" in name or \"ES D\" in name:\n name_cont=True\n if \"EN D\" in name and len(name)<8:\n name_cont=True\n\n if restrict_aip or military_aip:\n if feature['properties'].get('from (ft amsl)') is not None and (feature['properties'].get('to (ft amsl)') or \"Romerike\" in aipname or \"Oslo\" in aipname):\n logger.debug(\"RESTRICT/MILITARY + name and vertl complete\")\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n lastv = None\n else:\n logger.debug(\"RESTRICT/MILITARY + name and vertl NOT complete\")\n\n aipname = name\n logger.debug(\"Found name '%s' in line: %s\", aipname, line)\n return\n\n # The airsport document doesn't have recognizable airspace names\n # so we just assume every line that isn't otherwise parsed is the name of the next box.\n if airsport_aip and line.strip():\n logger.debug(\"Unhandled line in airsport_aip: %s\", line)\n if wstrip(line)==\"1\":\n logger.debug(\"Starting airsport_aip table\")\n airsport_intable = True\n elif wstrip(line)[0] != \"2\" and airsport_intable:\n logger.debug(\"Considering as new aipname: '%s'\", line)\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\n aipname = wstrip(line)\n\n if line.strip()==\"-+-\":\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)","def parse_pdb(self, line):\n if line is not None:\n self.original_text.append(line.rstrip(\"\\r\\n\"))","def __init__(self, line):\n # Throw an exception if we don't see the parenthesis that mark a cause\n if not line[108] == '(':\n raise ParsingException\n if not line[159:160] == ')':\n raise ParsingException\n\n # Parsing definitions\n self.cause = line[109:159].strip()"],"string":"[\n \"def parse_line(self, line):\\n raise NotImplementedError\",\n \"def parse(cls, line):\\r\\n raise NotImplementedError\",\n \"def parse_line(self, line, time_shift=0.0):\\n # The local variables are rather simple.\\n # pylint: disable=too-many-locals\\n try:\\n (\\n mode_string,\\n nlink,\\n user,\\n group,\\n size,\\n month,\\n day,\\n year_or_time,\\n name,\\n ) = self._split_line(line)\\n # We can get a `ValueError` here if the name is blank (see ticket #69).\\n # This is a strange use case, but at least we should raise the\\n # exception the docstring mentions.\\n except ValueError as exc:\\n raise ftputil.error.ParserError(str(exc))\\n # st_mode\\n st_mode = self.parse_unix_mode(mode_string)\\n # st_ino, st_dev, st_nlink, st_uid, st_gid, st_size, st_atime\\n st_ino = None\\n st_dev = None\\n st_nlink = int(nlink)\\n st_uid = user\\n st_gid = group\\n st_size = int(size)\\n st_atime = None\\n # st_mtime\\n st_mtime, st_mtime_precision = self.parse_unix_time(\\n month, day, year_or_time, time_shift, with_precision=True\\n )\\n # st_ctime\\n st_ctime = None\\n # st_name\\n if name.count(\\\" -> \\\") > 1:\\n # If we have more than one arrow we can't tell where the link name\\n # ends and the target name starts.\\n raise ftputil.error.ParserError(\\n '''name '{}' contains more than one \\\"->\\\"'''.format(name)\\n )\\n elif name.count(\\\" -> \\\") == 1:\\n st_name, st_target = name.split(\\\" -> \\\")\\n else:\\n st_name, st_target = name, None\\n stat_result = StatResult(\\n (\\n st_mode,\\n st_ino,\\n st_dev,\\n st_nlink,\\n st_uid,\\n st_gid,\\n st_size,\\n st_atime,\\n st_mtime,\\n st_ctime,\\n )\\n )\\n # These attributes are kind of \\\"half-official\\\". I'm not sure whether\\n # they should be used by ftputil client code.\\n # pylint: disable=protected-access\\n stat_result._st_mtime_precision = st_mtime_precision\\n stat_result._st_name = st_name\\n stat_result._st_target = st_target\\n return stat_result\",\n \"def parse_line(self, line: str) -> None:\\n self._count += 1\",\n \"def parseline(self, line):\\n line = line.strip()\\n\\n if not line:\\n # Deal with empty line or all whitespace line\\n return None, None, line\\n\\n # Expand command shortcuts to the full command name\\n for (shortcut, expansion) in self.shortcuts:\\n if line.startswith(shortcut):\\n line = line.replace(shortcut, expansion + ' ', 1)\\n break\\n\\n i, n = 0, len(line)\\n while i < n and line[i] in self.identchars:\\n i += 1\\n command, arg = line[:i], line[i:].strip()\\n return command, arg, line\",\n \"def _parse_record(line):\\n fields = line.split()\\n if len(fields) < 6:\\n raise ParseError(\\\"Less than six fields found in PED/FAM file\\\")\\n individual_id, paternal_id, maternal_id = fields[1:4]\\n if paternal_id == \\\"0\\\":\\n paternal_id = None\\n if maternal_id == \\\"0\\\":\\n maternal_id = None\\n return Trio(child=individual_id, father=paternal_id, mother=maternal_id)\",\n \"def _ParseAsanLogLine(line):\\n m = re.match(_RE_ASAN, line)\\n if not m:\\n return None\\n return AsanParsedLine(prefix=m.group('prefix'),\\n library=m.group('lib'),\\n pos=m.group('pos'),\\n rel_address=int(m.group('addr'), 16))\",\n \"def parse_line(self, line):\\n success = self.parser.handle_line(line)\\n if success:\\n self.data.update()\\n else:\\n self.bot.log(\\\"didn't handle line: '{}'\\\".format(line))\",\n \"def parse(self, filehandle):\\n l = filehandle.readline()\\n if l.split()[0] != '##maf':\\n return\\n else:\\n self.setpar(l.split()[1:])\\n\\n l=filehandle.readline()\\n while l:\\n la = l.split()\\n## print la\\n if(len(la)==0 or la[0]=='#'):\\n## print \\\"skipping\\\"\\n 1\\n elif(la[0]=='a'):\\n## print \\\"reading alignment\\\"\\n self.readalign(la[1:], filehandle)\\n else:\\n## print \\\"end of records\\\"\\n return\\n\\n l=filehandle.readline()\",\n \"def doomed_parser(line):\\n raise exceptions.LineParseException('Error occurred')\",\n \"def parse_line(self, line):\\n\\t\\tif line[0] == \\\"#\\\":\\n\\t\\t\\treturn False\\n\\t\\tparts = [x.strip() for x in line.strip().split(\\\",\\\")]\\n\\t\\tself.unix_time = int(parts[0])\\n\\t\\tself.cycles_done = int(parts[1])\\n\\t\\tself.cur_path = int(parts[2])\\n\\t\\tself.paths_total = int(parts[3])\\n\\t\\tself.pending_total = int(parts[4])\\n\\t\\tself.pending_favs = int(parts[5])\\n\\t\\tself.map_size = float(parts[6].replace(\\\"%\\\",\\\"\\\"))\\n\\t\\tself.unique_crashes = int(parts[7])\\n\\t\\tself.unique_hangs = int(parts[8])\\n\\t\\tself.max_depth = int(parts[9])\\n\\t\\tself.execs_per_sec = float(parts[10])\\n\\t\\treturn True\",\n \"def __init__(self, line):\\n # Throw an exception if we don't see the parenthesis that mark a history entry\\n if not line[108] == '(':\\n raise ParsingException\\n if not line[138:139] == ')':\\n raise ParsingException\\n\\n self.status = line[109:122].strip()\\n self.time_stamp = datetime.strptime(line[122:138], '%m/%d/%Y %H:%M')\",\n \"def GetLine(line):\\r\\n pass\",\n \"def parse(self,att_line):\\r\\n att_line = {item.split('=')[0]:item.split('=')[1] for item in att_line.split(';')}\\r\\n if 'ID' in att_line:\\r\\n self.id = att_line.pop('ID',None)\\r\\n if 'Name' in att_line:\\r\\n self.name = att_line.pop('Name',None)\\r\\n if 'Alias' in att_line:\\r\\n self.alias = att_line.pop('Alias',None)\\r\\n if 'Parent' in att_line:\\r\\n self.parent = att_line.pop('Parent',None)\\r\\n if 'Target' in att_line:\\r\\n self.target = att_line.pop('Target',None)\\r\\n if 'Gap' in att_line:\\r\\n self.gap = att_line.pop('Gap',None)\\r\\n if 'Derives_from' in att_line:\\r\\n self.derives_from = att_line.pop('Derives_from',None)\\r\\n if 'Note' in att_line:\\r\\n self.note = att_line.pop('Note',None)\\r\\n if 'Dbxref' in att_line:\\r\\n self.dbxref = att_line.pop('Dbxref',None)\\r\\n if 'Ontology_term' in att_line:\\r\\n self.ontology_term = att_line.pop('Ontology_term',None)\\r\\n if 'Is_circular' in att_line:\\r\\n self.is_circular = att_line.pop('Is_circular',None)\\r\\n if self.allele_key in att_line:\\r\\n self.allele = att_line.pop(self.allele_key,None).split(',')\\r\\n if self.discovered_key in att_line:\\r\\n discovered_val = att_line.pop(self.discovered_key,None)\\r\\n if discovered_val in self.enabled:\\r\\n self.discovered = True\\r\\n elif discovered_val in self.disabled:\\r\\n self.discovered = False\\r\\n if self.validated_key in att_line:\\r\\n validated_val = att_line.pop(self.validated_key,None)\\r\\n if validated_val in self.enabled:\\r\\n self.validated = True\\r\\n elif validated_val in self.disabled:\\r\\n self.validated = False\\r\\n if self.active_key in att_line:\\r\\n active_val = att_line.pop(self.active_key,None)\\r\\n if active_val in self.enabled:\\r\\n self.active = False\\r\\n elif active_val in self.disabled:\\r\\n self.active = True\\r\\n else:\\r\\n pass#print(\\\"{} is not a valid entry for {}\\\".format(active_val,self.active_key))\\r\\n else:\\r\\n #TODO this will make every element withought existing value active.\\r\\n self.active = True\\r\\n rest_dict = {}\\r\\n for key,value in att_line.items():\\r\\n if self.history_key in key:\\r\\n parts = att_line[key].split(',')\\r\\n if len(parts) == 3:\\r\\n self.add_history(*parts)\\r\\n else:\\r\\n reason = '.'.join(parts[2:])\\r\\n self.add_history(parts[0],parts[1],reason)\\r\\n else:\\r\\n rest_dict[key] = value\\r\\n if rest_dict != {}:\\r\\n #TODO: maybe add this to a logger instead\\r\\n #print(\\\"attributes put in other: {}\\\".format(', '.join(att_line.keys())))\\r\\n self.other = att_line\\r\\n return self\",\n \"def parseLine(self, line):\\n\\n # Bail out on lines with a malformed timestamp\\n try:\\n timestamp = time.mktime(time.strptime(line[1:25], \\\"%a %b %d %H:%M:%S %Y\\\"))\\n except:\\n return\\n \\n text = line[27:]\\n \\n if self.myname: \\n self.attendance.mark(timestamp, self.myname)\\n text = self.re_myname.sub(self.myname + ' ', text) \\n \\n damage = self.re_damage.search(text)\\n #damage = False\\n death = self.re_death.search(text)\\n #death = False\\n miss = self.re_miss.search(text)\\n #miss = False\\n #defensive = self.re_defensive.search(text)\\n defensive = False\\n loot = self.re_loot.search(text)\\n attendance = self.re_attendance.search(text)\\n if damage:\\n (attacker, atktype, defender, amount, nonmelee) = damage.groups()\\n if nonmelee:\\n atktype = 'non-melee'\\n if self.extract and (self.extract == attacker or self.extract == defender):\\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, int(amount))\\n if attacker.count(' ') == 0:\\n self.attendance.mark(timestamp, attacker)\\n if defender.count(' ') == 0:\\n self.defender.mark(timestamp, defender)\\n elif miss:\\n (attacker, atktype, defender) = miss.groups()\\n if self.extract and (self.extract == attacker or self.extract == defender):\\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, 'miss')\\n if attacker.count(' ') == 0:\\n self.attendance.mark(timestamp, attacker)\\n if defender.count(' ') == 0:\\n self.defender.mark(timestamp, defender)\\n elif defensive:\\n (attacker, atktype, defender, defensetype) = defensive.groups()\\n if self.extract and (self.extract == attacker or self.extract == defender):\\n self.fights.getFight(timestamp, attacker, defender).addAttack(timestamp, atktype, defensetype)\\n if attacker.count(' ') == 0:\\n self.attendance.mark(timestamp, attacker)\\n if defender.count(' ') == 0:\\n self.defender.mark(timestamp, defender)\\n elif death:\\n (defender, junk, attacker) = death.groups()\\n if junk.count('have slain'):\\n (defender, attacker) = (attacker, defender)\\n # Use PC deaths to track their attendance\\n if defender.count(' ') == 0:\\n self.attendance.mark(timestamp, defender)\\n elif attacker.count(' ') == 0:\\n self.kills.addKill(timestamp, defender)\\n if self.extract and (self.extract == attacker or self.extract == defender):\\n self.fights.addDeath(timestamp, attacker, defender)\\n if attacker.count(' ') == 0:\\n self.attendance.mark(timestamp, attacker)\\n elif loot:\\n (looter, item) = loot.groups()\\n self.loot.addLoot(timestamp, looter, item)\\n self.attendance.mark(timestamp, looter)\\n elif attendance:\\n attendee = attendance.group(1)\\n self.attendance.mark(timestamp, attendee)\",\n \"def parse_line(line: str) -> str:\\n return line\",\n \"def parse_line(line: str) -> str:\\n return line\",\n \"def parse_line(line: str) -> str:\\n return line\",\n \"def parse_line(line: str) -> str:\\n return line\",\n \"def parse_movie(self, line):\\n pass\",\n \"def decodeline(self, line):\\n result = ApacheLogLine()\\n result.full_line = line\\n linepatternmatch = self._linepattern.match(line)\\n if linepatternmatch:\\n result.hostname = linepatternmatch.group(1)\\n result.user = linepatternmatch.group(2)\\n if result.user == '-':\\n result.user = ''\\n (result.accesstime_seconds, result.serveroffset) = self.parsedate(linepatternmatch.group(3))\\n result.accesstime_string = stringdate(result.accesstime_seconds, offset=result.serveroffset)\\n result.file = linepatternmatch.group(4)\\n result.code = linepatternmatch.group(5)\\n result.code_description = self._codetranslator.get_description(result.code)\\n result.size = linepatternmatch.group(6)\\n if result.size == '-':\\n result.size = 0\\n result.referer = linepatternmatch.group(7)\\n if result.referer == '-':\\n result.referer = ''\\n result.browser = linepatternmatch.group(8)\\n else:\\n self._notparsable += 1\\n warn(\\\"The line '%s' could not be parsed\\\" % line)\\n return None\\n if self._line_fits_pattern(result):\\n self._acceptedlines += 1\\n return result\\n else:\\n self._rejectedlines += 1\\n return None\",\n \"def parse(line: str) -> \\\"SeqNode\\\":\\n return MiniParser(Lexer(line)).parse()\",\n \"def _parse_line(self, line):\\n fields = line.split('|', 4) # stop splitting after fourth | found\\n line_info = {'raw_message': line}\\n if len(fields) == 5:\\n line_info.update(dict(zip(self._fieldnames, fields)))\\n return line_info\",\n \"def parse_line(self, line, time_shift=0.0):\\n raise NotImplementedError(\\\"must be defined by subclass\\\")\",\n \"def parse_apache_log_line(logline):\\n match = re.search(APACHE_ACCESS_LOG_PATTERN, logline)\\n if match is None:\\n return logline, 0\\n size_field = match.group(9)\\n if size_field == '-':\\n size = long(0)\\n else:\\n size = long(match.group(9))\\n return (Row(\\n host=match.group(1),\\n client_identd=match.group(2),\\n user_id=match.group(3),\\n date_time=parse_apache_time(match.group(4)),\\n method=match.group(5),\\n endpoint=match.group(6),\\n protocol=match.group(7),\\n response_code=int(match.group(8)),\\n content_size=size\\n ), 1)\",\n \"def parse(input_data):\\n parser = ACLParser(grammar)\\n\\n try:\\n data = input_data.read()\\n except AttributeError:\\n data = input_data\\n\\n ## parse the acl\\n success, children, nextchar = parser.parse(data)\\n\\n if success and nextchar == len(data):\\n assert len(children) == 1\\n return children[0]\\n else:\\n line = data[:nextchar].count('\\\\n') + 1\\n column = len(data[data[nextchar].rfind('\\\\n'):nextchar]) + 1\\n raise exceptions.ParseError('Could not match syntax. Please report as a bug.', line, column)\",\n \"def _parse_line(line):\\n if line.startswith('import '):\\n line = line.replace('import ', '')\\n return line\",\n \"def parse_line(line):\\n num1 = int(line.split(\\\"-\\\")[0])\\n num2 = int(line.split(\\\"-\\\")[1].split(\\\" \\\")[0])\\n character = line.split(\\\" \\\")[1].split(\\\":\\\")[0]\\n password = line.split(\\\" \\\")[2]\\n # print(f\\\"{line} :: ({num1}, {num2}, {character}, {password})\\\")\\n return num1, num2, character, password\",\n \"def parseApacheLogLine(logline):\\n match = re.search(APACHE_ACCESS_LOG_PATTERN, logline)\\n if match is None:\\n return (logline, 0)\\n size_field = match.group(9)\\n if size_field == '-':\\n size = long(0)\\n else:\\n size = long(match.group(9))\\n return (Row(\\n host = match.group(1),\\n client_identd = match.group(2),\\n user_id = match.group(3),\\n date_time = parse_apache_time(match.group(4)),\\n method = match.group(5),\\n endpoint = match.group(6),\\n protocol = match.group(7),\\n response_code = int(match.group(8)),\\n content_size = size\\n ), 1)\",\n \"def parse_pdb(self, line):\\n super().parse_pdb(line)\\n self.num_remark = int(line[10:15].strip())\\n self.num_het = int(line[20:25].strip())\\n self.num_helix = int(line[25:30].strip())\\n self.num_sheet = int(line[30:35].strip())\\n self.num_turn = int(line[35:40].strip())\\n self.num_site = int(line[40:45].strip())\\n self.num_xform = int(line[45:50].strip())\\n self.num_coord = int(line[50:55].strip())\\n self.num_ter = int(line[55:60].strip())\\n self.num_conect = int(line[60:65].strip())\\n self.num_seq = int(line[65:70].strip())\",\n \"def read_token(line):\\n token = line.strip().split('\\\\t')\\n if len(token) == 6:\\n token += ['_', '_', '_', '_']\\n id, form, lemma, cpostag, postag, feats, head, deprel, phead, pdeprel = token\\n try:\\n head = int(head)\\n except ValueError:\\n head = '_'\\n try:\\n phead = int(phead)\\n except ValueError:\\n phead = '_'\\n return Token(int(id), form, lemma, cpostag, postag, feats, head, deprel, phead, pdeprel)\",\n \"def _parse_lladdr(line):\\n tokens = line.split()\\n return tokens[1]\",\n \"def parseFileLine(self, line):\\n c = line.strip().split(\\\":\\\")\\n return (c[0], c[1], c[2], c[3])\",\n \"def _process_line(self, line):\\n i = 0\\n while True:\\n i = self._process_token(line)\\n if i == 0:\\n break\\n line = line[i:]\\n if line:\\n util.debug('Lexer state:\\\\n{}'.format(self._debug_lexer_state()))\\n raise LexerError('Syntax error (remaining:%r)' % (line,),\\n self._cur_lineno + 1,\\n self._cur_charno + 1)\",\n \"def parse_access_log(log_lines):\\n matches = [ ACCESS_RE.search(y) for y in log_lines ]\\n return [ x.groupdict() for x in matches if x is not None ]\",\n \"def ParseLine(line):\\n words = line.split()\\n date = words[0][1:] + \\\" \\\" + words[1][:-1]\\n parsed_date = parse(date)\\n year = parsed_date.year\\n month = parsed_date.month\\n day = parsed_date.day\\n hour = parsed_date.hour\\n mins = parsed_date.minute\\n\\n #print (year, month, day, hour, mins)\\n shift_start = False\\n guard_id = 0\\n falls_asleep = False\\n wakes = False\\n if (words[2] == \\\"Guard\\\"):\\n shift_start = True\\n guard_id = int(words[3][1:])\\n elif (words[2] == \\\"wakes\\\"):\\n wakes = True\\n guard_id = 0\\n elif (words[2] == \\\"falls\\\"):\\n falls_asleep = True\\n guard_id = 0\\n return Record(date, year, month, day, hour, mins, shift_start, guard_id, falls_asleep, wakes)\",\n \"def _parse_line(line):\\n # Tokenize the line.\\n synset_pos, synset_offset, pos_score, neg_score, synset_terms, gloss = line.split('\\\\t')\\n\\n # We'll ignore the synset terms and gloss, because the NLTK synset\\n # object stored in SWNEntry can get those from WordNet.\\n\\n return SWNEntry(synset_pos, int(synset_offset), float(pos_score), float(neg_score))\",\n \"def parse_annotation_line(line, ln):\\n fields = [f.strip() for f in line.split('\\\\t')]\\n if len(fields) != 6:\\n raise FormatError('Failed to parse line %d: %s' % (ln, line))\\n PMID = fields[0]\\n try:\\n start = int(fields[1])\\n end = int(fields[2])\\n except:\\n raise FormatError('Failed to parse line %d: %s' % (ln, line))\\n text = fields[3]\\n type_ = fields[4]\\n if len(text) != end-start:\\n raise FormatError('Text \\\"%s\\\" has length %d, end-start (%d-%d) is %s' %\\n (text, len(text), end, start, end-start))\\n norms = fields[5].split('|')\\n return Annotation(PMID, start, end, text, type_, norms)\",\n \"def parse_line(self, line):\\n tokens, permanent, comment = OrdersParser.tokenize(line)\\n \\n if not tokens:\\n if comment:\\n self._consumer.comment(permanent=permanent, comment=comment)\\n return\\n \\n order = tokens.popleft().lower()\\n \\n if order == '#atlantis':\\n if not tokens:\\n raise SyntaxError('{}: missing faction'.format(line))\\n faction = OrdersParser._value(tokens.popleft())\\n try:\\n password = tokens.popleft()\\n except IndexError:\\n self._consumer.atlantis(faction=faction)\\n else:\\n self._consumer.atlantis(faction=faction,\\n password=password)\\n \\n elif order == '#end':\\n self._consumer.atlantis_end()\\n \\n elif order == 'unit':\\n if not tokens:\\n raise SyntaxError('{}: missing unit'.format(line))\\n else:\\n unit = OrdersParser._value(tokens.popleft())\\n if not unit:\\n raise SyntaxError('{}: invalid unit'.format(line))\\n self._consumer.unit(unit=unit)\\n \\n elif order == 'form':\\n if not tokens:\\n raise SyntaxError('{}: missing alias'.format(line))\\n else:\\n alias = OrdersParser._value(tokens.popleft())\\n if not alias:\\n raise SyntaxError('{}: invalid alias'.format(line))\\n self._consumer.order_form(alias=alias, permanent=permanent,\\n comment=comment)\\n elif order == 'end':\\n self._consumer.order_end()\\n \\n elif order == 'turn':\\n self._consumer.order_turn(permanent=permanent, comment=comment)\\n \\n elif order == 'endturn':\\n self._consumer.order_endturn()\\n \\n elif order == 'address':\\n if not tokens:\\n raise SyntaxError('{}: missing address'.format(line))\\n else:\\n self._consumer.order_address(address=tokens.popleft(),\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'advance':\\n try:\\n dirs = [OrdersParser._parse_dir(d.lower()) for d in tokens]\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n else:\\n self._consumer.order_advance(dirs=dirs, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'assassinate':\\n try:\\n unit = OrdersParser._parse_unit(tokens)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n else:\\n self._consumer.order_assassinate(unit=unit,\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'attack':\\n targets = []\\n try:\\n while tokens:\\n targets.append(OrdersParser._parse_unit(tokens))\\n except SyntaxError as e:\\n self._consumer.order_attack(targets=targets,\\n permanent=permanent,\\n comment=comment)\\n raise SyntaxError('{}: {}'.format(line, e))\\n else:\\n self._consumer.order_attack(targets=targets,\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'autotax':\\n if not tokens:\\n raise SyntaxError('{}: missing value'.format(line))\\n try:\\n self._consumer.order_autotax(\\n flag=OrdersParser._parse_TF(tokens.popleft()),\\n permanent=permanent, comment=comment)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n \\n elif order == 'avoid':\\n if not tokens:\\n raise SyntaxError('{}: missing value'.format(line))\\n try:\\n self._consumer.order_avoid(\\n flag=OrdersParser._parse_TF(tokens.popleft()),\\n permanent=permanent, comment=comment)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n \\n elif order == 'idle':\\n self._consumer.order_idle(permanent=permanent, comment=comment)\\n \\n elif order == 'behind':\\n if not tokens:\\n raise SyntaxError('{}: missing value'.format(line))\\n try:\\n self._consumer.order_behind(\\n flag=OrdersParser._parse_TF(tokens.popleft()),\\n permanent=permanent, comment=comment)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n \\n elif order == 'build':\\n if not tokens:\\n self._consumer.order_build(permanent=permanent, comment=comment)\\n else:\\n tok = tokens.popleft().lower()\\n if tok == 'help':\\n try:\\n target = OrdersParser._parse_unit(tokens)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n else:\\n self._consumer.order_build(target=target,\\n permanent=permanent,\\n comment=comment)\\n else:\\n self._consumer.order_build(structure=tok,\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'buy':\\n if not tokens:\\n raise SyntaxError('{}: missing amount'.format(line))\\n num = tokens.popleft().lower()\\n if num == 'all':\\n num = OrdersParser.AMT_ALL\\n else:\\n num = OrdersParser._value(num)\\n if not num:\\n raise SyntaxError('{}: missing amount'.format(line))\\n if not tokens:\\n raise SyntaxError('{}: missing item'.format(line))\\n self._consumer.order_buy(num=num, item=tokens.popleft().lower(),\\n permanent=permanent, comment=comment)\\n \\n elif order == 'cast':\\n if not tokens:\\n raise SyntaxError('{}: missing skill'.format(line))\\n skill = tokens.popleft().lower()\\n params = [p.lower() for p in tokens]\\n self._consumer.order_cast(skill=skill, params=params,\\n permanent=permanent, comment=comment)\\n \\n elif order == 'claim':\\n if not tokens:\\n raise SyntaxError('{}: missing amount'.format(line))\\n value = OrdersParser._value(tokens.popleft())\\n if not value:\\n raise SyntaxError('{}: missing amount'.format(line))\\n self._consumer.order_claim(num=value, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'combat':\\n if not tokens:\\n combat = OrdersParser.IT_NONE\\n else:\\n combat = tokens.popleft().lower()\\n self._consumer.order_combat(skill=combat, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'consume':\\n if not tokens:\\n consuming = 'none'\\n else:\\n consuming = tokens.popleft().lower()\\n if consuming not in ('unit', 'faction', 'none'):\\n raise SyntaxError('{}: invalid value'.format(line))\\n self._consumer.order_consume(consuming=consuming,\\n permanent=permanent, comment=comment)\\n \\n elif order == 'declare':\\n if not tokens:\\n raise SyntaxError('{}: missing faction'.format(line))\\n fac = tokens.popleft().lower()\\n if fac != 'default':\\n fac = OrdersParser._value(fac)\\n if not fac:\\n raise SyntaxError('{}: missing faction'.format(line))\\n if not tokens:\\n self._consumer.order_declare(faction=fac, permanent=permanent,\\n comment=comment)\\n else:\\n attitude = tokens.popleft().lower()\\n if attitude in ('hostile', 'unfriendly', 'neutral',\\n 'friendly', 'ally'):\\n self._consumer.order_declare(faction=fac,\\n attitude=attitude,\\n permanent=permanent,\\n comment=comment)\\n else:\\n raise SyntaxError('{}: invalid attitude'.format(line))\\n \\n elif order == 'describe':\\n if tokens:\\n target = tokens.popleft().lower()\\n else:\\n raise SyntaxError('{}: missing target'.format(line))\\n if tokens:\\n description = tokens.popleft()\\n else:\\n description = None\\n if target == 'unit':\\n self._consumer.order_describe(unit=description,\\n permanent=permanent,\\n comment=comment)\\n elif target in ('ship', 'building', 'object', 'structure'):\\n self._consumer.order_describe(structure=description,\\n permanent=permanent,\\n comment=comment)\\n else:\\n raise SyntaxError('{}: invalid target'.format(line))\\n \\n elif order == 'destroy':\\n self._consumer.order_destroy(permanent=permanent, comment=comment)\\n \\n elif order == 'enter':\\n if tokens:\\n structure = OrdersParser._value(tokens.popleft())\\n if dir:\\n self._consumer.order_enter(structure=structure,\\n permanent=permanent,\\n comment=comment)\\n else:\\n raise SyntaxError('{}: invalid structure'.format(line))\\n else:\\n raise SyntaxError('{}: missing structure'.format(line))\\n \\n elif order == 'entertain':\\n self._consumer.order_entertain(permanent=permanent, comment=comment)\\n \\n elif order == 'evict':\\n targets = []\\n try:\\n while tokens:\\n targets.append(OrdersParser._parse_unit(tokens))\\n except SyntaxError as e:\\n self._consumer.order_evict(targets=targets,\\n permanent=permanent,\\n comment=comment)\\n raise SyntaxError('{}: {}'.format(line, e))\\n else:\\n self._consumer.order_evict(targets=targets,\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'exchange':\\n try:\\n target = OrdersParser._parse_unit(tokens, allow_any=True)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n if not tokens:\\n raise SyntaxError('{}: missing given amount'.format(line))\\n amtGive = OrdersParser._value(tokens.popleft())\\n if not tokens:\\n raise SyntaxError('{}: missing given item'.format(line))\\n itemGive = tokens.popleft().lower()\\n if not tokens:\\n raise SyntaxError('{}: missing expected amount'.format(line))\\n amtExpected = OrdersParser._value(tokens.popleft())\\n if not tokens:\\n raise SyntaxError('{}: missing expected item'.format(line))\\n itemExpected = tokens.popleft().lower()\\n self._consumer.order_exchange(\\n target=target, give={'amt': amtGive, 'item': itemGive},\\n expected={'amt': amtExpected, 'item': itemExpected},\\n permanent=permanent, comment=comment)\\n \\n elif order == 'faction':\\n if not tokens:\\n raise SyntaxError('{}: missing faction type'.format(line))\\n ftype = {}\\n while tokens:\\n t = tokens.popleft().lower()\\n if not tokens:\\n raise SyntaxError('{}: invalid value'.format(line))\\n ftype[t] = OrdersParser._value(tokens.popleft())\\n self._consumer.order_faction(permanent=permanent, comment=comment,\\n **ftype)\\n \\n elif order == 'find':\\n if not tokens:\\n raise SyntaxError('{}: missing faction'.format(line))\\n fac = tokens.popleft().lower()\\n if fac != 'all':\\n fac = OrdersParser._value(fac)\\n if not fac:\\n raise SyntaxError('{}: invalid faction'.format(line))\\n self._consumer.order_find(permanent=permanent, comment=comment,\\n faction=fac)\\n \\n elif order == 'forget':\\n if not tokens:\\n raise SyntaxError('{}: missing skill'.format(line))\\n self._consumer.order_forget(permanent=permanent, comment=comment,\\n skill=tokens.popleft().lower())\\n \\n elif order == 'withdraw':\\n if not tokens:\\n raise SyntaxError('{}: missing amount'.format(line))\\n tok = tokens.popleft().lower()\\n amt = OrdersParser._value(tok)\\n if amt < 1:\\n amt = 1\\n item = tok\\n elif tokens:\\n item = tokens.popleft().lower()\\n else:\\n raise SyntaxError('{}: missing item'.format(line))\\n self._consumer.order_withdraw(permanent=permanent, comment=comment,\\n amt=amt, item=item)\\n \\n elif order == 'give':\\n try:\\n target = OrdersParser._parse_unit(tokens)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n if not tokens:\\n raise SyntaxError('{}: missing amount'.format(line))\\n amt = tokens.popleft().lower()\\n if amt == 'unit':\\n self._consumer.order_give(permanent=permanent, comment=comment,\\n target=target, give=amt)\\n else:\\n if amt != 'all':\\n amt = OrdersParser._value(amt)\\n if not amt:\\n raise SyntaxError('{}: invalid amount'.format(line))\\n try:\\n item = tokens.popleft().lower()\\n if item == 'unfinished':\\n unfinished = True\\n item = tokens.popleft().lower()\\n else:\\n unfinished = False\\n except:\\n raise SyntaxError('{}: missing item'.format(line))\\n \\n if tokens and tokens[0].lower() == 'except':\\n tok = tokens.popleft().lower()\\n if amt != 'all':\\n raise SyntaxError(\\n '{}: except only valid with all'. format(line))\\n if not tokens:\\n raise SyntaxError(\\n '{}: missing except value'.format(line))\\n excpt = OrdersParser._value(tokens.popleft())\\n if not excpt:\\n raise SyntaxError(\\n '{}: invalid except value'.format(line))\\n self._consumer.order_give(permanent=permanent,\\n comment=comment,\\n target=target,\\n give={'amt': amt, 'item': item,\\n 'unfinished': unfinished,\\n 'excpt': excpt})\\n else:\\n self._consumer.order_give(permanent=permanent,\\n comment=comment,\\n target=target,\\n give={'amt': amt, 'item': item,\\n 'unfinished': unfinished})\\n \\n elif order == 'guard':\\n if not tokens:\\n raise SyntaxError('{}: invalid value'.format(line))\\n try:\\n guard = OrdersParser._parse_TF(tokens.popleft())\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n self._consumer.order_guard(flag=guard, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'hold':\\n if not tokens:\\n raise SyntaxError('{}: invalid value'.format(line))\\n try:\\n hold = OrdersParser._parse_TF(tokens.popleft())\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n self._consumer.order_hold(flag=hold, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'join':\\n try:\\n target = OrdersParser._parse_unit(tokens)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n if tokens:\\n tok = tokens.popleft().lower()\\n if tok == 'nooverload':\\n self._consumer.order_join(target=target, nooverload=True,\\n permanent=permanent,\\n comment=comment)\\n elif tok == 'merge':\\n self._consumer.order_join(target=target, merge=True,\\n permanent=permanent,\\n comment=comment)\\n else:\\n self._consumer.order_join(target=target,\\n permanent=permanent,\\n comment=comment)\\n else:\\n self._consumer.order_join(target=target,\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'leave':\\n self._consumer.order_leave(permanent=permanent, comment=comment)\\n \\n elif order == 'move':\\n try:\\n dirs = [OrdersParser._parse_dir(d.lower()) for d in tokens]\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n else:\\n self._consumer.order_move(dirs=dirs, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'name':\\n if len(tokens) < 2:\\n raise SyntaxError('{}: missing name'.format(line))\\n what, name = tokens.popleft().lower(), tokens.popleft()\\n if what == 'faction':\\n self._consumer.order_name(permanent=permanent, comment=comment,\\n faction=name)\\n elif what == 'unit':\\n self._consumer.order_name(permanent=permanent, comment=comment,\\n unit=name)\\n elif what in ('building', 'ship', 'object', 'structure'):\\n self._consumer.order_name(permanent=permanent, comment=comment,\\n structure=name)\\n elif what in ('village', 'town', 'city') and \\\\\\n OrdersParser._get_legal(name):\\n self._consumer.order_name(permanent=permanent, comment=comment,\\n city=OrdersParser._get_legal(name))\\n else:\\n raise SyntaxError('{}: invalid argument'.format(line))\\n \\n elif order == 'noaid':\\n if not tokens:\\n raise SyntaxError('{}: invalid value'.format(line))\\n try:\\n noaid = OrdersParser._parse_TF(tokens.popleft())\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n self._consumer.order_noaid(flag=noaid, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'nocross':\\n if not tokens:\\n raise SyntaxError('{}: invalid value'.format(line))\\n try:\\n nocross = OrdersParser._parse_TF(tokens.popleft())\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n self._consumer.order_nocross(flag=nocross, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'nospoils':\\n if not tokens:\\n raise SyntaxError('{}: invalid value'.format(line))\\n try:\\n spoils_none = OrdersParser._parse_TF(tokens.popleft())\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n if spoils_none:\\n self._consumer.order_spoils(spoils='none', permanent=permanent,\\n comment=comment)\\n else:\\n self._consumer.order_spoils(spoils='all', permanent=permanent,\\n comment=comment)\\n raise DeprecationWarning(\\n '{}: deprecated. Use SPOILS instead'.format(line))\\n \\n elif order == 'option':\\n if not tokens:\\n raise SyntaxError('{}: missing option'.format(line))\\n option = tokens.popleft().lower()\\n if option == 'times':\\n self._consumer.order_option(times=True, permanent=permanent,\\n comment=comment)\\n elif option == 'notimes':\\n self._consumer.order_option(times=False, permanent=permanent,\\n comment=comment)\\n elif option == 'showattitudes':\\n self._consumer.order_option(showunitattitudes=True,\\n permanent=permanent,\\n comment=comment)\\n elif option == 'dontshowattitudes':\\n self._consumer.order_option(showunitattitudes=False,\\n permanent=permanent,\\n comment=comment)\\n elif option == 'template':\\n if not tokens:\\n raise SyntaxError('{}: missing template type'.format(line))\\n temformat = tokens.popleft().lower()\\n if temformat in ('off', 'short', 'long', 'map'):\\n self._consumer.order_option(temformat=temformat,\\n permanent=permanent,\\n comment=comment)\\n else:\\n raise SyntaxError('{}: invalid template type'.format(line))\\n else:\\n raise SyntaxError('{}: invalid option'.format(line))\\n \\n elif order == 'password':\\n if not tokens:\\n self._consumer.order_password(password='none',\\n permanent=permanent,\\n comment=comment)\\n else:\\n self._consumer.order_password(password=tokens.popleft(),\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'pillage':\\n self._consumer.order_pillage(permanent=permanent, comment=comment)\\n \\n elif order == 'prepare':\\n if not tokens:\\n self._consumer.order_prepare(item=None,\\n permanent=permanent,\\n comment=comment)\\n else:\\n self._consumer.order_prepare(item=tokens.popleft().lower(),\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'weapon':\\n self._consumer.order_weapon(permanent=permanent, comment=comment,\\n items=[w.lower() for w in tokens])\\n \\n elif order == 'armor':\\n self._consumer.order_armor(permanent=permanent, comment=comment,\\n items=[w.lower() for w in tokens])\\n \\n elif order == 'produce':\\n if not tokens:\\n raise SyntaxError('{}: missing item'.format(line))\\n item = tokens.popleft().lower()\\n if OrdersParser._value(item):\\n if not tokens:\\n raise SyntaxError('{}: missing item'.format(line))\\n self._consumer.order_produce(target=OrdersParser._value(item),\\n item=tokens.popleft().lower(),\\n permanent=permanent,\\n comment=comment)\\n else:\\n self._consumer.order_produce(item=item,\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'promote':\\n try:\\n unit = OrdersParser._parse_unit(tokens)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n else:\\n self._consumer.order_promote(unit=unit, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'quit':\\n if not tokens:\\n self._consumer.order_quit(permanent=permanent, comment=comment)\\n else:\\n self._consumer.order_quit(password=tokens.popleft(),\\n permanent=permanent, comment=comment)\\n \\n elif order == 'restart':\\n if not tokens:\\n self._consumer.order_restart(permanent=permanent,\\n comment=comment)\\n else:\\n self._consumer.order_restart(password=tokens.popleft(),\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'reveal':\\n if not tokens:\\n self._consumer.order_reveal(reveal=None, permanent=permanent,\\n comment=comment)\\n else:\\n tok = tokens.popleft().lower()\\n if tok == 'none':\\n self._consumer.order_reveal(reveal=None, comment=comment,\\n permanent=permanent)\\n elif tok in ('unit', 'faction'):\\n self._consumer.order_reveal(reveal=tok, comment=comment,\\n permanent=permanent)\\n else:\\n raise SyntaxError('{}: invalid value'.format(line))\\n \\n elif order == 'sail':\\n try:\\n dirs = [OrdersParser._parse_dir(d.lower(), allow_enter=False) \\\\\\n for d in tokens]\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n else:\\n self._consumer.order_sail(dirs=dirs, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'sell':\\n if not tokens:\\n raise SyntaxError('{}: missing amount'.format(line))\\n num = tokens.popleft().lower()\\n if num == 'all':\\n num = OrdersParser.AMT_ALL\\n else:\\n num = OrdersParser._value(num)\\n if not num:\\n raise SyntaxError('{}: missing amount'.format(line))\\n if not tokens:\\n raise SyntaxError('{}: missing item'.format(line))\\n self._consumer.order_sell(num=num, item=tokens.popleft().lower(),\\n permanent=permanent, comment=comment)\\n \\n elif order == 'share':\\n if not tokens:\\n raise SyntaxError('{}: invalid value'.format(line))\\n try:\\n share = OrdersParser._parse_TF(tokens.popleft())\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n self._consumer.order_share(flag=share, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'show':\\n try:\\n what, item = tokens.popleft().lower(), tokens.popleft().lower()\\n except IndexError:\\n raise SyntaxError('{}: missing target'.format(line))\\n if what == 'skill':\\n self._consumer.order_show(permanent=permanent, comment=comment,\\n skill=item)\\n elif what == 'item':\\n self._consumer.order_show(permanent=permanent, comment=comment,\\n item=item)\\n elif what == 'object':\\n self._consumer.order_show(permanent=permanent, comment=comment,\\n structure=item)\\n else:\\n raise SyntaxError('{}: invalid target'.format(line))\\n \\n elif order == 'spoils':\\n if not tokens:\\n tok = 'all'\\n else:\\n tok = tokens.popleft().lower()\\n if tok in ('none', 'walk', 'fly', 'swim', 'sail', 'all'):\\n self._consumer.order_spoils(spoils=tok, permanent=permanent,\\n comment=comment)\\n else:\\n raise SyntaxError('{}: invalid option'.format(line))\\n \\n elif order == 'steal':\\n try:\\n unit = OrdersParser._parse_unit(tokens)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n if not tokens:\\n raise SyntaxError('{}: missing item'.format(line))\\n else:\\n item = tokens.popleft().lower()\\n self._consumer.order_steal(target=unit, item=item,\\n permanent=permanent, comment=comment)\\n \\n elif order == 'study':\\n if not tokens:\\n raise SyntaxError('{}: missing skill'.format(line))\\n sk = tokens.popleft().lower()\\n if tokens:\\n self._consumer.order_study(\\n skill=sk, level=OrdersParser._value(tokens.popleft()),\\n permanent=permanent, comment=comment)\\n else:\\n self._consumer.order_study(skill=sk, permanent=permanent,\\n comment=comment)\\n \\n elif order == 'take':\\n if not tokens or tokens.popleft().lower() != 'from':\\n raise SyntaxError('{}: missing from'.format(line))\\n if not tokens:\\n raise SyntaxError('{}: missing unit'.format(line))\\n unit = OrdersParser._value(tokens.popleft())\\n if not unit:\\n raise SyntaxError('{}: invalid unit'.format(line))\\n target = {'unitnum': unit}\\n if not tokens:\\n raise SyntaxError('{}: missing amount'.format(line))\\n amt = tokens.popleft().lower()\\n if amt != 'all':\\n amt = OrdersParser._value(amt)\\n if not amt:\\n raise SyntaxError('{}: invalid amount'.format(line))\\n try:\\n item = tokens.popleft().lower()\\n if item == 'unfinished':\\n unfinished = True\\n item = tokens.popleft().lower()\\n else:\\n unfinished = False\\n except:\\n raise SyntaxError('{}: missing item'.format(line))\\n \\n if tokens and tokens[0].lower() == 'except':\\n tok = tokens.popleft().lower()\\n if amt != 'all':\\n raise SyntaxError(\\n '{}: except only valid with all'. format(line))\\n if not tokens:\\n raise SyntaxError(\\n '{}: missing except value'.format(line))\\n excpt = OrdersParser._value(tokens.popleft())\\n if not excpt:\\n raise SyntaxError(\\n '{}: invalid except value'.format(line))\\n self._consumer.order_takefrom(permanent=permanent,\\n comment=comment,\\n target=target,\\n give={'amt': amt, 'item': item,\\n 'unfinished': unfinished,\\n 'excpt': excpt})\\n else:\\n self._consumer.order_takefrom(permanent=permanent,\\n comment=comment,\\n target=target,\\n give={'amt': amt, 'item': item,\\n 'unfinished': unfinished})\\n \\n elif order == 'tax':\\n self._consumer.order_tax(permanent=permanent, comment=comment)\\n \\n elif order == 'teach':\\n if not tokens:\\n raise SyntaxError('{}: missing target'.format(line))\\n targets = []\\n try:\\n while tokens:\\n targets.append(OrdersParser._parse_unit(tokens))\\n except SyntaxError as e:\\n self._consumer.order_teach(targets=targets,\\n permanent=permanent,\\n comment=comment)\\n raise SyntaxError('{}: {}'.format(line, e))\\n else:\\n self._consumer.order_teach(targets=targets,\\n permanent=permanent,\\n comment=comment)\\n \\n elif order == 'work':\\n self._consumer.order_work(permanent=permanent, comment=comment)\\n \\n elif order == 'transport':\\n try:\\n target = OrdersParser._parse_unit(tokens)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n if not tokens:\\n raise SyntaxError('{}: missing amount'.format(line))\\n amt = tokens.popleft().lower()\\n if amt != 'all':\\n amt = OrdersParser._value(amt)\\n if not amt:\\n raise SyntaxError('{}: invalid amount'.format(line))\\n try:\\n item = tokens.popleft().lower()\\n if item == 'unfinished':\\n unfinished = True\\n item = tokens.popleft().lower()\\n else:\\n unfinished = False\\n except:\\n raise SyntaxError('{}: missing item'.format(line))\\n\\n if tokens and tokens[0].lower() == 'except':\\n tok = tokens.popleft().lower()\\n if amt != 'all':\\n raise SyntaxError(\\n '{}: except only valid with all'. format(line))\\n if not tokens:\\n raise SyntaxError(\\n '{}: missing except value'.format(line))\\n excpt = OrdersParser._value(tokens.popleft())\\n if not excpt:\\n raise SyntaxError(\\n '{}: invalid except value'.format(line))\\n self._consumer.order_transport(permanent=permanent,\\n comment=comment,\\n target=target,\\n give={'amt': amt, 'item': item,\\n 'unfinished': unfinished,\\n 'excpt': excpt})\\n else:\\n self._consumer.order_transport(permanent=permanent,\\n comment=comment,\\n target=target,\\n give={'amt': amt, 'item': item,\\n 'unfinished': unfinished})\\n \\n elif order == 'distribute':\\n try:\\n target = OrdersParser._parse_unit(tokens)\\n except SyntaxError as e:\\n raise SyntaxError('{}: {}'.format(line, e))\\n if not tokens:\\n raise SyntaxError('{}: missing amount'.format(line))\\n amt = tokens.popleft().lower()\\n if amt != 'all':\\n amt = OrdersParser._value(amt)\\n if not amt:\\n raise SyntaxError('{}: invalid amount'.format(line))\\n try:\\n item = tokens.popleft().lower()\\n if item == 'unfinished':\\n unfinished = True\\n item = tokens.popleft().lower()\\n else:\\n unfinished = False\\n except:\\n raise SyntaxError('{}: missing item'.format(line))\\n \\n if tokens and tokens[0].lower() == 'except':\\n tok = tokens.popleft().lower()\\n if amt != 'all':\\n raise SyntaxError(\\n '{}: except only valid with all'. format(line))\\n if not tokens:\\n raise SyntaxError(\\n '{}: missing except value'.format(line))\\n excpt = OrdersParser._value(tokens.popleft())\\n if not excpt:\\n raise SyntaxError(\\n '{}: invalid except value'.format(line))\\n self._consumer.order_distribute(permanent=permanent,\\n comment=comment,\\n target=target,\\n give={'amt': amt, 'item': item,\\n 'unfinished': unfinished,\\n 'excpt': excpt})\\n else:\\n self._consumer.order_distribute(permanent=permanent,\\n comment=comment,\\n target=target,\\n give={'amt': amt, 'item': item,\\n 'unfinished': unfinished})\",\n \"def _parseAttributeString(self, line):\\n attribute, value = line.partition(' ')[::2]\\n self._setAttribute(attribute, value)\",\n \"def parse_line(line):\\n\\tpattern = re.compile(\\\"\\\"\\\"\\n\\t\\t[ \\\\t]*\\n\\t\\t(private|package|remote|public)*[ ]*\\n\\t\\t(any|string|array|numeric|boolean|component|struct|void)*[ ]*\\n\\t\\t(function[ ]+|\\\\<cffunction[ ]+name[ ]*=[ ]*\\\\\\\"?)([_\\\\-a-z][a-z0-9_\\\\-]+)\\n\\t\\t\\\"\\\"\\\", \\n\\t\\tre.VERBOSE|re.MULTILINE|re.IGNORECASE)\\n\\tm = pattern.match(line)\\n\\t#return the 5th gouped regex, which should be the function name\\n\\tret_val = m.group(4) if m else ''\\n\\treturn ret_val\",\n \"def parse(self,line,mult,notifies):\\n return 0\",\n \"def _parseLine(self, line, delimiter = \\\":\\\"):\\r\\n\\t\\tsplt = line.split(delimiter)\\r\\n\\t\\tinVec = self._parseVec(splt[0])\\r\\n\\t\\toutVec = self._parseVec(splt[1])\\r\\n\\t\\tif (len(splt) == 2):\\r\\n\\t\\t\\tlabel = \\\"\\\"\\r\\n\\t\\telse:\\r\\n\\t\\t\\tlabel = splt[2]\\r\\n\\t\\tself.data.append({'in':inVec, 'out':outVec, 'label':label})\",\n \"def parseApacheLogLine(logline):\\r\\n match = re.search(APACHE_ACCESS_LOG_PATTERN, logline) # Matching pattern with each element\\r\\n size_field = match.group(9) # Get size fields\\r\\n if size_field == '-': \\r\\n size = long(0) # make it zero\\r\\n else:\\r\\n size = long(match.group(9)) # else convert it to long format\\r\\n return (Row( # Return the extracted data in row format for easy access\\r\\n host = match.group(1),\\r\\n client_identd = match.group(2),\\r\\n user_id = match.group(3),\\r\\n date_time = parse_apache_time(match.group(4)),\\r\\n method = match.group(5),\\r\\n endpoint = match.group(6),\\r\\n protocol = match.group(7),\\r\\n response_code = int(match.group(8)),\\r\\n content_size = size\\r\\n ))\",\n \"def parse(self, line):\\n try:\\n (year, month, day, hour, minute, second, microseconds, offset_hour, offset_minute, source, process, logentry) = re.match('^(\\\\d\\\\d\\\\d\\\\d)-(\\\\d\\\\d)-(\\\\d\\\\d)T(\\\\d\\\\d):(\\\\d\\\\d):(\\\\d\\\\d)\\\\.([\\\\d]+)\\\\+(\\\\d\\\\d):(\\\\d\\\\d) ([a-z]+)\\\\[([a-zA-Z0-9_.]+)\\\\]: ([0-9a-z-A-Z\\\\-_\\\\.\\\\[\\\\]:\\\\?\\\\#\\\\\\\",/\\\\ ={}\\\\'\\\\(\\\\)<>]+)$', line).groups()\\n except:\\n pass\\n \\n try:\\n parsed_data = dict()\\n parsed_data['timestamp'] = \\\" \\\".join([\\\"-\\\".join([year, month, day]), \\\":\\\".join([hour, minute, second])])\\n parsed_data['log_time'] = datetime.datetime(int(year), int(month), int(day), int(hour), int(minute), int(second))\\n parsed_data['log_source'] = source\\n parsed_data['log_type'] = process\\n except (AttributeError, UnboundLocalError):\\n PARSE_ERRORS.append(line)\\n return False\\n\\n #TODO: This still needs work on spaces in values surrounded by \\\" \\\" \\n if parsed_data['log_source'] == \\\"heroku\\\":\\n if logentry.__len__() > 1:\\n logentry = re.sub(', ', ',', logentry)\\n line_chunks = re.split(' ', logentry)\\n for chunk in line_chunks:\\n line_chunks = re.split('=', chunk)\\n if line_chunks.__len__() > 2:\\n #fwd and path are a little clunky to parse\\n pass\\n elif line_chunks.__len__() > 1:\\n parsed_data[line_chunks[0]] = line_chunks[1]\\n else:\\n pass\\n else:\\n return False\\n else:\\n # TODO: [app] \\n # Needs parsing. Do that here.\\n return False\\n\\n return parsed_data\",\n \"def parse(self, line):\\n\\t\\n\\t# remove trailing newline a-la Perl CHOMP\\n\\tline = line.rstrip(\\\"\\\\n\\\")\\n\\n\\t\\n # correctly formatted PDB files\\n # TODO - assuming 80 chars means well formatted is\\n # perhaps risky. Need a more robust way to asses\\n # formatting validity\\n\\n if len(line) == 80:\\n self.record_name = line[0:6].strip()\\n self.atom_id = int(line[6:11].strip())\\n self.atom_name = line[12:16].strip()\\n self.alt_location = line[16]\\n self.res_name = line[17:20].strip()\\n self.chain = line[21]\\n self.res_id = line[22:26].strip()\\n self.res_ins_code = line[26]\\n self.coord_X = float(line[30:38].strip())\\n self.coord_Y = float(line[38:46].strip())\\n self.coord_Z = float(line[46:54].strip())\\n self.occupancy = float(line[54:60].strip())\\n self.beta = float(line[60:66].strip())\\n self.seg_ID = line[72:76].strip()\\n self.element = line[76:78].strip()\\n\\t if line[78:80].strip() == \\\"\\\":\\n\\t\\t self.charge=0.0\\n\\t else:\\n\\t\\t self.charge = float(line[78:80].strip())\\n self.chain_local_id = -1\\n self.formatted_ok = True\\n\\n # Heuristic section - split by space and then use\\n # errors in casting as flags for things being issues\\n # Note this may need to be expanded as malformed edge-cases\\n # are identified...\\n else:\\n rawsplitline = filter(None, line.split(\\\" \\\"))\\n\\t \\n\\t \\n\\n splitline = []\\n for i in rawsplitline:\\n if i == \\\"\\\\n\\\" or i == \\\"\\\\t\\\":\\n pass\\n else:\\n splitline.append(i)\\n \\n num_cols = len(splitline)\\n\\n\\t print num_cols\\n \\n try:\\n if num_cols == 10:\\n self.record_name = splitline[0] \\n self.atom_id = int(splitline[1])\\n self.atom_name = splitline[2] \\n self.alt_location = \\\"\\\"\\n self.res_name = splitline[3] \\n self.chain = \\\"\\\"\\n self.res_id = int(splitline[4])\\n self.res_ins_code = \\\"\\\"\\n self.coord_X = float(splitline[5]) \\n self.coord_Y = float(splitline[6]) \\n self.coord_Z = float(splitline[7])\\n self.occupancy = float(splitline[8])\\n self.beta = float(splitline[9])\\n self.seg_ID = \\\" \\\"\\n self.element = \\\" \\\" \\n self.charge = \\\" \\\"\\n self.chain_local_id = -1\\n self.formatted_ok = False\\n\\n elif num_cols == 11:\\n self.record_name = splitline[0] \\n self.atom_id = int(splitline[1])\\n self.atom_name = splitline[2] \\n self.alt_location = \\\" \\\"\\n self.res_name = splitline[3] \\n self.chain = splitline[4]\\n self.res_id = int(splitline[5])\\n self.res_ins_code = \\\" \\\"\\n self.coord_X = float(splitline[6]) \\n self.coord_Y = float(splitline[7]) \\n self.coord_Z = float(splitline[8]) \\n self.occupancy = float(splitline[9]) \\n self.beta = float(splitline[10])\\n self.seg_ID = \\\" \\\"\\n self.element = \\\" \\\" \\n self.charge = \\\" \\\"\\n self.chain_local_id = -1\\n self.formatted_ok = False\\n\\n elif num_cols == 12:\\n self.record_name = splitline[0] \\n self.atom_id = int(splitline[1])\\n self.atom_name = splitline[2] \\n self.alt_location = \\\" \\\"\\n self.res_name = splitline[3] \\n self.chain = splitline[4]\\n self.res_id = int(splitline[5])\\n self.res_ins_code = \\\" \\\"\\n self.coord_X = float(splitline[6]) \\n self.coord_Y = float(splitline[7]) \\n self.coord_Z = float(splitline[8]) \\n self.occupancy = float(splitline[9]) \\n self.beta = float(splitline[10])\\n self.seg_ID = \\\" \\\"\\n self.element = splitline[11] \\n self.charge = \\\" \\\"\\n self.chain_local_id = -1\\n self.formatted_ok = False\\n else:\\n raise PDB_atomException(\\\"Did not match number of columns\\\")\\n except ValueError,e:\\n print \\\"Error with columns (using \\\" + str(num_cols) + \\\") columns\\\"\\n print \\\"Tried to cast string to int/float\\\"\\n raise e\",\n \"def parse_line(self, line):\\n command, _, arg = line.strip().partition(\\\" \\\")\\n return command, arg.strip()\",\n \"def parse_line(self, line, time_shift=0.0):\\n # The local variables are rather simple.\\n # pylint: disable=too-many-locals\\n try:\\n date, time_, dir_or_size, name = line.split(None, 3)\\n except ValueError:\\n # \\\"unpack list of wrong size\\\"\\n raise ftputil.error.ParserError(\\\"line '{}' can't be parsed\\\".format(line))\\n # st_mode\\n # Default to read access only; in fact, we can't tell.\\n st_mode = 0o400\\n if dir_or_size == \\\"<DIR>\\\":\\n st_mode = st_mode | stat.S_IFDIR\\n else:\\n st_mode = st_mode | stat.S_IFREG\\n # st_ino, st_dev, st_nlink, st_uid, st_gid\\n st_ino = None\\n st_dev = None\\n st_nlink = None\\n st_uid = None\\n st_gid = None\\n # st_size\\n if dir_or_size != \\\"<DIR>\\\":\\n try:\\n st_size = int(dir_or_size)\\n except ValueError:\\n raise ftputil.error.ParserError(\\\"invalid size {}\\\".format(dir_or_size))\\n else:\\n st_size = None\\n # st_atime\\n st_atime = None\\n # st_mtime\\n st_mtime, st_mtime_precision = self.parse_ms_time(\\n date, time_, time_shift, with_precision=True\\n )\\n # st_ctime\\n st_ctime = None\\n stat_result = StatResult(\\n (\\n st_mode,\\n st_ino,\\n st_dev,\\n st_nlink,\\n st_uid,\\n st_gid,\\n st_size,\\n st_atime,\\n st_mtime,\\n st_ctime,\\n )\\n )\\n # These attributes are kind of \\\"half-official\\\". I'm not sure whether\\n # they should be used by ftputil client code.\\n # pylint: disable=protected-access\\n # _st_name and _st_target\\n stat_result._st_name = name\\n stat_result._st_target = None\\n # mtime precision in seconds\\n stat_result._st_mtime_precision = st_mtime_precision\\n return stat_result\",\n \"def parseline(self, line):\\n line = line.strip()\\n if not line:\\n return None, None, line\\n elif line[0] == '?':\\n line = 'help ' + line[1:]\\n elif line[0] == '!':\\n if hasattr(self, 'do_shell'):\\n line = 'shell ' + line[1:]\\n else:\\n return None, None, line\\n return '', '', line\",\n \"def __init__(self, line):\\n # Throw an exception if we don't see the parenthesis that mark a date entry\\n if not line[108] == '(':\\n raise ParsingException\\n if not line[164:165] == ')':\\n raise ParsingException\\n\\n # Parsing definitions\\n self.start_time = datetime.strptime(line[109:125], '%d-%b-%Y %H%M')\\n self.end_time = datetime.strptime(line[128:144], '%d-%b-%Y %H%M')\\n self.time_stamp = datetime.strptime(line[148:164], '%m/%d/%Y %H:%M')\",\n \"def next_line(self, context, line):\",\n \"def parse_line(line):\\n return parse('#{id_:d} @ {x:d},{y:d}: {w:d}x{h:d}', line)\",\n \"def parseLine(line):\\n\\n\\teq = line.find('=')\\n\\tif eq == -1: raise Exception()\\n\\tkey = line[:eq].strip()\\n\\tvalue = line[eq+1:-1].strip()\\n\\treturn key, parseValue(value)\",\n \"def process_idx_file_line(self, line):\\n pass\",\n \"def parse_mod_entry(self, line):\\n split_line = line.split(' ')\\n enable = split_line.pop(0)\\n path = split_line.pop()\\n version = split_line.pop()\\n name = split_line.pop()\\n return enable, name, version, path\",\n \"def _parse(self, line):\\n comd, value = cmd.parse(line, CLIENT_PREFIX)\\n if comd == 'reg':\\n self.peername = value\\n elif comd == 'eof':\\n self._reset()\\n msg = cmd.clientcmd(comd, value)\\n msg = cmd.addFirst(msg, self.peername)\\n self.sendString(msg)\\n elif comd == 'fail':\\n self._reset()\\n else:\\n return False\\n return True\",\n \"def parse_user_dict(self, line):\\n pass\",\n \"def parseLine(self, line):\\n # Removes surrounding whitespace\\n line = self.separateElements(line)\\n if len(line) == 0: return\\n # Checks if the line is a label declaration\\n if line[0].lower() == \\\"label\\\":\\n # --Validates the line\\n if len(line) != 2: raise Exception(\\\"Invalid Label\\\")\\n if len(line[1]) < 2: raise Exception(\\\"Invalid Label\\\") \\n if line[1][-1] != ':': raise Exception(\\\"Invalid Label\\\")\\n # Gets the label name\\n labelName = line[1][:-1]\\n\\n # Creates a new symbol entry for the label, the pointer refers to the memory location of the label\\n # It defaults to the location of the label in the instruction sequence\\n self.symbolTable.append({ \\\"type\\\": \\\"LABEL\\\", \\\"name\\\": labelName, \\\"pointer\\\": len(self.instructionList) * 4})\\n # Checks if the line is data declaration\\n elif line[0].lower() == \\\"data\\\" or (line[0].lower()[:4] == \\\"data\\\" and line[0][4] == \\\"[\\\"):\\n # Removes the DATA tag from the data\\n line[0] = line[0][4:]\\n # --Validates the line\\n if len(line) < 2: raise Exception(\\\"Invalid DATA\\\")\\n # Gets the data name\\n dataName = line[1]\\n # Stores the data length\\n dataLength = 4 # A word\\n # Gets any default data\\n defaultData = 0\\n # Stores the data type\\n dataType = \\\"int\\\"\\n if len(line) == 3:\\n if line[2][0] == \\\"\\\\\\\"\\\" and line[2][-1] == \\\"\\\\\\\"\\\":\\n dataType = \\\"string\\\"\\n defaultData = line[2][1:-1]\\n dataLength = len(defaultData)\\n elif line[2].isnumeric():\\n defaultData = line[2]\\n elif line[2][-1] == 'f' and line[2][:-1].isnumeric():\\n dataType = \\\"float\\\"\\n defaultData = line[2][0]\\n # Checks if a data length was given\\n if len(line[0]) > 2 and (line[0][0] == \\\"[\\\" and line[0][-1] == \\\"]\\\"):\\n data = line[0][1:-1]\\n if not data.isnumeric(): raise TypeError(\\\"Invalid data length type\\\")\\n dataLength = int(data)\\n\\n # Creates a new symbol entry for the data\\n self.symbolTable.append({ \\\"type\\\": \\\"DATA\\\", \\\"name\\\": dataName, \\\"default\\\": defaultData, \\\"dataType\\\": dataType, \\\"length\\\": dataLength})\\n # The line is most likely an instruction\\n else:\\n # --Validates the line\\n #Stores the control bits\\n controlBits = 1 << 5 # Sets it to 0b100000\\n # Checks if the first element is control bits\\n if line[0][0] == \\\"{\\\" and line[0][-1] == \\\"}\\\": # First element is control bits\\n # Separates the two sections of the control bits\\n controlSections = line[0].split(':')\\n #Goes through the characters and constructs the control bits for the instruction\\n carryBits = controlSections[0].lower()\\n carryFlag = int('c' in carryBits)\\n zeroFlag = int('z' in carryBits)\\n negativeFlag = int('n' in carryBits)\\n signedOverflowFlag = int('s' in carryBits)\\n #Gets the conditions bits\\n if len(controlSections) == 2:\\n conditionBits = controlSections[1].lower()\\n isAnd = int('x' in conditionBits)\\n isOne = int('1' in conditionBits)\\n #Sets the last two bits on controlBits to the conditionBits\\n controlBits ^= isAnd << 1\\n controlBits ^= isOne\\n # Constructs the control bits section\\n controlBits ^= carryFlag << 5\\n controlBits ^= zeroFlag << 4\\n controlBits ^= negativeFlag << 3\\n controlBits ^= signedOverflowFlag << 2\\n # Removes the control bits section from the line\\n line.pop(0)\\n # Performs this check as the controlbits element gets removed (if it existed) and so the length of the elments could be zerp\\n if len(line) == 0: raise Exception(\\\"Invalid Instruction\\\")\\n # --The first element is the instruction\\n # Identifies the instruction from the mnemonic using the lookup table\\n if line[0] in self.InstructionLookupTable:\\n ins = self.InstructionLookupTable[line[0]]\\n insCode = ins[\\\"code\\\"]\\n insControlBits = ins['controlBits'] if ins['controlBits'] else controlBits\\n # Creates a representation of the instruction, this is stored in the instructionList and is assembled later\\n instrucitonRepr = {\\n \\\"code\\\": insCode,\\n \\\"controlBits\\\": insControlBits,\\n }\\n # Parses the arguments given and stores the operandStruct returned in the instruciton representation\\n if len(line) > 1: instrucitonRepr[\\\"operand\\\"] = self.parseArgs(line[1:], insCode)\\n self.instructionList.append(instrucitonRepr)\",\n \"def _parse(self, line):\\n comd, value = cmd.parse(line, SERVER_PREFIX)\\n player = self.player\\n if comd == 'play':\\n audio, seek = cmd.separate(value)\\n player.playFile(audio, seek=float(seek))\\n newline = 'Player started playing %s' %(value)\\n elif comd == 'seek':\\n value = float(value)\\n player.seekto(value)\\n newline = 'Forwared to %d seconds' %(value)\\n elif comd == 'pause':\\n player.pause()\\n newline = 'Player Paused'\\n elif comd == 'volume':\\n value = float(value)\\n player.volume = value\\n newline = 'Volume changed to %d' %(value)\\n else:\\n return line\\n return newline\",\n \"def parse_line(line):\\n if len(line) < 11:\\n exit(\\\"invalid Intel HEX line: %s\\\" % line)\\n if line[0] != ':':\\n exit(\\\"invalid Intel HEX line: %s\\\" % line)\\n line = line[1:]\\n try:\\n int(line, 16)\\n except ValueError:\\n exit(\\\"invalid Intel HEX line: %s\\\" % line)\\n line = line.decode('hex')\\n return Line(line[0], line[1:3], line[3], line[4:-1], line[-1])\",\n \"def _parse_line(self, line):\\n with open(self._manifest.path, 'r') as manifest_file:\\n if isinstance(line, str):\\n assert line in self.BASE_INFORMATION.keys(), \\\\\\n 'An attempt to get non-existent information from the manifest'\\n for _ in range(self.BASE_INFORMATION[line]):\\n fline = manifest_file.readline()\\n return json.loads(fline)[line]\\n else:\\n assert self._index, 'No prepared index'\\n offset = self._index[line]\\n manifest_file.seek(offset)\\n properties = manifest_file.readline()\\n return json.loads(properties)\",\n \"def _parse_general_info(self, line):\\n if self._regex_helper.search_compiled(W._re_general_info, line):\\n self.current_ret['GENERAL_INFO'].update({\\n 'time': datetime.datetime.strptime(self._regex_helper.group(\\\"TIME\\\"), '%H:%M:%S').time(),\\n 'uptime': self._regex_helper.group(\\\"UPTIME\\\"),\\n 'user_number': self._regex_helper.group(\\\"USER_NUMBER\\\"),\\n 'load_average': self._regex_helper.group(\\\"L_AVERAGE\\\")\\n })\\n raise ParsingDone\",\n \"def getLineInformation(line):\\n \\n pass\",\n \"def _parse(line: str) -> Tuple[int, str, str, bool]:\\n level, tag, args = None, None, None\\n try:\\n # Try to split the line into three parts, then try two parts\\n try:\\n level, tag, args = line.split(' ', maxsplit=2)\\n except ValueError:\\n try:\\n level, tag = line.split(' ', maxsplit=1)\\n except ValueError:\\n raise InvalidLineException(f'Invalid line: {line}')\\n\\n # INDI nor FAM should not be the tag\\n if tag in ('INDI', 'FAM'):\\n raise InvalidLineException(f'Invalid tag {line}')\\n\\n # If INDI or FAM are args, swap the args and tag\\n if args in ('INDI', 'FAM'):\\n temp = args\\n args = tag\\n tag = temp\\n\\n # Level must be between 0 and 2 inclusive\\n if level not in ('0', '1', '2'):\\n raise InvalidLineException(f'Invalid level: {level}')\\n level = int(level)\\n\\n # Allow a trailing space\\n if args == '':\\n args = None\\n\\n if tag == 'INDI':\\n assert level == 0\\n assert args is not None\\n elif tag == 'NAME':\\n assert level == 1\\n assert args is not None\\n elif tag == 'SEX':\\n assert level == 1\\n assert args in ('M', 'F')\\n elif tag == 'BIRT':\\n assert level == 1\\n assert args is None\\n elif tag == 'DEAT':\\n assert level == 1\\n assert args is None\\n elif tag == 'FAMC':\\n assert level == 1\\n assert args is not None\\n elif tag == 'FAMS':\\n assert level == 1\\n assert args is not None\\n elif tag == 'FAM':\\n assert level == 0\\n assert args is not None\\n elif tag == 'MARR':\\n assert level == 1\\n assert args is None\\n elif tag == 'HUSB':\\n assert level == 1\\n assert args is not None\\n elif tag == 'WIFE':\\n assert level == 1\\n assert args is not None\\n elif tag == 'CHIL':\\n assert level == 1\\n assert args is not None\\n elif tag == 'DIV':\\n assert level == 1\\n assert args is None\\n elif tag == 'DATE':\\n assert level == 2\\n assert args is not None\\n # Date must have valid args\\n try:\\n day, month, year = args.split(' ', maxsplit=2)\\n except ValueError:\\n raise InvalidLineException(f'Not enough values for DATE: {args}')\\n assert day == '0' or not day[0] == '0' and day.isdigit()\\n assert month in ('JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC')\\n assert len(year) == 4 and year.isdigit()\\n elif tag == 'HEAD':\\n assert level == 0\\n assert args is None\\n elif tag == 'TRLR':\\n assert level == 0\\n assert args is None\\n elif tag == 'NOTE':\\n assert level == 0\\n else:\\n raise InvalidLineException(f'Unknown Tag: {tag}')\\n except (AssertionError, InvalidLineException):\\n return level, tag, args, False\\n\\n return level, tag, args, True\",\n \"def from_line(self, line: str):\\n raise NotImplementedError()\",\n \"def read_line(line):\\n label = line[0:11]\\n text = line[11:]\\n y = 1 if label == '__label__2 ' else 0\\n return text, y\",\n \"def __call__( self, line ):\\n return self.__getitem__( line )\",\n \"def __call__( self, line ):\\n return self.__getitem__( line )\",\n \"def _parse_file_line(line):\\n # match initially added ebuilds\\n match = ebuild_ADM_regex.match(line)\\n if match:\\n status = match.group('status')\\n category = match.group('category')\\n pkg = match.group('P')\\n try:\\n return atom_cls(f'={category}/{pkg}'), status\\n except MalformedAtom:\\n return None\\n\\n # match renamed ebuilds\\n match = ebuild_R_regex.match(line)\\n if match:\\n status = match.group('status')\\n category = match.group('category')\\n pkg = match.group('P')\\n try:\\n return atom_cls(f'={category}/{pkg}'), status\\n except MalformedAtom:\\n return None\",\n \"def _read_addenda_record(self, line):\\n addenda_dict = {'Addenda Type Code:': line[1:3],\\n 'Payment Related Info': line[3:83].strip(),\\n 'Addenda Sequence Number': line[83:87],\\n 'Entry Detail Sequence Number': line[87:94]}\\n self.addenda_records.append(addenda_dict)\",\n \"def parse_line(line, key):\\n keys = key.split(', ')\\n ParseLine = (line.get(id) for id in keys)\\n\\n return ParseLine\",\n \"def __parseLine(line):\\n\\n # extract name\\n name_len = line.index(\\\" \\\")\\n name = line[:name_len]\\n line = line[name_len + 3:]\\n\\n # array-ize 'electron' val\\n elec_pos = line.index(\\\"electron\\\") + 9\\n line = line[:elec_pos] + '[' + line[elec_pos:].replace(' ', ',') + ']'\\n\\n # quote 'small' val\\n line = line.replace(' ', '')\\n line = line.replace('small:', 'small:\\\"').replace(',molar', '\\\",molar')\\n\\n # quote all keys\\n for i in [\\\"position\\\", \\\"number\\\", \\\"small\\\", \\\"molar\\\", \\\"electron\\\"]:\\n line = line.replace(i, '\\\"' + i + '\\\"')\\n\\n return eval('{\\\"name\\\":\\\"' + name + '\\\",' + line + '}')\",\n \"def parse_line(self, line):\\n if self.signal_eof:\\n return \\\"\\\"\\n\\n match = re.search(\\\"^([\\\\w\\\\s]+from) ([^:]+):(\\\\d+)(:|,)$\\\", line)\\n if match:\\n return self.parse_line_from(match)\\n\\n match = re.search(\\\"^([^:]+):(?:((?:\\\\d+:)?\\\\d+):)?(?:(error|warning|note):)?(.+)$\\\", line)\\n if match:\\n return self.parse_line_err(match)\\n\\n return line\",\n \"def process_line(line: str):\\n \\n comment_start = line.find(';')\\n\\n # Remove comments, one comment per line allowed\\n if comment_start != -1:\\n line = line[:comment_start]\\n\\n line = line.strip()\\n \\n # Splits commands such that the command and all details are seperated\\n # \\\"command ...\\\" -> [command, ...]\\n try:\\n command, contents = line.split(maxsplit = 1)\\n # Deals with function names, two special commands, and empty lines\\n except ValueError:\\n if line == '':\\n return None\\n elif line[-1] == ':' or line == 'end' or line == 'ret':\\n return (line,)\\n\\n # Splits depending on command type, some requiring one argument, others two\\n try:\\n one, two = contents.split(',')\\n return command, one.strip(), two.strip()\\n except ValueError:\\n return command, contents.strip()\",\n \"def read_line(self, line):\\n line_in_asm_array = list()\\n documentation = [\\\"//\\\" + line]\\n line_in_asm_array.extend(documentation)\\n command_type = Parser.commandType(line)\\n\\n # not supposed to happen:\\n # if command_type is None:\\n # print(\\\"problem\\\")\\n\\n self.update_last_function(line, command_type)\\n translated_lines = self.get_correct_lines(command_type, line)\\n\\n self.label_counter = self.label_counter + 1\\n line_in_asm_array.extend(translated_lines)\\n self.assembler_lines.append(line_in_asm_array)\",\n \"def readline(self) -> str | None:\",\n \"def parse_line(line):\\n log_line = LogLine(line)\\n dt = datetime.datetime.strptime(log_line.line[0], \\\"%Y-%m-%d %H:%M:%S\\\")\\n # make a tuple with dt and the rest (splatted)\\n return (dt, *log_line.line[1:])\",\n \"def parser(line):\\n # Remove comment and whitespace\\n line = re.sub(r'//.*', '' , line) # remove comment\\n line = line.strip() # remove whitespace\\n\\n # Parse A instruction, return int or string\\n if line.find('@') == 0:\\n try:\\n parsed = int(line[1:])\\n flag = \\\"A_DECIMAL\\\"\\n except:\\n parsed = line[1:]\\n flag = \\\"A_INSTRUCTION\\\"\\n\\n elif line.startswith(\\\"(\\\") and line.endswith(\\\")\\\"):\\n parsed = line[1:-1]\\n flag = \\\"GOTO_INSTRUCTION\\\"\\n else:\\n # Parse C instruction, return tuple\\n if line.find(';') != -1:\\n comp, jump = line.split(';') # comp ; jump\\n dest = \\\"null\\\"\\n if comp.find('=') != -1:\\n dest, comp = comp.split('=') # dest = comp ; jump\\n parsed = comp, dest, jump\\n flag = \\\"C_INSTRUCTION\\\"\\n\\n elif line.find('=') != -1:\\n dest, comp = line.split('=') # dest = comp\\n jump = \\\"null\\\"\\n parsed = comp, dest, jump\\n flag = \\\"C_INSTRUCTION\\\"\\n else:\\n parsed = None\\n flag = None\\n\\n return parsed, flag\",\n \"def parse_line(cls, line):\\n assert isinstance(line, bytes)\\n\\n match = HEADER_FIELD_REGEX.match(line)\\n\\n if not match:\\n raise HeaderParseError(line)\\n\\n name, content = (s.decode(\\\"ascii\\\").strip() for s in match.groups(b\\\"\\\"))\\n name = name.lower()\\n\\n if name != \\\"set-cookie\\\" or is_rfc1123_datetime(content):\\n content = cls.split_field_content(content)\\n\\n return (name, content)\",\n \"def parseInputLine(self, line):\\r\\n if line is not None and line is not '':\\r\\n func = getattr(self, 'cmd_' + line.split()[0].upper(), None)\\r\\n if func is not None:\\r\\n func(line.split()[1:])\\r\\n else:\\r\\n self.terminal.write('No such command')\\r\\n self.showPrompt()\",\n \"def _parse_single_line(self, statement_line: str) -> List[str]:\\r\\n space_split = statement_line.split(\\\" \\\")\\r\\n\\r\\n ref = int(space_split[0])\\r\\n\\r\\n transaction_date = \\\" \\\".join(space_split[1:3])\\r\\n\\r\\n post_date = \\\" \\\".join(space_split[3:5])\\r\\n\\r\\n # find column of the amount\\r\\n col_amount = -1\\r\\n while len(space_split[col_amount]) < 1:\\r\\n col_amount -= 1\\r\\n amount = space_split[col_amount]\\r\\n amount = self._convert_amount_to_float(amount=amount)\\r\\n\\r\\n details = \\\" \\\".join(space_split[5:col_amount])\\r\\n return ref, transaction_date, post_date, details, amount\",\n \"def process_line(self, line):\\n columns = line.split('|')\\n\\n if len(line) == 0 or len(columns) < 16:\\n return None # empty line or malformed line\\n\\n cmte_id, name, zip_code = columns[0], columns[7], columns[10][:5]\\n transaction_dt, transaction_amt = columns[13], columns[14]\\n other_id = columns[15]\\n\\n if len(other_id) > 0 or len(transaction_amt) == 0 or len(cmte_id) == 0 or len(name) == 0 or len(zip_code) < 5:\\n return None # malformed data fields, ignore this line\\n transaction_date = string_to_date(transaction_dt)\\n if transaction_date is None:\\n return None # 'TRANSACTION_DT' is an invalid date\\n\\n try:\\n if self.repeat_donor(name, zip_code, transaction_date.year):\\n # this record is from a repeat donor in any prior calendar year\\n amount = float(transaction_amt)\\n key = RecipientZipYear(cmte_id, zip_code, transaction_date.year)\\n if key not in self.running_percentile:\\n self.running_percentile[key] = RunningPercentile(self.percentile)\\n self.running_percentile[key].add(amount)\\n return self.print_record(key)\\n else:\\n return None # this record is not from a repeat donor\\n except:\\n return None # exception may comes from malformed line, so just ignore this line\",\n \"def parse (self, line):\\n result = self.program.parseString (line)\\n return TranQL_AST (result.asList (), self.backplane)\",\n \"def _next_record(self, next_line):\\n record = self.loader.parse_record_stream(self.reader,\\n next_line,\\n self.known_format)\\n\\n self.member_info = None\\n\\n # Track known format for faster parsing of other records\\n self.known_format = record.format\\n\\n return record\",\n \"def parse(self, input):\\n pass\",\n \"def parse_line(self, line: str, src_ntypes=None, adj_ntypes=None, etypes=None, prev_data: PrevData = None, verbose=__debug__):\\r\\n\\r\\n if prev_data:\\r\\n prev_src_data, prev_adj_data = prev_data\\r\\n if not line:\\r\\n if prev_adj_data:\\r\\n prev_src_data.update(prev_adj_data)\\r\\n return prev_src_data\\r\\n line = line.lstrip()\\r\\n if line[0].startswith(self.comment_indicator):\\r\\n return None, prev_data\\r\\n prev_data = bool(prev_data)\\r\\n else:\\r\\n ensure_arg_not_none_or_empty(arg_val=line, arg_name='line', extra_msg='the input graph adjacency/path line to parse is empty')\\r\\n line = line.lstrip()\\r\\n if line[0].startswith(self.comment_indicator):\\r\\n return None\\r\\n\\r\\n splits = line.split(self.node_sep)\\r\\n if len(splits) <= 1:\\r\\n raise ValueError(f\\\"the string `{line}` does not seen to describe an adjacency list or a path, while using `{self.node_sep}` as the delimiter\\\")\\r\\n try:\\r\\n data_entry = self._parse_by_format2(key_prefix='src_', format_obj=self.source_node_format, format_type=self._source_node_format_type, text=splits[0])\\r\\n use_prev_data: bool = prev_data and prev_src_data is not None and data_entry['src_nid'] == prev_src_data['src_nid']\\r\\n except Exception as err:\\r\\n raise extra_msg(err,\\r\\n f\\\"a source node cannot be parsed from the string `{splits[0]}`; the whole line to parse is `{line}`\\\")\\r\\n\\r\\n if src_ntypes is None or data_entry.get('src_ntype', None) in src_ntypes: # applies the source node type filter\\r\\n adj_data = prev_adj_data if use_prev_data and prev_adj_data is not None else PaddedListDict()\\r\\n for adj_node_edge_str in splits[1:]:\\r\\n cur_adj_data = self._parse_by_format2(key_prefix='adj_', format_obj=self.adj_node_format, format_type=self._adj_node_format_type, text=adj_node_edge_str)\\r\\n if (adj_ntypes and cur_adj_data.get('adj_ntype', None) not in adj_ntypes) or (etypes and cur_adj_data.get('adj_etype', None) not in etypes):\\r\\n continue\\r\\n adj_data += cur_adj_data\\r\\n\\r\\n if prev_data:\\r\\n if use_prev_data:\\r\\n data_entry.update(prev_src_data)\\r\\n return None, (data_entry, adj_data)\\r\\n else:\\r\\n if prev_adj_data:\\r\\n prev_src_data.update(prev_adj_data)\\r\\n return prev_src_data, (data_entry, adj_data)\\r\\n else:\\r\\n if adj_data:\\r\\n data_entry.update(adj_data)\\r\\n return data_entry\\r\\n else:\\r\\n return None\\r\\n else:\\r\\n if prev_data:\\r\\n if use_prev_data:\\r\\n return None, (prev_src_data, prev_adj_data)\\r\\n else:\\r\\n if prev_adj_data:\\r\\n prev_src_data.update(prev_adj_data)\\r\\n return prev_src_data, (None, None)\\r\\n else:\\r\\n return None\",\n \"def process_line(self, line):\\n for char in line:\\n if self.current_state == 1:\\n\\n if char == \\\"{\\\":\\n self.current_state = 2 # Comment\\n elif char == \\\":\\\":\\n self.set_type = \\\", Assign\\\"\\n self.set_value = char\\n self.current_state = 3 # Assign\\n elif char in self.letters:\\n self.set_type = \\\", Identifier\\\"\\n self.set_value = char\\n self.current_state = 4 # Identifier\\n elif char in self.digits:\\n self.set_type = \\\", Number\\\"\\n self.set_value = char\\n self.current_state = 5 # Number\\n elif char in self.special_symbols:\\n self.set_type = \\\", SpecialSymbol\\\"\\n self.set_value = char\\n self.tokens.append(self.set_value + self.set_type) # Done\\n self.current_state = 1\\n elif char != \\\" \\\" and char != \\\"\\\\n\\\":\\n self.current_state = -1\\n elif self.current_state == 2:\\n\\n if char == \\\"}\\\":\\n self.current_state = 1\\n self.set_value = \\\"\\\"\\n elif self.current_state == 3:\\n\\n if char == \\\"=\\\":\\n self.set_value += char\\n self.tokens.append(self.set_value + self.set_type) # Done\\n self.current_state = 1\\n else:\\n self.current_state = -1\\n elif self.current_state == 4:\\n\\n if char in self.letters:\\n self.set_value += char\\n else: # Done\\n self.current_state = 1\\n if self.set_value in self.reserverd_words:\\n self.set_type = \\\", Reserverd Word\\\"\\n self.tokens.append(self.set_value + self.set_type) # Done\\n elif self.current_state == 5:\\n\\n if char in self.digits:\\n self.set_value += char\\n else: # Done\\n self.tokens.append(self.set_value + self.set_type)\\n self.current_state = 1\\n # elif self.current_state == 6:\\n #\\n #\\n # self.tokens.append(self.set_value + self.set_type)\\n # self.current_state = 1\",\n \"def parseMonitorLog(log_file, attack_props):\\n if not os.path.exists(log_file):\\n return\\n report = open(log_file, 'r')\\n lines = report.readlines()\\n #print lines\\n report.close()\\n \\n readingStations = False\\n readingAps = False\\n for line in lines:\\n line = line.strip()\\n #print line\\n if not readingStations and not readingAps:\\n if line.startswith(\\\"BSSID\\\"):\\n readingAps = True\\n continue\\n elif line.startswith(\\\"Station\\\"):\\n readingStations = True\\n continue\\n elif readingAps:\\n if len(line) < 4:\\n readingAps =False\\n else:\\n fields = line.split(',')\\n #print fields\\n ap_mac = fields[0].strip()\\n if attack_props.hasAP(ap_mac):\\n ap = attack_props.getActiveAP(ap_mac)\\n else:\\n ap = AccessPoint(ap_mac, attack_props.log_path)\\n attack_props.addActiveAP(ap)\\n ap.update(fields)\\n elif readingStations and len(line) > 4:\\n fields = line.split(',')\\n station_mac = fields[0].strip()\\n ap_mac = fields[5].strip()\\n if attack_props.hasAP(ap_mac):\\n ap = attack_props.getAP(ap_mac) \\n if ap.stations.has_key(station_mac):\\n station = ap.stations[station_mac]\\n else:\\n station = Station(station_mac)\\n ap.stations[station_mac] = station\\n station.ap = station\\n station.update(fields)\",\n \"def parse(lines):\\n if len(lines) == 0:\\n return (None, lines)\\n title = lines[0]\\n if len(title) > 0 and \\\"*\\\" == title[0]:\\n level = 1\\n while title[level] == \\\"*\\\":\\n level = level + 1\\n if title[level] != \\\" \\\":\\n return (None, lines)\\n else:\\n heading = title[level+1:]\\n todo = heading[:4] == \\\"TODO\\\"\\n done = heading[:4] == \\\"DONE\\\"\\n if todo or done:\\n heading = heading[4:]\\n return (ORGSection(heading.strip(), level=level, TODO=todo, DONE=done), lines[1:])\\n else:\\n return (None, lines)\",\n \"def _scan_alignment(self,handle, consumer):\\n while 1:\\n line = handle.readline()\\n if not line:\\n break\\n if is_blank_line(line):\\n continue\\n else:\\n consumer.query_alignment(line)\\n read_and_call(handle, consumer.positive_alignment)\\n read_and_call(handle, consumer.hit_alignment)\",\n \"def _read_file_control_record(self, line):\\n self.file_control_record = {'Batch Count': int(line[1:7]),\\n 'Block Count': int(line[7:13]),\\n 'Addenda Count': int(line[13:21]),\\n 'Entry Hash': line[21:31],\\n 'Total Debit Amount': int(line[31:43]) / 100,\\n 'Total Credit Amount': int(line[43:55]) / 100,\\n 'Reserved Data': line[55:94].strip()}\",\n \"def test_parse_consumer_address_1_field(self):\\n fields = {'Consumer Address 1': {'offset': 81,\\n 'length': 30}}\\n p = top.Parser(fields=fields)\\n received = p.parse_line(self._line)\\n expected = {'Consumer Address 1': '51 Westbourne St.'}\\n msg = 'Consumer Address 1 field parse incorrect'\\n self.assertEqual(received, expected, msg)\",\n \"def test_with_one_member_only(self, entries, errors, __):\\n self.assertEqualEntries(\\\"\\\"\\\"\\n 2011-05-17 open Expenses:Restaurant:Martin\\n\\n 2011-05-17 * \\\"Something\\\"\\n Expenses:Restaurant:Martin 2.00 USD\\n Assets:Cash -2.00 USD\\n \\\"\\\"\\\", entries)\",\n \"def process_line(line: str) -> Instruction:\\n register, op, value, _, base, check, limit = line.split()\\n return Instruction(register, op, int(value), base, check, int(limit))\",\n \"def parse_ability_triggering(line: str):\\n return [0, 1]\",\n \"def _analyzeLine(self, line, date, data):\\n user = re.search(': (.*)', line).group().split()[1]\\n data[user].add(ConvertTime(date, line))\",\n \"def parseStmt(line):\\n print(\\\"Statement\\\")\\n index=0\\n if line[0] == 's':\\n print(\\\"Set\\\")\\n index += 4\\n rest = line[index:]\\n cmds = str.split(rest, ',')\\n parseSet(cmds)\\n elif line[0] == 'h':\\n exit()\\n elif line[0] == 'j':\\n index += 5\\n if line[index] == ' ':\\n print(\\\"Jumpt\\\")\\n index += 1\\n rest = line[index:]\\n cmds = str.split(rest, ',')\\n parseJumpt(cmds)\\n else:\\n print(\\\"Jump\\\")\\n rest = line[index:]\\n cmds = str.split(rest, ',')\\n parseJump(cmds)\\n else:\\n print(\\\"Invalid Operation\\\")\",\n \"def parse(line, half=1):\\n line = line.strip()\\n logger.debug(\\\"LINE '%s'\\\", line)\\n\\n global aipname, alonging, ats_chapter, coords_wrap, obj, feature\\n global features, finalcoord, lastn, laste, lastv, airsport_intable\\n global border, re_coord3, country\\n global sectors, name_cont, cold_resp\\n\\n if line==LINEBREAK:\\n # drop current feature, if we don't have vertl by now,\\n # then this is just an overview polygon\\n feature = {\\\"properties\\\":{}}\\n obj = []\\n alonging = False\\n coords_wrap = \\\"\\\"\\n lastv = None\\n return\\n\\n\\n if ad_aip and not \\\"ENNO\\\" in filename:\\n if not ats_chapter:\\n # skip to chapter 2.71\\n if \\\"ATS airspace\\\" in line or \\\"ATS AIRSPACE\\\" in line:\\n logger.debug(\\\"Found chapter 2.71\\\")\\n ats_chapter=True\\n return\\n else:\\n # then skip everything after\\n if \\\"AD 2.\\\" in line or \\\"ATS COMM\\\" in line:\\n #if \\\"ATS komm\\\" in line or \\\"Kallesignal\\\" in line:\\n logger.debug(\\\"End chapter 2.71\\\")\\n ats_chapter=False\\n\\n class_=re_class.search(line) or re_class2.search(line) or re_class_openair.search(line)\\n if class_:\\n logger.debug(\\\"Found class in line: %s\\\", line)\\n class_=class_.groupdict()\\n feature['properties']['class']=class_.get('class')\\n if tia_aip:\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n return\\n\\n # SPECIAL CASE temporary workaround KRAMFORS\\n if aipname and (\\\"KRAMFORS\\\" in aipname) and (\\\"within\\\" in line):\\n return\\n # SPECIAL CASE workaround SÄLEN/SAAB CTR sectors\\n if aipname and ((\\\"SÄLEN\\\" in aipname) or (\\\"SAAB\\\" in aipname)) and (\\\"Sector\\\" in line):\\n logger.debug(\\\"TEST: Breaking up SÄLEN/SAAB, aipname=.\\\"+aipname)\\n sectors.append((aipname, obj))\\n feature, obj = {\\\"properties\\\":{}}, []\\n if \\\"SÄLEN\\\" in aipname:\\n aipname = \\\"SÄLEN CTR \\\"+line\\n else:\\n aipname = \\\"SAAB CTR \\\"+line\\n # SPECIAL CASE check for Valldal AIP names\\n if valldal and 'Valldal' in line:\\n aipname=\\\" \\\".join(line.strip().split()[0:2])\\n logger.debug(\\\"Valldal aipname: '%s'\\\", aipname)\\n feature['properties']['class']='Luftsport'\\n feature['properties']['from (ft amsl)']=0\\n feature['properties']['from (m amsl)'] =0\\n\\n coords = re_coord.search(line)\\n coords2 = re_coord2.search(line)\\n coords3 = re_coord3.findall(line)\\n\\n if (coords or coords2 or coords3):\\n\\n logger.debug(\\\"Found %i coords in line: %s\\\", coords3 and len(coords3) or 1, line)\\n logger.debug(printj(coords3))\\n if line.strip()[-1] == \\\"N\\\":\\n coords_wrap += line.strip() + \\\" \\\"\\n logger.debug(\\\"Continuing line after N coordinate: %s\\\", coords_wrap)\\n return\\n elif coords_wrap:\\n nline = coords_wrap + line\\n logger.debug(\\\"Continued line: %s\\\", nline)\\n coords = re_coord.search(nline)\\n coords2 = re_coord2.search(nline)\\n coords3 = re_coord3.findall(nline)\\n logger.debug(\\\"Found %i coords in merged line: %s\\\", coords3 and len(coords3) or '1', nline)\\n line = nline\\n coords_wrap = \\\"\\\"\\n\\n if coords and not (\\\"Lyng\\\" in aipname or \\\"Halten\\\" in aipname):\\n coords = coords.groupdict()\\n n = coords.get('cn') or coords.get('n')\\n e = coords.get('ce') or coords.get('e')\\n #n = coords.get('n') or coords.get('cn')\\n #e = coords.get('e') or coords.get('ce')\\n rad = coords.get('rad')\\n if not rad:\\n rad_m = coords.get('rad_m')\\n if rad_m:\\n rad = m2nm(rad_m)\\n if not n or not e or not rad:\\n coords_wrap += line.strip() + \\\" \\\"\\n # FIXME: incomplete circle continuation is broken\\n logger.debug(\\\"Continuing line after incomplete circle: %s\\\", coords_wrap)\\n return\\n lastn, laste = n, e\\n logger.debug(\\\"Circle center is %s %s %s %s\\\", coords.get('n'), coords.get('e'), coords.get('cn'), coords.get('ce'))\\n logger.debug(\\\"COORDS is %s\\\", json.dumps(coords))\\n c_gen = gen_circle(n, e, rad)\\n logger.debug(\\\"LENS %s %s\\\", len(obj), len(c_gen))\\n obj = merge_poly(obj, c_gen)\\n logger.debug(\\\"LENS %s %s\\\", len(obj), len(c_gen))\\n\\n elif coords2:\\n coords = coords2.groupdict()\\n n = coords.get('n')\\n e = coords.get('e')\\n if n is None and e is None:\\n n,e = lastn, laste\\n secfrom = coords.get('secfrom')\\n secto = coords.get('secto')\\n radfrom = coords.get('radfrom')\\n radto = coords.get('rad')\\n c_gen = gen_sector(n, e, secfrom, secto, radfrom, radto)\\n\\n obj = merge_poly(obj, c_gen)\\n\\n else:\\n skip_next = 0\\n for blob in coords3:\\n ne,n,e,along,arc,rad,cn,ce = blob[:8]\\n circle = blob[8] if len(blob)==9 else None\\n logger.debug(\\\"Coords: %s\\\", (n,e,ne,along,arc,rad,cn,ce,circle))\\n if skip_next > 0 and n:\\n logger.debug(\\\"Skipped.\\\")\\n skip_next -= 1\\n continue\\n if arc:\\n arcdata = re_arc.search(line)\\n if not arcdata:\\n coords_wrap += line.strip() + \\\" \\\"\\n logger.debug(\\\"Continuing line after incomplete arc: %s\\\", coords_wrap)\\n return\\n arcdata = arcdata.groupdict()\\n logger.debug(\\\"Completed arc: %s\\\", arcdata)\\n n = arcdata['n']\\n e = arcdata['e']\\n rad = arcdata.get('rad1') or arcdata.get('rad2')\\n arc = gen_circle(n, e, rad, convert=False)\\n to_n = arcdata['n2']\\n to_e = arcdata['e2']\\n cw = arcdata['dir']\\n logger.debug(\\\"ARC IS \\\"+cw)\\n fill = fill_along(obj[-1],(to_n,to_e), arc, (cw=='clockwise'))\\n lastn, laste = None, None\\n\\n for apair in fill:\\n bn, be = ll2c(apair)\\n obj.insert(0,(bn,be))\\n skip_next = 1\\n elif circle:\\n coords_wrap += line.strip() + \\\" \\\"\\n # FIXME: incomplete circle continuation is broken\\n logger.debug(\\\"Continuing line after incomplete circle (3): %s\\\", coords_wrap)\\n return\\n\\n\\n if alonging:\\n if not n and not e:\\n n, e = lastn, laste\\n fill = fill_along(alonging, (n,e), border)\\n alonging = False\\n lastn, laste = None, None\\n #HACK matching point in the wrong direction - FIXME don't select closest but next point in correct direction\\n if \\\"Sälen TMA b\\\" in aipname or \\\"SÄLEN CTR Sector b\\\" in aipname:\\n fill=fill[1:]\\n for bpair in fill:\\n bn, be = ll2c(bpair)\\n obj.insert(0,(bn,be))\\n\\n if rad and cn and ce:\\n c_gen = gen_circle(cn, ce, rad)\\n logger.debug(\\\"Merging circle using cn, ce.\\\")\\n obj = merge_poly(obj, c_gen)\\n if n and e:\\n lastn, laste = n, e\\n obj.insert(0,(n,e))\\n if along:\\n if not n and not e:\\n n, e = lastn, laste\\n alonging = (n,e)\\n if '(' in ne:\\n finalcoord = True\\n logger.debug(\\\"Found final coord.\\\")\\n else:\\n finalcoord = False\\n if (airsport_aip or aip_sup or military_aip) and finalcoord:\\n if feature['properties'].get('from (ft amsl)') is not None:\\n logger.debug(\\\"Finalizing: finalcoord.\\\")\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n lastv = None\\n\\n if not valldal:\\n return\\n\\n # IDENTIFY temporary restrictions\\n period = re_period.search(line) or re_period2.search(line) or re_period3.search(line)\\n\\n if cold_resp and not feature.get('properties',{}).get('temporary'):\\n logger.debug(\\\"Adding temporary restriction to cold response airspace.\\\")\\n feature['properties']['temporary'] = True\\n feature['properties']['dashArray'] = \\\"5 5\\\"\\n feature['properties']['Date from'] = [\\\"14 MAR\\\"]\\n feature['properties']['Date until'] = [\\\"31 MAR\\\"]\\n feature['properties']['Time from (UTC)'] = \\\"0000\\\"\\n feature['properties']['Time to (UTC)'] = \\\"2359\\\"\\n\\n # IDENTIFY frequencies\\n freq = re_freq.search(line)\\n if freq:\\n freq = freq.groupdict()\\n logger.debug(\\\"Found FREQUENCY: %s\\\", freq['freq'])\\n feature['properties']['frequency'] = freq.get('freq')\\n\\n # IDENTIFY altitude limits\\n vertl = re_vertl_upper.search(line) or re_vertl_lower.search(line) or re_vertl.search(line) or re_vertl2.search(line) or (military_aip and re_vertl3.search(line))\\n\\n if vertl:\\n vertl = vertl.groupdict()\\n logger.debug(\\\"Found vertl in line: %s\\\", vertl)\\n fromamsl, toamsl = None, None\\n\\n v = vertl.get('ftamsl')\\n flfrom = vertl.get('flfrom')\\n flto = vertl.get('flto')\\n fl = vertl.get('fl')\\n rmk = vertl.get('rmk')\\n\\n if rmk is not None:\\n v = 14999 # HACK: rmk = \\\"Lower limit of controlled airspace -> does not affect us\\\"\\n if fl is not None:\\n v = int(fl) * 100\\n\\n if flto is not None:\\n toamsl = int(flto) * 100\\n if flfrom:\\n fromamsl = v or (int(flfrom) * 100)\\n fl = fl or flfrom\\n elif flfrom is not None:\\n fromamsl = int(flfrom) * 100\\n fl = fl or flfrom\\n elif v is not None:\\n if lastv is None:\\n toamsl = v\\n if fl is not None:\\n flto = fl\\n else:\\n fromamsl = v\\n else:\\n fromamsl = vertl.get('msl',vertl.get('gnd',vertl.get('from')))\\n if fromamsl == \\\"GND\\\": fromamsl = 0\\n if fromamsl == \\\"MSL\\\": fromamsl = 0\\n toamsl = vertl.get('unl',vertl.get('to'))\\n if toamsl == \\\"UNL\\\": toamsl = 999999\\n\\n if toamsl is not None:\\n lastv = toamsl\\n currentv = feature['properties'].get('to (ft amsl)')\\n if currentv is not None and currentv != toamsl:\\n logger.warning(\\\"attempt to overwrite vertl_to %s with %s.\\\" % (currentv, toamsl))\\n if int(currentv) > int(toamsl):\\n logger.warning(\\\"skipping.\\\")\\n return\\n logger.warning(\\\"ok.\\\")\\n if flto is not None:\\n feature['properties']['to (fl)']=flto\\n feature['properties']['to (ft amsl)']=toamsl\\n feature['properties']['to (m amsl)'] = ft2m(toamsl)\\n if valldal:\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n lastv = None\\n if fromamsl is not None:\\n currentv = feature['properties'].get('from (ft amsl)')\\n if currentv is not None and currentv != fromamsl:\\n logger.warning(\\\"attempt to overwrite vertl_from %s with %s.\\\" % (currentv, fromamsl))\\n if int(currentv) < int(fromamsl):\\n logger.warning(\\\"skipping.\\\")\\n return\\n logger.warning(\\\"ok.\\\")\\n if fl is not None:\\n feature['properties']['from (fl)']=fl\\n feature['properties']['from (ft amsl)']=fromamsl\\n feature['properties']['from (m amsl)'] = ft2m(fromamsl)\\n lastv = None\\n if (((cta_aip or airsport_aip or aip_sup or tia_aip or (aipname and (\\\"TIZ\\\" in aipname))) and (finalcoord or tia_aip_acc)) or country != 'EN'):\\n logger.debug(\\\"Finalizing poly: Vertl complete.\\\")\\n if aipname and ((\\\"SÄLEN\\\" in aipname) or (\\\"SAAB\\\" in aipname)) and len(sectors)>0:\\n for x in sectors[1:]: # skip the first sector, which is the union of the other sectors in Swedish docs\\n aipname_, obj_ = x\\n logger.debug(\\\"Restoring \\\"+aipname_+\\\" \\\"+str(len(sectors)))\\n feature_ = deepcopy(feature)\\n logger.debug(\\\"Finalizing SAAB/SÄLEN: \\\" + aipname_)\\n finalize(feature_, features, obj_, source, aipname_, cta_aip, restrict_aip, aip_sup, tia_aip)\\n sectors = []\\n logger.debug(\\\"Finalizing last poly as .\\\"+aipname)\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n\\n logger.debug(\\\"From %s to %s\\\", feature['properties'].get('from (ft amsl)'), feature['properties'].get('to (ft amsl)'))\\n return\\n\\n # IDENTIFY airspace naming\\n name = re_name.search(line) or re_name2.search(line) or re_name3.search(line) or re_name4.search(line) or \\\\\\n re_miscnames.search(line) or re_name5.search(line) or re_name_cr.search(line) or re_name6.search(line) or \\\\\\n re_name_openair.search(line)\\n\\n if name_cont and not 'Real time' in line:\\n aipname = aipname + \\\" \\\" + line\\n logger.debug(\\\"Continuing name as \\\"+aipname)\\n if line == '' or 'EN D' in aipname:\\n name_cont = False\\n\\n if name:\\n named=name.groupdict()\\n if en_enr_5_1 or \\\"Hareid\\\" in line:\\n logger.debug(\\\"RESTRICT/HAREID\\\")\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n lastv = None\\n\\n name=named.get('name')\\n if 'polaris' in name.lower() and 'norway' in name.lower():\\n pos = name.lower().index('norway')\\n name = name[:pos]\\n\\n if name[:6]==\\\"Sector\\\" and \\\"ACC\\\" in aipname:\\n return\\n\\n if named.get('name_cont'):\\n name += ' '+named.get('name_cont')\\n name_cont=True\\n\\n if (name == \\\"Sector a\\\") or (name == \\\"Sector b\\\") or (aipname and (\\\"Sector\\\" in aipname) and ((\\\"SÄLEN\\\" in aipname) or (\\\"SAAB\\\" in aipname))):\\n return\\n if \\\"ES R\\\" in name or \\\"ES D\\\" in name:\\n name_cont=True\\n if \\\"EN D\\\" in name and len(name)<8:\\n name_cont=True\\n\\n if restrict_aip or military_aip:\\n if feature['properties'].get('from (ft amsl)') is not None and (feature['properties'].get('to (ft amsl)') or \\\"Romerike\\\" in aipname or \\\"Oslo\\\" in aipname):\\n logger.debug(\\\"RESTRICT/MILITARY + name and vertl complete\\\")\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n lastv = None\\n else:\\n logger.debug(\\\"RESTRICT/MILITARY + name and vertl NOT complete\\\")\\n\\n aipname = name\\n logger.debug(\\\"Found name '%s' in line: %s\\\", aipname, line)\\n return\\n\\n # The airsport document doesn't have recognizable airspace names\\n # so we just assume every line that isn't otherwise parsed is the name of the next box.\\n if airsport_aip and line.strip():\\n logger.debug(\\\"Unhandled line in airsport_aip: %s\\\", line)\\n if wstrip(line)==\\\"1\\\":\\n logger.debug(\\\"Starting airsport_aip table\\\")\\n airsport_intable = True\\n elif wstrip(line)[0] != \\\"2\\\" and airsport_intable:\\n logger.debug(\\\"Considering as new aipname: '%s'\\\", line)\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\\n aipname = wstrip(line)\\n\\n if line.strip()==\\\"-+-\\\":\\n feature, obj = finalize(feature, features, obj, source, aipname, cta_aip, restrict_aip, aip_sup, tia_aip)\",\n \"def parse_pdb(self, line):\\n if line is not None:\\n self.original_text.append(line.rstrip(\\\"\\\\r\\\\n\\\"))\",\n \"def __init__(self, line):\\n # Throw an exception if we don't see the parenthesis that mark a cause\\n if not line[108] == '(':\\n raise ParsingException\\n if not line[159:160] == ')':\\n raise ParsingException\\n\\n # Parsing definitions\\n self.cause = line[109:159].strip()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6672727","0.62225854","0.613628","0.61219925","0.59706","0.5941891","0.5929608","0.5854193","0.5786448","0.577579","0.5775706","0.576628","0.5740041","0.5700446","0.56839246","0.56678885","0.56678885","0.56678885","0.56678885","0.56296605","0.5623283","0.5556197","0.5521216","0.5508207","0.55052507","0.5482033","0.54789126","0.54784805","0.54476964","0.54438895","0.5423575","0.5415431","0.54055995","0.53974354","0.5395907","0.5391387","0.5375973","0.53707683","0.53701514","0.5347909","0.53463566","0.5344352","0.53418845","0.5338326","0.5331187","0.5320537","0.5312019","0.5302219","0.5298666","0.52885693","0.52865094","0.52687204","0.5268354","0.5261052","0.5247586","0.52350354","0.52207726","0.52074987","0.5196285","0.5184371","0.5172503","0.51703775","0.5169336","0.5160248","0.51590264","0.5151956","0.51517713","0.51517713","0.5149224","0.51291883","0.5127932","0.5103961","0.5094392","0.50935835","0.50883913","0.508166","0.5066878","0.5061462","0.5058782","0.5058095","0.50568515","0.5040026","0.50392145","0.5024633","0.50222844","0.502071","0.5018721","0.5018695","0.50162584","0.50074667","0.50073177","0.5006063","0.5004824","0.5003891","0.4990645","0.49873403","0.49858734","0.49775523","0.49761242","0.4971014"],"string":"[\n \"0.6672727\",\n \"0.62225854\",\n \"0.613628\",\n \"0.61219925\",\n \"0.59706\",\n \"0.5941891\",\n \"0.5929608\",\n \"0.5854193\",\n \"0.5786448\",\n \"0.577579\",\n \"0.5775706\",\n \"0.576628\",\n \"0.5740041\",\n \"0.5700446\",\n \"0.56839246\",\n \"0.56678885\",\n \"0.56678885\",\n \"0.56678885\",\n \"0.56678885\",\n \"0.56296605\",\n \"0.5623283\",\n \"0.5556197\",\n \"0.5521216\",\n \"0.5508207\",\n \"0.55052507\",\n \"0.5482033\",\n \"0.54789126\",\n \"0.54784805\",\n \"0.54476964\",\n \"0.54438895\",\n \"0.5423575\",\n \"0.5415431\",\n \"0.54055995\",\n \"0.53974354\",\n \"0.5395907\",\n \"0.5391387\",\n \"0.5375973\",\n \"0.53707683\",\n \"0.53701514\",\n \"0.5347909\",\n \"0.53463566\",\n \"0.5344352\",\n \"0.53418845\",\n \"0.5338326\",\n \"0.5331187\",\n \"0.5320537\",\n \"0.5312019\",\n \"0.5302219\",\n \"0.5298666\",\n \"0.52885693\",\n \"0.52865094\",\n \"0.52687204\",\n \"0.5268354\",\n \"0.5261052\",\n \"0.5247586\",\n \"0.52350354\",\n \"0.52207726\",\n \"0.52074987\",\n \"0.5196285\",\n \"0.5184371\",\n \"0.5172503\",\n \"0.51703775\",\n \"0.5169336\",\n \"0.5160248\",\n \"0.51590264\",\n \"0.5151956\",\n \"0.51517713\",\n \"0.51517713\",\n \"0.5149224\",\n \"0.51291883\",\n \"0.5127932\",\n \"0.5103961\",\n \"0.5094392\",\n \"0.50935835\",\n \"0.50883913\",\n \"0.508166\",\n \"0.5066878\",\n \"0.5061462\",\n \"0.5058782\",\n \"0.5058095\",\n \"0.50568515\",\n \"0.5040026\",\n \"0.50392145\",\n \"0.5024633\",\n \"0.50222844\",\n \"0.502071\",\n \"0.5018721\",\n \"0.5018695\",\n \"0.50162584\",\n \"0.50074667\",\n \"0.50073177\",\n \"0.5006063\",\n \"0.5004824\",\n \"0.5003891\",\n \"0.4990645\",\n \"0.49873403\",\n \"0.49858734\",\n \"0.49775523\",\n \"0.49761242\",\n \"0.4971014\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5084293"},"document_rank":{"kind":"string","value":"75"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":104,"numItemsPerPage":100,"numTotalItems":95772,"offset":10400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDQzODk5MCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzQ0NDI1OTAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.Xv7eOHKZkYJ1PW2Xu4AQ9CSxY70cYGcNA_v_reCPSQ8t99Fp_5HgIP0-Qupb6fkUkDWXKm8ihuc-V11evhWPAw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Generate a simple plot of the test and training learning curve. | def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
train_sizes=np.linspace(.1, 1.0, 20),
verbose=1,
n_jobs=30,
):
fig = plt.figure()
plt.title(title)
if ylim is not None:
plt.ylim(*ylim)
plt.xlabel("Training examples")
plt.ylabel("Score")
train_sizes, train_scores, test_scores = learning_curve(
estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
plt.grid()
plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std, alpha=0.1,
color="r")
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std, alpha=0.1, color="g")
plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
label="Training score")
plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
label="Cross-validation score")
plt.legend(loc="best")
return fig | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_learning_curve(model, X_train, X_test, y_train, y_test):\n\n m, train_scores, valid_scores = learning_curve(estimator = model, \n X = X_train, y = y_train.ravel(), train_sizes = np.linspace(0.1,1.0, 80))\n\n train_cv_err = np.mean(train_scores, axis=... | [
"0.77526236",
"0.765993",
"0.7510692",
"0.7418097",
"0.74108005",
"0.7352996",
"0.7338834",
"0.71422535",
"0.70823896",
"0.70736265",
"0.7060562",
"0.704026",
"0.7026929",
"0.7022064",
"0.7012828",
"0.6985284",
"0.6938504",
"0.6930585",
"0.6926712",
"0.692088",
"0.6913427",
... | 0.6493104 | 68 |
Modified `get_state` thread implementation. | async def get_discussion(context, author:str, permlink:str, observer:str=''):
db = context['db']
author = valid_account(author)
permlink = valid_permlink(permlink)
observer = valid_account(observer, allow_empty=True)
sql = "SELECT * FROM bridge_get_discussion(:author,:permlink,:observer)"
rows = await db.query_all(sql, author=author, permlink=permlink, observer=observer)
if not rows or len(rows) == 0:
return {}
root_id = rows[0]['id']
all_posts = {}
root_post = _bridge_post_object(rows[0])
root_post['active_votes'] = await find_votes_impl(db, rows[0]['author'], rows[0]['permlink'], VotesPresentation.BridgeApi)
root_post = append_statistics_to_post(root_post, rows[0], False)
root_post['replies'] = []
all_posts[root_id] = root_post
parent_to_children_id_map = {}
for index in range(1, len(rows)):
parent_id = rows[index]['parent_id']
if parent_id not in parent_to_children_id_map:
parent_to_children_id_map[parent_id] = []
parent_to_children_id_map[parent_id].append(rows[index]['id'])
post = _bridge_post_object(rows[index])
post['active_votes'] = await find_votes_impl(db, rows[index]['author'], rows[index]['permlink'], VotesPresentation.BridgeApi)
post = append_statistics_to_post(post, rows[index], False)
post['replies'] = []
all_posts[post['post_id']] = post
for key in parent_to_children_id_map:
children = parent_to_children_id_map[key]
post = all_posts[key]
for child_id in children:
post['replies'].append(_ref(all_posts[child_id]))
#result has to be in form of dictionary of dictionaries {post_ref: post}
results = {}
for key in all_posts:
post_ref = _ref(all_posts[key])
results[post_ref] = all_posts[key]
return results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_state(self):",
"def _get_state(self):\n return self.__state",
"def _get_state(self):\n return self.__state",
"def _get_state(self):\n return self.__state",
"def _get_state(self):\n return self.__state",
"def _get_state(self):\n return self.__state",
"def _get_state(self):\n r... | [
"0.71893764",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806",
"0.71459806"... | 0.0 | -1 |
Downloads all files from the SugarSync account to the provided output folder | def download_files(self, output, replace=False):
try:
# Create output directory
# self._output_path = os.path.join(output,
# "sugardl_{}".format(datetime.datetime.now().strftime("%Y%m%d_%H%M%S")))
# os.makedirs(self._output_path)
# Just write to the provided output directory
self._output_path = output
#####
# Authenticate: getting a refresh token, then an access token
#####
print("Authenticating..")
self._get_refresh_token()
self._get_access_token()
#####
# User Info
#####
self._get_user_info()
#####
# Get all folder metadata prior to download
#####
self._get_sync_folders()
#####
# Download: Recursively download all syncfolder contents
#####
for folder in self._folder_metadata:
print("== SYNC FOLDER DOWNLOAD: {} ==".format(folder['displayName']))
self._download_folder_contents(folder['contents'], "{}/{}".format(self._output_path, folder['displayName']), start_idx=0, replace=replace)
print("")
except Exception as e:
print("Error in download_files: {}".format(traceback.print_exc()))
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download(urls, dest_folder):\n pass",
"def download_output_files(self):\n bucket_list = self.bucket.list(\"output/part\")\n for bucket_entry in bucket_list:\n key_string = str(bucket_entry.key)\n # check if file exists locally, if not: download it\n if not os.p... | [
"0.6863336",
"0.6838265",
"0.6813811",
"0.6791622",
"0.6458129",
"0.64210194",
"0.63175696",
"0.6252998",
"0.62363803",
"0.621832",
"0.6204603",
"0.6164557",
"0.6153396",
"0.61488926",
"0.6148461",
"0.6134311",
"0.6120213",
"0.60974497",
"0.6057297",
"0.5996962",
"0.5962937",... | 0.74477714 | 0 |
Retrieves Refresh Token, a prerequisite for the Access Token. Useful so we dont need the user/pass after this | def _get_refresh_token(self):
doc = minidom.Document()
root = doc.createElement('appAuthorization')
doc.appendChild(root)
user = doc.createElement('username')
user.appendChild(doc.createTextNode(self.username))
root.appendChild(user)
pw = doc.createElement('password')
pw.appendChild(doc.createTextNode(self.password))
root.appendChild(pw)
application = doc.createElement('application')
application.appendChild(doc.createTextNode(self.appId))
root.appendChild(application)
aki = doc.createElement('accessKeyId')
aki.appendChild(doc.createTextNode(self.publicAccessKey))
root.appendChild(aki)
pak = doc.createElement('privateAccessKey')
pak.appendChild(doc.createTextNode(self.privateAccessKey))
root.appendChild(pak)
data = doc.toprettyxml()
resp = requests.post(BASE_URL + "app-authorization", data=data, headers=self._default_headers, verify=False)
if resp.status_code >= 300:
raise Exception("Failed to authorize app: {}".format(resp))
# Save off the refresh token
self._refresh_token = resp.headers.get('Location', None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh_token(self):\n # basic function to get an access token\n api_response = requests.get(\n self.api_config.get_api_url() + \"authentication/g?username=\" + self.api_config.get_api_username() + \"&password=\" + self.api_config.get_api_password())\n\n if api_response.status_c... | [
"0.79821616",
"0.77993184",
"0.77876174",
"0.7653094",
"0.7641783",
"0.76409805",
"0.7515908",
"0.7497555",
"0.7450978",
"0.74201334",
"0.74056983",
"0.7358515",
"0.73581094",
"0.7352093",
"0.7338572",
"0.7290165",
"0.72726715",
"0.72268915",
"0.72166353",
"0.72111404",
"0.71... | 0.7480263 | 8 |
Requests Access Token using the Refresh Token. Access Token is required for all future requests | def _get_access_token(self):
self._access_token = None
if not self._refresh_token:
raise ValueError("Refresh Token not set")
doc = minidom.Document()
root = doc.createElement('tokenAuthRequest')
doc.appendChild(root)
aki = doc.createElement('accessKeyId')
aki.appendChild(doc.createTextNode(self.publicAccessKey))
root.appendChild(aki)
pak = doc.createElement('privateAccessKey')
pak.appendChild(doc.createTextNode(self.privateAccessKey))
root.appendChild(pak)
rt = doc.createElement('refreshToken')
rt.appendChild(doc.createTextNode(self._refresh_token))
root.appendChild(rt)
data = doc.toprettyxml()
resp = requests.post(BASE_URL + "authorization", data=data, headers=self._default_headers, verify=False)
if resp.status_code >= 300:
raise Exception("Failed to claim access token: {}".format(resp))
vals = etree_to_dict(ET.XML(resp.content.decode('utf-8')))
self._access_token = resp.headers.get('Location', None)
if not self._access_token:
raise ValueError("Unable to get access token")
self._user_id = os.path.basename(vals.get('authorization').get('user'))
# Always set the expiry 30 minutes from now so we dont have to deal with parsing timezones
# self._access_token_expiry = dateutil_parser.parse(vals.get('authorization').get('expiration'))
self._access_token_expiry = datetime.datetime.utcnow() + datetime.timedelta(minutes=30) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh_access_token(self):\n parameters = {'client_id': self.CLIENT_ID,\n 'auth_code': self.auth_code,\n 'client_secret': self.CLIENT_SECRET,\n 'grant_type': 'authorization_code'}\n url = self.ACCESS_TOKEN_URL % parameters\n data = self._get_refresh_... | [
"0.79307115",
"0.78929",
"0.77902746",
"0.77651143",
"0.7737486",
"0.7703352",
"0.7701342",
"0.76643175",
"0.76561",
"0.7591492",
"0.75551724",
"0.75300753",
"0.75291276",
"0.7458949",
"0.7428596",
"0.74130595",
"0.7403479",
"0.73890567",
"0.73884934",
"0.73849046",
"0.736639... | 0.7272183 | 23 |
Retrieves user information to include sync folders | def _get_user_info(self):
if not self._refresh_token:
raise ValueError("Refresh Token not set")
# Add access token to the headers
add_headers = dict(self._default_headers)
add_headers['Authorization'] = self._access_token
resp = requests.get(BASE_URL + "user/{}".format(self._user_id), headers=add_headers, verify=False)
if resp.status_code >= 300:
raise Exception("Failed to retrieve user info: {}".format(resp))
vals = etree_to_dict(ET.XML(resp.content.decode('utf-8')))
# Print generic user info
print("")
print("== USER INFO ==")
print("Username: {}".format(vals.get('user').get('username')))
print("Nickname: {}".format(vals.get('user').get('nickname')))
print("Usage: {} MB / {} MB".format(int(int(vals.get('user').get('quota').get('usage')) / (1024*1024)),
int(int(vals.get('user').get('quota').get('limit')) / (1024*1024))))
print("")
# Grab folder ids we care about
self._user_sync_folders_url = vals.get('user').get('syncfolders') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_info(self) -> str:\n return self._searcher.get_user_info()",
"def get_users_info(): \n \n data = user_obj.get_users_info()\n return data",
"def user_info(self):\n response = self.query('user_info')\n return response",
"def getUserInfo(self, user):\n return pwd.ge... | [
"0.69573396",
"0.68997866",
"0.6759884",
"0.6710544",
"0.6675518",
"0.661304",
"0.6520475",
"0.6491115",
"0.6431651",
"0.63984233",
"0.6313943",
"0.63038987",
"0.6303114",
"0.63017505",
"0.6268096",
"0.62518907",
"0.62275803",
"0.61987466",
"0.61969614",
"0.6171311",
"0.61620... | 0.7239684 | 0 |
Retrieves metadata on all sync folders | def _get_sync_folders(self):
if not self._user_sync_folders_url:
raise ValueError("User sync folders URL not retrieved")
if not self._refresh_token:
raise ValueError("Refresh Token not set")
# Add access token to the headers
add_headers = dict(self._default_headers)
add_headers['Authorization'] = self._access_token
resp = requests.get(self._user_sync_folders_url, headers=add_headers, verify=False)
if resp.status_code >= 300:
raise Exception("Failed to claim access token: {}".format(resp))
vals = etree_to_dict(ET.XML(resp.content.decode('utf-8')))
# Print and store relevant sync folder information
print("== SYNC FOLDERS ==")
for folder in vals.get('collectionContents').get('collection'):
print("Folder: {}".format(folder.get('displayName')))
self._folder_metadata.append(folder)
print("") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_root_metadata(self):\n r = self._do_request(\n 'get',\n http_server_utils.join_url_components(\n [self._api_drive_endpoint_prefix, 'root']),\n params={'select': 'id,name,fileSystemInfo'})\n return r.json()",
"def syncfolder():",
"def getFol... | [
"0.648162",
"0.60808307",
"0.59680235",
"0.58834165",
"0.58828735",
"0.58178836",
"0.58129156",
"0.57245374",
"0.5677313",
"0.5626248",
"0.5588174",
"0.5587416",
"0.55705136",
"0.55277115",
"0.55202806",
"0.5497931",
"0.54850954",
"0.54689896",
"0.5424635",
"0.5419897",
"0.54... | 0.7083151 | 0 |
Recursively downloads all file content within a folder | def _download_folder_contents(self, folder_uri, relpath, start_idx=0, replace=False):
if not self._access_token:
raise ValueError("Access Token not set")
# Create the folder in the output dir if it doesnt exist
if not os.path.exists(relpath):
print("Creating folder: {}".format(relpath))
os.makedirs(relpath)
# Add access token to the headers
add_headers = dict(self._default_headers)
add_headers['Authorization'] = self._access_token
resp = requests.get(folder_uri, headers=add_headers, params={'start': start_idx}, verify=False)
if resp.status_code >= 300:
raise Exception("Failed to retrieve folder info: {}".format(resp))
vals = etree_to_dict(ET.XML(resp.content.decode('utf-8')))
# Download all top level files
ret_files = vals.get('collectionContents', {}).get('file', list())
if isinstance(ret_files, dict):
# Case when there is only a single file
files = []
files.append(ret_files)
else:
files = ret_files
for f in files:
try:
filepath = "{}/{}".format(relpath, f['displayName'])
if not replace and os.path.exists(filepath):
print("File already exists, skipping {}".format(filepath))
continue
print("Downloading: {}".format(filepath))
self._download_file_contents(f, filepath)
except:
print("Error downloading {}: {}".format(f, traceback.print_exc()))
# If there are more than 500 items, recursively call on this same folder but start at start_idx+500
item_count = len(vals.get('collectionContents', {}).get('collection', list())) + len(
vals.get('collectionContents', {}).get('file', list()))
if item_count >= 500:
self._download_folder_contents(folder_uri, relpath, start_idx=start_idx+500, replace=replace)
# Download all folders
subfolders_ret = vals.get('collectionContents', {}).get('collection', list())
if isinstance(subfolders_ret, dict):
# Case when there is only one subfolder
subfolders = []
subfolders.append(subfolders_ret)
else:
subfolders = subfolders_ret
for subfolder in subfolders:
try:
self._download_folder_contents(subfolder['contents'], relpath + "/" + subfolder['displayName'], replace=replace)
except:
print("Error downloading subfolder: {}".format(traceback.print_exc())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_all_files(self, root_url, version):\n file_list = self._http_client.get(root_url + '?ref=refs/tags/' + version)\n for file in file_list.json():\n if file['type'] == 'file':\n download_url = file['download_url']\n download_path = self.get_module_an... | [
"0.72201246",
"0.7049657",
"0.6965782",
"0.6872731",
"0.6746397",
"0.6685815",
"0.6519834",
"0.64734966",
"0.6453111",
"0.64178264",
"0.6356167",
"0.63462275",
"0.6333368",
"0.62987703",
"0.6254699",
"0.62543726",
"0.62343174",
"0.6186609",
"0.61842734",
"0.61728805",
"0.6165... | 0.6973404 | 2 |
If we're unable to establish a connection to the Elasticsearch server, CannotLoadConfiguration (which the circulation manager can understand) is raised instead of an Elasticsearchspecific exception. | def test_elasticsearch_error_in_constructor_becomes_cannotloadconfiguration(self):
# Unlike other tests in this module, this one runs even if no
# ElasticSearch server is running, since it's testing what
# happens if there's a problem communicating with that server.
class Mock(ExternalSearchIndex):
def set_works_index_and_alias(self, _db):
raise ElasticsearchException("very bad")
with pytest.raises(CannotLoadConfiguration) as excinfo:
Mock(self._db)
assert "Exception communicating with Elasticsearch server: " in str(excinfo.value)
assert "very bad" in str(excinfo.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def check_connection(self, hass: HomeAssistantType):\n from elasticsearch import (\n AuthenticationException,\n AuthorizationException,\n ConnectionError,\n ElasticsearchException,\n SSLError,\n )\n\n client = None\n is_suppor... | [
"0.6263491",
"0.62350416",
"0.6013181",
"0.5960673",
"0.59529793",
"0.5821141",
"0.5678517",
"0.5538262",
"0.5535928",
"0.5493257",
"0.54761046",
"0.5462948",
"0.53717524",
"0.5338984",
"0.5287106",
"0.52525455",
"0.5251487",
"0.5240034",
"0.5202334",
"0.5163459",
"0.51596135... | 0.699837 | 0 |
The name of the search index is the prefix (defined in ExternalSearchTest.setup) plus a version number associated with this version of the core code. | def test_works_index_name(self):
assert "test_index-v4" == self.search.works_index_name(self._db) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def db_index_name(self):\r\n return 'index_{}'.format(self.db_field_name)",
"def index_prefix(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"index_prefix\")",
"def index_prefix(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"index_prefix\")",
"def build_index():\n pas... | [
"0.58981884",
"0.5859757",
"0.5859757",
"0.5726856",
"0.56515306",
"0.5513793",
"0.5505178",
"0.54348093",
"0.53886336",
"0.5384905",
"0.5370095",
"0.5368973",
"0.53638005",
"0.5342818",
"0.5323321",
"0.53231466",
"0.53118646",
"0.53068525",
"0.53068525",
"0.52520263",
"0.521... | 0.6855528 | 0 |
When all the filters are applied to `start`, the result is `finish`. | def filters_to(start, finish):
for find, replace in filters:
start = find.sub(replace, start)
assert start == finish | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def after_all(self) -> None:\r\n for a_filter in self.filters[::-1]:\r\n a_filter.after_all()",
"def analyze(self, start, end):\n return",
"def FilterDone(self, last_bits):\n return last_bits",
"def __call__(self, start):\r\n return self._iterate(start)",
"def catch_up(se... | [
"0.60245126",
"0.58253586",
"0.5557765",
"0.546555",
"0.5420422",
"0.5409369",
"0.53233445",
"0.5279904",
"0.5211791",
"0.51451194",
"0.51429945",
"0.5127559",
"0.50891775",
"0.50891775",
"0.50891775",
"0.50891775",
"0.5051931",
"0.5035896",
"0.49861154",
"0.4938378",
"0.4924... | 0.74531156 | 0 |
Iterate over a WorkList until it ends, and return all of the pages. | def pages(worklist):
pagination = SortKeyPagination(size=2)
facets = Facets(
self._default_library, None, None, order=Facets.ORDER_TITLE
)
pages = []
while pagination:
pages.append(worklist.works(
self._db, facets, pagination, self.search
))
pagination = pagination.next_page
# The last page should always be empty -- that's how we
# knew we'd reached the end.
assert [] == pages[-1]
# Return all the other pages for verification.
return pages[:-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pages(self, url_list):\n page_helper = self.get_page\n pool = ThreadPool(self.max_threads)\n results = pool.map(page_helper, url_list)\n pool.close()\n pool.join()\n return results",
"def pages(self):\n # The page list comes in three sections. Given radiu... | [
"0.6512649",
"0.6426794",
"0.6418355",
"0.63479626",
"0.62923247",
"0.6280523",
"0.6178995",
"0.6132314",
"0.61132336",
"0.6108371",
"0.6048124",
"0.6044336",
"0.60390985",
"0.6030068",
"0.5951634",
"0.59403145",
"0.59379506",
"0.58951074",
"0.5890618",
"0.5873708",
"0.587297... | 0.7885278 | 0 |
Verify that when the books created during test setup are ordered by the given `sort_field`, they show up in the given `order`. Also verify that when the search is ordered descending, the same books show up in the opposite order. This proves that `sort_field` isn't being ignored creating a test that only succeeds by chance. | def assert_order(sort_field, order, **filter_kwargs):
expect = self._expect_results
facets = Facets(
self._default_library, Facets.COLLECTION_FULL,
Facets.AVAILABLE_ALL, order=sort_field, order_ascending=True
)
expect(order, None, Filter(facets=facets, **filter_kwargs))
facets.order_ascending = False
expect(list(reversed(order)), None, Filter(facets=facets, **filter_kwargs))
# Get each item in the list as a separate page. This
# proves that pagination works for this sort order for
# both Pagination and SortKeyPagination.
facets.order_ascending = True
for pagination_class in (
Pagination, SortKeyPagination
):
pagination = pagination_class(size=1)
to_process = list(order) + [[]]
while to_process:
filter = Filter(facets=facets, **filter_kwargs)
expect_result = to_process.pop(0)
expect(expect_result, None, filter, pagination=pagination)
pagination = pagination.next_page
# We are now off the edge of the list -- we got an
# empty page of results and there is no next page.
assert None == pagination
# Now try the same tests but in reverse order.
facets.order_ascending = False
for pagination_class in (
Pagination, SortKeyPagination
):
pagination = pagination_class(size=1)
to_process = list(reversed(order)) + [[]]
results = []
pagination = SortKeyPagination(size=1)
while to_process:
filter = Filter(facets=facets, **filter_kwargs)
expect_result = to_process.pop(0)
expect(expect_result, None, filter, pagination=pagination)
pagination = pagination.next_page
# We are now off the edge of the list -- we got an
# empty page of results and there is no next page.
assert None == pagination | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_sort(self):\n sort_field = MoveSearchForm.sort\n for value, label in sort_field.kwargs['choices']:\n response = self.do_search(id=u'1', sort=value)\n self.assert_(\n response.tmpl_context.results,\n \"\"\"Sort by {0} doesn't crash\"\"\".for... | [
"0.69119376",
"0.62695354",
"0.59014153",
"0.5880185",
"0.5848647",
"0.5769646",
"0.5743111",
"0.5740987",
"0.56924033",
"0.56718487",
"0.56502676",
"0.5648147",
"0.5643026",
"0.56352484",
"0.56259537",
"0.55134785",
"0.55029243",
"0.5502388",
"0.5476563",
"0.54709595",
"0.54... | 0.7052679 | 0 |
Simulate the application of a nested filter. | def filter(self, **kwargs):
new_filters = self.nested_filter_calls + [kwargs]
return MockSearch(
self, self._query, new_filters, self.order,
self._script_fields
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mock_chain(self, filters, new_filter):\n if filters is None:\n # There are no active filters.\n filters = []\n if isinstance(filters, elasticsearch_dsl_query):\n # An initial filter was passed in. Convert it to a list.\n filters = [filters]\n fi... | [
"0.6055056",
"0.5969588",
"0.5811234",
"0.5677359",
"0.5674291",
"0.56733555",
"0.56623197",
"0.56011295",
"0.5598666",
"0.5580886",
"0.55451864",
"0.55215704",
"0.55069554",
"0.54262555",
"0.54063",
"0.5369425",
"0.5340776",
"0.53186697",
"0.5311007",
"0.5300697",
"0.5297867... | 0.52616525 | 25 |
Simulate the creation of an ElasticsearchDSL `Search` object from an ElasticsearchDSL `Query` object. | def query(self, query):
return MockSearch(
self, query, self.nested_filter_calls, self.order,
self._script_fields
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _search(self, query):\n return self._request(query)",
"def search_query(\n self,\n index, # type: str\n query, # type: SearchQuery\n *options, # type: SearchOptions\n **kwargs\n ) -> SearchResult:\n\n query = SearchQueryBuilder.create_search_query_object... | [
"0.7029542",
"0.6688671",
"0.6600027",
"0.6517039",
"0.6485709",
"0.64265573",
"0.64017105",
"0.6352035",
"0.6290121",
"0.61653656",
"0.614457",
"0.61306244",
"0.60751146",
"0.6055303",
"0.60288244",
"0.6017776",
"0.6013076",
"0.59807044",
"0.59282154",
"0.591098",
"0.5907803... | 0.75526977 | 0 |
Simulate the application of a sort order. | def sort(self, *order_fields):
return MockSearch(
self, self._query, self.nested_filter_calls, order_fields,
self._script_fields
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_sorting(sort=selection_sort, num_items=20, max_value=50):\n # TODO: Repeat until all items are in sorted order\n # TODO: Take first unsorted item\n # TODO: Insert it in sorted order in front of items",
"def test_benchmark_sorted(benchmark, benchmark_items_fixture):\n do_benchmark(benchmark_i... | [
"0.6867885",
"0.64630604",
"0.6454256",
"0.63690174",
"0.632256",
"0.6318335",
"0.62491775",
"0.62284666",
"0.62284666",
"0.6171056",
"0.616647",
"0.61227566",
"0.61051816",
"0.6099615",
"0.6089664",
"0.60870415",
"0.6045168",
"0.6039011",
"0.6034501",
"0.5993905",
"0.5981229... | 0.0 | -1 |
Simulate the addition of script fields. | def script_fields(self, **kwargs):
return MockSearch(
self, self._query, self.nested_filter_calls, self.order,
kwargs
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, script, inputs, outputs):",
"def _add_fields(self, fields):\n for field in fields:\n self.add(field)",
"def script(self):",
"def add_inputs(self, inputs):\n self.inputs += inputs",
"def add_new_item_field(*fields, **keywords):\n\n for field in fields:\n prin... | [
"0.692667",
"0.56195414",
"0.5602282",
"0.5565711",
"0.554856",
"0.5542783",
"0.5513092",
"0.54535246",
"0.5447269",
"0.5425964",
"0.54044926",
"0.5340656",
"0.5258546",
"0.52512413",
"0.51859945",
"0.51825964",
"0.51686376",
"0.51534796",
"0.5128652",
"0.5083519",
"0.506479"... | 0.0 | -1 |
Verify that both universal methods were called and that the return values were incorporated into the query being built by `search`. This method modifies the `search` object in place so that the rest of a test can ignore all the universal stuff. | def validate_universal_calls(cls):
assert True == cls.universal_called
assert True == cls.nested_called
# Reset for next time.
cls.base_called = None
cls.nested_called = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_perform_search_old(self):\n es_instance_info = {'cluster_name': 'elasticsearch', 'cluster_uuid': 'kPjOcrpMQaWWm4neFdzLrw', 'name': 'f492663fbfa2', 'tagline': 'You Know, for Search', 'version': {'build_date': '2019-04-05T22:55:32.697037Z', 'build_flavor': 'oss', 'build_hash': 'b7e28a7', 'build_snaps... | [
"0.6531283",
"0.64964837",
"0.63405144",
"0.6176755",
"0.6176755",
"0.6176755",
"0.608852",
"0.5953733",
"0.59461486",
"0.5940335",
"0.57574964",
"0.571873",
"0.5685846",
"0.5673872",
"0.5671505",
"0.5655952",
"0.565061",
"0.56470966",
"0.56348187",
"0.5606218",
"0.55955267",... | 0.0 | -1 |
Build a Query object from a set of facets, then call build() on it. | def from_facets(*args, **kwargs):
facets = Facets(self._default_library, *args, **kwargs)
filter = Filter(facets=facets)
qu = MockQuery("query string", filter=filter)
built = qu.build(search)
# Return the rest to be verified in a test-specific way.
return built | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_filters(self, queryset, applicable_filters=None, applicable_exclusions=None):\n for field, options in applicable_filters[\"field_facets\"].items():\n queryset = queryset.facet(field, **options)\n\n for field, options in applicable_filters[\"date_facets\"].items():\n qu... | [
"0.6496745",
"0.6315449",
"0.6258068",
"0.60086054",
"0.5911915",
"0.57755864",
"0.573584",
"0.5670942",
"0.56401163",
"0.5602675",
"0.5568983",
"0.5543967",
"0.553353",
"0.54699177",
"0.5458636",
"0.54096997",
"0.5407078",
"0.5323815",
"0.53104126",
"0.52941847",
"0.52759683... | 0.7220995 | 0 |
Helper method for the most common case, where a Filter.build() returns a main filter and no nested filters. | def assert_filter_builds_to(self, expect, filter, _chain_filters=None):
final_query = {'bool': {'must_not': [RESEARCH.to_dict()]}}
if expect:
final_query['bool']['must'] = expect
main, nested = filter.build(_chain_filters)
assert final_query == main.to_dict()
return main, nested | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_filter_chain(self):\n result = None\n for klass in self.filters:\n tmp = klass(self, self.args, result)\n logging.info(\"%s %s\", klass, tmp.active)\n if tmp.active:\n result = tmp\n return result or (lambda x: x)",
"def _build(self,... | [
"0.71433246",
"0.6450868",
"0.6068573",
"0.59432274",
"0.5906227",
"0.5796689",
"0.5791745",
"0.5788301",
"0.5783497",
"0.5759372",
"0.573049",
"0.5677852",
"0.5637443",
"0.5626888",
"0.5609167",
"0.55952406",
"0.5576881",
"0.5536685",
"0.5529956",
"0.5527361",
"0.55241287",
... | 0.59127074 | 4 |
Validate the 'easy' part of the sort order the tiebreaker fields. Return the 'difficult' part. | def validate_sort_order(filter, main_field):
# The tiebreaker fields are always in the same order, but
# if the main sort field is one of the tiebreaker fields,
# it's removed from the list -- there's no need to sort on
# that field a second time.
default_sort_fields = [
{x: "asc"} for x in ['sort_author', 'sort_title', 'work_id']
if x != main_field
]
assert default_sort_fields == filter.sort_order[1:]
return filter.sort_order[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_admin_sort_by(sort_on):\n try:\n sort_attributes = ['title', 'md_pub_date', 'summary']\n if sort_on in sort_attributes:\n return sort_on\n else:\n return 'title'\n except Exception as e:\n print \"Exception: \" + str(e)",
"def sorting_by_criter... | [
"0.5422345",
"0.51779574",
"0.51326853",
"0.51216465",
"0.5098696",
"0.49896",
"0.498799",
"0.49557397",
"0.49503902",
"0.49242207",
"0.48612294",
"0.48536846",
"0.48222044",
"0.48191088",
"0.48098657",
"0.4788777",
"0.47594061",
"0.47372675",
"0.4728122",
"0.47202504",
"0.47... | 0.6764114 | 0 |
Verify that `filter` is a boolean filter that matches one of a number of possibilities. Return those possibilities. | def dichotomy(filter):
assert "bool" == filter.name
assert 1 == filter.minimum_should_match
return filter.should | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_filter_mixed_function(self):\n for none_type in (False, True):\n for all_type in (False, True):\n for any_type in (False, True, None):\n result = none_type is False and all_type is True \\\n and (any_type is None or any_type is Tru... | [
"0.6741921",
"0.6474875",
"0.6376854",
"0.6179683",
"0.6159572",
"0.59450597",
"0.5884499",
"0.5780944",
"0.5735032",
"0.5734875",
"0.5713773",
"0.5666095",
"0.56029093",
"0.5585088",
"0.55647486",
"0.55589753",
"0.55378103",
"0.55280507",
"0.55214506",
"0.5489386",
"0.548355... | 0.67647254 | 0 |
Verify that a filter only matches when there is no value for the given field. | def assert_matches_nonexistent_field(f, field):
assert (
f.to_dict() ==
{'bool': {'must_not': [{'exists': {'field': field}}]}}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_filterval(filterval):\n if filterval != 'description' and filterval != 'fulldescription' and filterval != 'completed':\n return False\n else:\n return True",
"def test_filter_function_none(self):\n self.es.register_filter(lambda x: False, ftype='none')\n ... | [
"0.6997897",
"0.65928715",
"0.65643317",
"0.6421701",
"0.64098537",
"0.6297924",
"0.6291485",
"0.62772375",
"0.6188193",
"0.6145177",
"0.6119406",
"0.6065322",
"0.60579246",
"0.6054443",
"0.60046804",
"0.5999436",
"0.59982795",
"0.5972854",
"0.59515387",
"0.59507996",
"0.5950... | 0.7020142 | 0 |
A mock of _chain_filters so we don't have to check test results against supercomplicated Elasticsearch filter objects. Instead, we'll get a list of smaller filter objects. | def _mock_chain(self, filters, new_filter):
if filters is None:
# There are no active filters.
filters = []
if isinstance(filters, elasticsearch_dsl_query):
# An initial filter was passed in. Convert it to a list.
filters = [filters]
filters.append(new_filter)
return filters | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_apply_filter(mocker):\n list_of_filter_dict_keys = [\n 'EqualTo',\n 'Contains',\n 'ContainsAll',\n 'ContainsAny',\n 'ContainsIgnoreCase',\n 'DoesNotContain',\n 'GreaterThan',\n 'GreaterThanOrEqualTo',\n 'DoesNotContainIgnoreCase',\n ... | [
"0.65804183",
"0.6574269",
"0.6492736",
"0.63977313",
"0.6358299",
"0.631415",
"0.6254892",
"0.6224293",
"0.620702",
"0.6090167",
"0.6076573",
"0.6039105",
"0.59843934",
"0.5979323",
"0.59743553",
"0.5895422",
"0.58411616",
"0.5840082",
"0.57979",
"0.5793634",
"0.5764596",
... | 0.8190246 | 0 |
Clears the model directory and only maintains the latest `checkpoints` number of checkpoints. | def clear_model_dir(self, checkpoints, logger):
files = os.listdir(self.model_dir)
last_modification = [(os.path.getmtime(os.path.join(self.model_dir, f)), f) for f in files]
# Sort the list by last modified.
last_modification.sort(key=itemgetter(0))
# Delete everything but the last 10 files.
ckpnt_no = 0
for time, f in last_modification[:-checkpoints]:
ckpnt_no += 1
os.remove(os.path.join(self.model_dir, f))
msg = "Deleted %d checkpoints" % (ckpnt_no)
logger.debug(msg)
print(msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear_checkpoints(self):\n if tf.gfile.Exists(str(self.info.checkpoint_path)):\n tf.gfile.DeleteRecursively(str(self.info.checkpoint_path))",
"def clear_model_checkpoints(self):\n if self.file_prefix is None:\n return\n\n with os.scandir() as path_list:\n ... | [
"0.7887548",
"0.78405684",
"0.70502526",
"0.7037212",
"0.69053566",
"0.6885986",
"0.64904153",
"0.6437186",
"0.64033055",
"0.6368597",
"0.6348156",
"0.63442576",
"0.6341169",
"0.6286433",
"0.6260607",
"0.62325686",
"0.6117156",
"0.6105783",
"0.60879576",
"0.6058965",
"0.60501... | 0.8535333 | 0 |
Create a new instance of the factory. | def __init__(self):
super().__init__()
self.register_as_type(DefaultLoggerFactory.NullLoggerDescriptor, NullLogger)
self.register_as_type(DefaultLoggerFactory.ConsoleLoggerDescriptor, ConsoleLogger)
self.register_as_type(DefaultLoggerFactory.CompositeLoggerDescriptor, CompositeLogger) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createInstance (self, factory, **kw):\n kw.update(self.__kw)\n return factory(*self.__args, **kw)",
"def create(cls):\n pass\n return cls()",
"def create_factory(cls, *args):\n raise NotImplementedError",
"def create(cls, _):\n return cls",
"def factory(self):\... | [
"0.8068922",
"0.7944279",
"0.7823079",
"0.76350766",
"0.7491401",
"0.7373942",
"0.72846454",
"0.72057045",
"0.7116696",
"0.7116696",
"0.70897645",
"0.70344335",
"0.7027849",
"0.7027849",
"0.70022064",
"0.70022064",
"0.6944803",
"0.6784452",
"0.6782056",
"0.674577",
"0.6729694... | 0.0 | -1 |
Rebuilds the surfaces based on the original positions and alpha value. This can be used to reset the states of buttons after returning to a Menu a second time. | def reset(self):
self.x = self.x_original
self.alpha = self.alpha_original
# Button "background" - active
self.active_background_surface.set_alpha(self.alpha)
# Button "background" - inactive
self.inactive_background_surface.set_alpha(self.alpha)
# active
self.active_text_surface = self.active_font.render(self.text, True, self.color_text)
self.active_textRect = self.active_text_surface.get_rect()
# inactive
self.inactive_text_surface = self.inactive_font.render(self.text, True, self.color_text)
self.inactive_textRect = self.inactive_text_surface.get_rect()
if self.text_alignment == 'CENTER':
self.active_textRect.center = ((self.x + (self.rect.w / 2)), (self.y + (self.rect.h / 2)))
self.inactive_textRect.center = ((self.x + (self.rect.w / 2)), (self.y + (self.rect.h / 2)))
elif self.text_alignment == 'RIGHT':
self.active_textRect.centery = self.y + (self.rect.h / 2)
self.active_textRect.right = self.x + self.w - 15 # padding of 15
self.inactive_textRect.centery = self.y + (self.rect.h / 2)
self.inactive_textRect.right = self.x + self.w - 15 # padding of 15
else: # LEFT (or invalid)
self.active_textRect.centery = self.y + (self.rect.h / 2)
self.active_textRect.left = self.x + 15 # padding of 15
self.inactive_textRect.centery = self.y + (self.rect.h / 2)
self.inactive_textRect.left = self.x + 15 # padding of 15 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reindex_graphics(self):\n for obj in self.context.static_objects:\n self.canvas.children.remove(obj.widget.canvas)\n # fill _objects_z_index\n _objects_z_index = {}\n for obj in self.context.static_objects:\n y = obj.widget.pos[1]\n if not y in _obje... | [
"0.6098649",
"0.5991369",
"0.5905092",
"0.5815281",
"0.5792299",
"0.57288677",
"0.5722896",
"0.5714045",
"0.5713487",
"0.5713487",
"0.57038414",
"0.5668134",
"0.56377494",
"0.5615933",
"0.5568823",
"0.55665016",
"0.5559408",
"0.55072635",
"0.54790586",
"0.54756534",
"0.547195... | 0.6623888 | 0 |
Checks which rendering is needed and renders the button onto the screen surface. Checks whether the button was clicked and if so, returns the text of the button. | def render(self, mouse, events, fading=False):
clicked = True if pygame.MOUSEBUTTONDOWN in [e.type for e in events] else False
if fading:
self.render_fading()
elif self.mouse_on_button(mouse):
self.render_active()
if clicked: # mouse on button + click
return self.text
else:
self.render_inactive()
return None # readability - return explicitly None if button was not clicked | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_button(self):\n # Draw the button's outline\n pg.draw.rect(self.screen, self.text_color, pg.Rect(self.rect.left - 1, self.rect.top - 1, self.rect.width + 2, self.rect.height + 2))\n\n # Draw the button\n pg.draw.rect(self.screen, self.button_color, self.rect)\n\n # Blit ... | [
"0.72366494",
"0.7209145",
"0.6849019",
"0.6800909",
"0.6409076",
"0.6328239",
"0.6212745",
"0.6210769",
"0.61994016",
"0.61717445",
"0.61338997",
"0.61237854",
"0.6081018",
"0.6080486",
"0.6069053",
"0.60556203",
"0.6053025",
"0.6003425",
"0.600016",
"0.5922334",
"0.5922334"... | 0.63266563 | 6 |
Rendering the inactive button onto the screen surface. | def render_inactive(self):
# Rendering button "background"
self.screen.blit(self.inactive_background_surface, (self.x, self.y))
# Rendering button text
self.screen.blit(self.active_text_surface, self.active_textRect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_active(self):\n # Rendering button \"background\"\n if self.resize_right:\n self.active_background_surface = pygame.Surface((self.w * 1.05, self.h))\n else:\n self.active_background_surface = pygame.Surface((self.w, self.h))\n self.active_background_surf... | [
"0.824468",
"0.727387",
"0.7242291",
"0.69929683",
"0.69051856",
"0.6741595",
"0.6675783",
"0.6625641",
"0.660019",
"0.6552847",
"0.65396786",
"0.6446757",
"0.6421722",
"0.64049184",
"0.63985157",
"0.6314176",
"0.6296651",
"0.6284545",
"0.62568057",
"0.6159919",
"0.6135134",
... | 0.90140796 | 0 |
Rendering the active button onto the screen surface. | def render_active(self):
# Rendering button "background"
if self.resize_right:
self.active_background_surface = pygame.Surface((self.w * 1.05, self.h))
else:
self.active_background_surface = pygame.Surface((self.w, self.h))
self.active_background_surface.set_alpha(self.alpha)
self.active_background_surface.fill(self.color_bg_active)
self.screen.blit(self.active_background_surface, (self.x, self.y)) # (0,0) are the top-left coordinates
# Rendering button text
self.screen.blit(self.inactive_text_surface, self.inactive_textRect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_inactive(self):\n # Rendering button \"background\"\n self.screen.blit(self.inactive_background_surface, (self.x, self.y))\n # Rendering button text\n self.screen.blit(self.active_text_surface, self.active_textRect)",
"def draw_button(self):\r\n self.surface.fill(sel... | [
"0.8091009",
"0.73016804",
"0.7288868",
"0.72423387",
"0.7085554",
"0.6943015",
"0.6838501",
"0.6808473",
"0.67748725",
"0.6729412",
"0.664229",
"0.6615208",
"0.6613954",
"0.65206283",
"0.6385157",
"0.63824177",
"0.63584137",
"0.63529414",
"0.62700206",
"0.6234393",
"0.622167... | 0.8646287 | 0 |
Renders the animation when a button was clicked | def render_fading(self):
self.alpha = self.alpha - self.fading_steps
self.inactive_background_surface.set_alpha(self.alpha)
if self.sliding_disappearance:
self.x -= self.sliding_steps
self.active_textRect.x -= self.sliding_steps
# Rendering button "background"
self.screen.blit(self.inactive_background_surface, (self.x, self.y)) # (0,0) are the top-left coordinates
if self.alpha > self.alpha_border: # Render button text until its alpha value is reduced by x
self.screen.blit(self.active_text_surface, self.active_textRect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_animation(self):\n self.animation = True\n self.fig = plt.figure()\n anim_running = True\n\n def onClick(event):\n nonlocal anim_running\n if anim_running:\n anim.event_source.stop()\n anim_running = False\n else:\n ... | [
"0.688087",
"0.6423931",
"0.6393294",
"0.62338537",
"0.6215481",
"0.6131152",
"0.61150575",
"0.6104077",
"0.6104077",
"0.60195327",
"0.5972781",
"0.59392756",
"0.5903568",
"0.5837927",
"0.5831422",
"0.57819444",
"0.57465935",
"0.5713443",
"0.56247807",
"0.56239694",
"0.562179... | 0.5403067 | 61 |
Checks whether the mouse is on the button and returns a boolean. | def mouse_on_button(self, mouse) -> bool:
return self.x + self.w > mouse[0] > self.x and self.y + self.h > mouse[1] > self.y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __check_if_got_pressed(self):\n mouse_x_pos,mouse_y_pos = pg.mouse.get_pos()\n\n if utilitiez.on_object(self.rect.x, self.rect.y, self.rect.width, self.rect.height, mouse_x_pos, mouse_y_pos,\n MOUSE_WIDTH, MOUSE_HEIGHT):\n self.__on_click()",
"def isButt... | [
"0.76346713",
"0.75949246",
"0.75622696",
"0.74238867",
"0.73842466",
"0.73723227",
"0.73164",
"0.72117794",
"0.71592665",
"0.7093802",
"0.70712423",
"0.70122606",
"0.68814075",
"0.68803525",
"0.685196",
"0.68248737",
"0.682373",
"0.6745367",
"0.6737135",
"0.6720025",
"0.6718... | 0.8396938 | 0 |
Test that a correct description passes the check and that a dot is added. | def test_description(self):
self.assertEqual(
"Description.",
DescribedModel.parse_obj({"name": "Name", "description": "Description"}).description,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_description(question):\n assert \"description\" in question[\"instance\"]\n description = question[\"instance\"][\"description\"]\n # there shouldn't be whitespace at the beginning or end\n assert description.strip() == description\n words = description.split()\n # we should have at leas... | [
"0.7467771",
"0.7183706",
"0.7170313",
"0.69735307",
"0.69044524",
"0.67804605",
"0.66104364",
"0.65192705",
"0.64968574",
"0.6449131",
"0.6411322",
"0.6408082",
"0.63846517",
"0.63669723",
"0.63474953",
"0.6342997",
"0.6311893",
"0.63043153",
"0.6295491",
"0.6244171",
"0.623... | 0.71865505 | 1 |
Test that a description with punctuation passes the check. | def test_description_with_punctuation(self):
self.assertEqual(
"Description?",
DescribedModel.parse_obj({"name": "Name", "description": "Description?"}).description,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_description(question):\n assert \"description\" in question[\"instance\"]\n description = question[\"instance\"][\"description\"]\n # there shouldn't be whitespace at the beginning or end\n assert description.strip() == description\n words = description.split()\n # we should have at leas... | [
"0.7259576",
"0.70288295",
"0.67982197",
"0.6772335",
"0.66292626",
"0.6555726",
"0.65338016",
"0.65078914",
"0.6434341",
"0.6406588",
"0.6294614",
"0.620535",
"0.61716986",
"0.61261255",
"0.6119967",
"0.6109077",
"0.6107635",
"0.61050224",
"0.60843354",
"0.6074227",
"0.60651... | 0.794725 | 0 |
Test that the description is mandatory. | def test_missing_description(self):
self.check_validation_error("description\n field required", name="Name") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_empty_description(self):\n self.check_validation_error('description\\n string does not match regex \".+\"', name=\"Name\", description=\"\")",
"def testDescription(self):\n project = self.session.create_project()\n\n self.util.stringTypeTest(self, project, \"description\")\n\n ... | [
"0.8143264",
"0.7655286",
"0.7621963",
"0.7548257",
"0.7531445",
"0.74477756",
"0.7441477",
"0.7300264",
"0.72981095",
"0.7288913",
"0.7284006",
"0.7265562",
"0.7217067",
"0.7123357",
"0.7076178",
"0.7076178",
"0.7076178",
"0.7076178",
"0.70645094",
"0.7035895",
"0.7025577",
... | 0.8563048 | 0 |
Test that the description has a nonzero length. | def test_empty_description(self):
self.check_validation_error('description\n string does not match regex ".+"', name="Name", description="") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_no_description(self):\n context = TestContext(session_context=ducktape_mock.session_context(),\n cls=DummyTestNoDescription, function=DummyTestNoDescription.test_this)\n assert context.description == \"\"",
"def test_missing_description(self):\n self.ch... | [
"0.6839186",
"0.6832089",
"0.6650879",
"0.66502285",
"0.6583756",
"0.65266544",
"0.6453843",
"0.6399938",
"0.63959414",
"0.63910407",
"0.63910407",
"0.63910407",
"0.63910407",
"0.63842446",
"0.63687706",
"0.636613",
"0.63494056",
"0.6325557",
"0.6310538",
"0.63036925",
"0.630... | 0.7342262 | 0 |
Extend to setup the model. | def setUp(self):
super().setUp()
described_model_kwargs = {"name": "Name", "description": "Description"}
self.mapped_model = MappedModel[DescribedModel].parse_obj({"described_model_type": described_model_kwargs})
self.expected_described_model = DescribedModel(**described_model_kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_models(self):\n pass",
"def init_model(self):\n pass",
"def initialize_model(self):\n pass",
"def setUpClass(self):\n\n base_model = BaseModel()",
"def prepare_model(self, **kwargs):\n pass",
"def _setupModel(self, parameters):\r\n ModelFitterCore.setup... | [
"0.79114515",
"0.77609944",
"0.76080114",
"0.75181067",
"0.74347234",
"0.7401676",
"0.72847205",
"0.7225797",
"0.72077334",
"0.7136066",
"0.7136066",
"0.7136066",
"0.7136066",
"0.7112577",
"0.7076257",
"0.70315",
"0.70315",
"0.70315",
"0.70315",
"0.6996519",
"0.69867325",
"... | 0.0 | -1 |
Test that values can be retrieved by key using __getitem__(). | def test_get_item(self):
self.assertEqual(self.expected_described_model, self.mapped_model["described_model_type"]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getitem__(self, key):\n pass",
"def __getitem__(self, key):",
"def __getitem__(self, key):\n raise NotImplementedError()",
"def __getitem__(self, key):\n for entry_key, value in self.read(key):\n if entry_key != key:\n raise KeyError(key)\n return value\n raise KeyE... | [
"0.75055385",
"0.74885994",
"0.73212683",
"0.7278315",
"0.7257539",
"0.7129784",
"0.70715296",
"0.70595926",
"0.70080745",
"0.70076877",
"0.69866014",
"0.69863576",
"0.6985903",
"0.6985903",
"0.6985903",
"0.6981361",
"0.69438547",
"0.69308174",
"0.6926797",
"0.6906123",
"0.68... | 0.0 | -1 |
Test that values can be retrieved by key using get(). | def test_get(self):
self.assertEqual(self.expected_described_model, self.mapped_model.get("described_model_type")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get(self):\n storage = Storage()\n keys_to_set = {'1': 'hello',\n '2': 'bye',\n '3': [1,2,'three'],\n '4': {1:'one', 2:'two'}}\n for key in keys_to_set.keys():\n storage.set(key, keys_to_set[key])\n\n ... | [
"0.7516749",
"0.69722515",
"0.69722515",
"0.6736516",
"0.67187446",
"0.67044663",
"0.6631371",
"0.6624731",
"0.6615741",
"0.65834504",
"0.6528521",
"0.64331293",
"0.6407079",
"0.6395825",
"0.6355946",
"0.6348174",
"0.6346767",
"0.62921834",
"0.6275098",
"0.6267472",
"0.625161... | 0.0 | -1 |
Test that the items can be retrieved. | def test_items(self):
self.assertEqual([("described_model_type", self.expected_described_model)], list(self.mapped_model.items())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_item_list(self):\n resp = self.app.get('/items')\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\n data = json.loads(resp.data)\n self.assertEqual(len(data), 3)",
"def test_get_items_page(self, mock_requests_get):\n result = resources.get_items_page(1, \"a... | [
"0.74696356",
"0.7277848",
"0.7122716",
"0.68902785",
"0.68500966",
"0.6840849",
"0.6809992",
"0.6799842",
"0.6778106",
"0.6757121",
"0.67133766",
"0.6710793",
"0.6653335",
"0.6622517",
"0.6612151",
"0.66074485",
"0.66016537",
"0.65803057",
"0.6577676",
"0.6576313",
"0.654119... | 0.62851614 | 47 |
Test that the values can be retrieved. | def test_values(self):
self.assertEqual([self.expected_described_model], list(self.mapped_model.values())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_many_values(self):\n write this test!",
"def test_getknowndata(self):\n result = recordparser.getfields(self.rawdata, self.fieldmap,\n self.sourcekeys)\n self.assertEqual(self.knownvalues, result)",
"def test_properties_get(self):\n pass",
"def test_getitem... | [
"0.72376066",
"0.66556334",
"0.66527504",
"0.6525868",
"0.65233016",
"0.65196735",
"0.64961874",
"0.64638084",
"0.64451057",
"0.642613",
"0.6415883",
"0.64122844",
"0.64025444",
"0.64025444",
"0.6368156",
"0.63579667",
"0.6348108",
"0.63410705",
"0.63293576",
"0.6287174",
"0.... | 0.6480253 | 7 |
Test that the format method returns the value. | def test_format(self):
class FooEnum(StrEnum):
"""Concrete string enum."""
FOO = "foo"
self.assertEqual("foo", f"{FooEnum.FOO}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_formatResult(self):\r\n x = self.FWP({'x': 3})\r\n self.assertEqual(x.formatResult(3), '3')",
"def testFormatLabelAndValue(self):\n\n self.assertEqual('Abc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz', 1))\n self.assertEqual('ABc: xyz', self.inv._FormatLabelAndValue('abc', 'xyz'... | [
"0.7601972",
"0.6776671",
"0.64708084",
"0.64118683",
"0.6358639",
"0.63170815",
"0.6206864",
"0.61815",
"0.6169668",
"0.6160455",
"0.61496854",
"0.60949385",
"0.6047818",
"0.6042502",
"0.59908664",
"0.5988443",
"0.59854466",
"0.5971309",
"0.5958548",
"0.5958548",
"0.5903482"... | 0.0 | -1 |
Returns list of repositories in the target systems defined by the given connection. | def fetch_repos(connection):
try:
response = connection.get_json('repository')
except HTTPRequestError as ex:
raise exception_from_http_error(ex) from ex
result = response.get('result', [])
return [Repository(connection, repo['rid'], data=repo) for repo in result] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_repos(self):\n return [self.config[\"repo\"]]",
"def listRepositories(self):\n return self.mini_catalog.listRepositories()",
"def list_repositories(self):\n repos = self.repo_conn.list_repositories()\n return repos",
"def find_repos(source_connection):\n\n #TODO\n ... | [
"0.73065317",
"0.7184677",
"0.7014473",
"0.69301844",
"0.6757819",
"0.66381013",
"0.65795696",
"0.6515173",
"0.6481872",
"0.6415119",
"0.63748735",
"0.63295364",
"0.631364",
"0.627221",
"0.6263997",
"0.62445974",
"0.6240596",
"0.6182124",
"0.61526173",
"0.6142442",
"0.6122399... | 0.71246964 | 2 |
Wait for clone process to finish | def wait_for_clone(repo, wait_for_ready, http_exc):
start_time = time.time()
while time.time() - start_time < wait_for_ready:
repo.wipe_data()
try:
if repo.is_cloned:
return
except HTTPRequestError:
_mod_log().debug('Failed to get status of the repository %s', repo.rid)
raise SAPCliError(f'Waiting for the repository to be in READY state timed out\n{http_exc}') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def waitUntilFinished():",
"def waitUntilFinished():",
"def waitUntilFinished():",
"def waitUntilFinished():",
"def wait(self):\n self.Popen.wait()",
"def wait(self):\n pass",
"def wait(self):\n pass",
"def wait_finish(self):\r\n self.proc.join()",
"def wait(self):\n\n ... | [
"0.65956825",
"0.65956825",
"0.65956825",
"0.65956825",
"0.6524684",
"0.6290063",
"0.6290063",
"0.6060584",
"0.6007381",
"0.59562814",
"0.59526855",
"0.59149146",
"0.5834006",
"0.5834006",
"0.58271825",
"0.5822418",
"0.57953876",
"0.57722795",
"0.5770641",
"0.5743308",
"0.572... | 0.6913001 | 0 |
Creates and clones the repository in the target systems | def clone(connection, url, rid, vsid='6IT', start_dir='src/', vcs_token=None, error_exists=True,
role='SOURCE', typ='GITHUB'):
config = {}
if start_dir:
config['VCS_TARGET_DIR'] = start_dir
if vcs_token:
config['CLIENT_VCS_AUTH_TOKEN'] = vcs_token
repo = Repository(connection, rid)
try:
repo.create(url, vsid, config=config, role=role, typ=typ)
except GCTSRepoAlreadyExistsError as ex:
if error_exists:
raise ex
_mod_log().debug(ex)
_mod_log().info(str(ex))
repo.wipe_data()
if not repo.is_cloned:
repo.clone()
else:
_mod_log().info('Not cloning the repository "%s": already performed')
return repo | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_clone_system(self):\n pass",
"def create_repo_clone(self, path, https):\n _, _, login, remote_dir = path.split('/', 3) # 3 x '/' before real path\n remote_dir = os.path.dirname(remote_dir) # final segment from clone\n print remote_dir\n cmd = ['ssh', login, 'mkdir', ... | [
"0.66225773",
"0.64688706",
"0.6379742",
"0.6350996",
"0.6275477",
"0.62710005",
"0.62257934",
"0.6220888",
"0.6183023",
"0.6109122",
"0.6078347",
"0.6077387",
"0.6044741",
"0.60430527",
"0.60360557",
"0.6035144",
"0.6016773",
"0.6012548",
"0.60095423",
"0.5999956",
"0.599848... | 0.57568884 | 46 |
Checks out the given branch in the given repository on the give system | def checkout(connection, branch, rid=None, repo=None):
if repo is None:
repo = Repository(connection, rid)
return repo.checkout(branch) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gitCheckoutBranch(self, path, branch):\r\n\r\n with workInDirectory(path):\r\n fetch_cmd = [\"git\", \"fetch\"]\r\n if self.verbose:\r\n print(\"Runing Command : {}\".format(\" \".join(fetch_cmd)))\r\n\r\n SubProcessUtility.runCommand(fetch_cmd)\r\n\r\n ... | [
"0.7553268",
"0.72212356",
"0.7122081",
"0.71060395",
"0.7037166",
"0.69275075",
"0.6837741",
"0.6769412",
"0.6685118",
"0.6674647",
"0.6668449",
"0.65646195",
"0.6517232",
"0.6484005",
"0.64520335",
"0.6417905",
"0.6379777",
"0.6373071",
"0.6324217",
"0.6288217",
"0.6272058"... | 0.728686 | 1 |
Returns log history of the given repository on the give system | def log(connection, rid=None, repo=None):
if repo is None:
repo = Repository(connection, rid)
return repo.log() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_rolling_log_history():\n current_tag = get_current_tag()\n return get_log_history(current_tag)",
"def retrieve_git_log(self):\n result = [str(entry).split(\"\\t\")[1]\n for entry in self.repo.head.log()]\n\n return result",
"def getLogs():",
"def getLogs():",
"d... | [
"0.6816535",
"0.6790785",
"0.64824134",
"0.64824134",
"0.6458293",
"0.644352",
"0.63438153",
"0.63379043",
"0.6326975",
"0.6298118",
"0.6273212",
"0.6261958",
"0.62492275",
"0.6150543",
"0.6111015",
"0.6078224",
"0.6065768",
"0.604785",
"0.6034963",
"0.6026202",
"0.601138",
... | 0.6000602 | 22 |
Pulls the given repository on the give system | def pull(connection, rid=None, repo=None):
if repo is None:
repo = Repository(connection, rid)
return repo.pull() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pull1(repo, **kwargs):\n ret = do_pull(repo, \"topology.virl\")\n if not ret:\n exit(1)",
"def pull(self):\n origin = self.git_repo.remotes.origin\n origin.pull()",
"def pull(self, remote, branch, *args):\n return self.cmd('pull', remote, branch, *args)",
"def pull(refer... | [
"0.73290116",
"0.717763",
"0.7176306",
"0.7152554",
"0.7016408",
"0.69733423",
"0.69663095",
"0.69643307",
"0.69623786",
"0.69125956",
"0.6869978",
"0.67377836",
"0.66976327",
"0.6685887",
"0.6681624",
"0.666945",
"0.66548884",
"0.6588705",
"0.6575877",
"0.65757114",
"0.65705... | 0.7484018 | 0 |
Deletes the given repository on the give system | def delete(connection, rid=None, repo=None):
if repo is None:
repo = Repository(connection, rid)
return repo.delete() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def repository_delete(ctx: click.Context, repository_name):\n subcommand_repository.cmd_delete(ctx.obj, repository_name)",
"def delete(ctx: click.Context, repository_path):\n root_commands.cmd_delete(ctx.obj, repository_path)",
"def delete(repo):\n print('Repo: %s' % repo)\n print('Deleted')",
"d... | [
"0.8317304",
"0.817318",
"0.774548",
"0.7673443",
"0.75179964",
"0.6937679",
"0.6887084",
"0.6834599",
"0.6765182",
"0.6756616",
"0.6703037",
"0.66614944",
"0.6376965",
"0.63704604",
"0.6368734",
"0.6269005",
"0.6256236",
"0.62037766",
"0.61481625",
"0.60742587",
"0.6066743",... | 0.7290421 | 5 |
Get Token for the currently logged in user | def get_user_credentials(connection):
response = connection.get_json('user')
user_data = response.get('user', None)
if user_data is None:
raise SAPCliError('gCTS response does not contain \'user\'')
config_data = user_data.get('config', None)
if config_data is None:
return []
user_credentials = [cred for cred in config_data if cred['key'] == 'USER_AUTH_CRED_ENDPOINTS']
return json.loads(user_credentials[0]['value']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_token(self):\n return user.get_token()",
"def get(self):\n if current_user and not current_user.is_anonymous:\n user = current_user\n tok = Token(user, 3600)\n return tok\n return jsonify({404: 'User not found'})",
"def get_token():\n if g.curre... | [
"0.8868773",
"0.8156606",
"0.8019521",
"0.8019521",
"0.7996061",
"0.7894515",
"0.78614265",
"0.77490443",
"0.77235836",
"0.7714836",
"0.7688327",
"0.7681948",
"0.75940716",
"0.75773776",
"0.7504578",
"0.7444878",
"0.74156564",
"0.74042356",
"0.73997515",
"0.7359239",
"0.73592... | 0.0 | -1 |
Set Token for the currently logged in user | def set_user_api_token(connection, api_url, token):
body = {
'endpoint': api_url,
'user': '',
'password': '',
'token': token,
'type': 'token'
}
connection.post_obj_as_json('user/credentials', body) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_UserToken(self, value):\n super(GetCategoriesInputSet, self)._set_input('UserToken', value)",
"def login_token(self, token):\n self.token = token # this will also set the refresh_token to None",
"def _set_token(self) -> None:\n if 'token' in self.params['user'].keys():\n ... | [
"0.71641374",
"0.71383333",
"0.71284956",
"0.7036171",
"0.6982911",
"0.69558555",
"0.6954422",
"0.68936217",
"0.68726385",
"0.6756373",
"0.6738934",
"0.6696999",
"0.66546893",
"0.66532344",
"0.66050583",
"0.66050583",
"0.65756255",
"0.6556584",
"0.6556224",
"0.6555834",
"0.64... | 0.6654888 | 12 |
Delete Token for the currently logged in user | def delete_user_credentials(connection, api_url):
body = {
'endpoint': api_url,
'user': '',
'password': '',
'token': '',
'type': 'none'
}
connection.post_obj_as_json('user/credentials', body) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self):\n\n user_id = get_jwt_identity()\n user = user_crud.get(user_id)\n if not user:\n abort(404, message=\"User not Found\")\n all_tokens = auth_crud.get_user_tokens(user_id)\n tokens = [token.to_dict() for token in all_tokens]\n for token in token... | [
"0.7799497",
"0.77679306",
"0.7517583",
"0.7433433",
"0.742697",
"0.7416216",
"0.74131984",
"0.7221469",
"0.72203773",
"0.71465814",
"0.71020013",
"0.7097267",
"0.70933104",
"0.70177597",
"0.69026256",
"0.6894906",
"0.6887351",
"0.6852845",
"0.6840806",
"0.68192285",
"0.68083... | 0.0 | -1 |
Get configuration property value for given key | def get_system_config_property(connection, config_key):
response = connection.get_json(f'system/config/{config_key}')
config_value = response.get('result')
if config_value is None:
raise SAPCliError("gCTS response does not contain 'result'")
return config_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, key):\n return self.config.get(key)",
"def get_property(self, key):\n _key = DJANGO_CONF[key]\n return getattr(self, _key, CONF_SPEC[_key])",
"def _get_config_value(self, section, key):\n return config.get(section, key)",
"def get_value(self, key):\n if key no... | [
"0.8216822",
"0.82159626",
"0.81225705",
"0.80191004",
"0.78103554",
"0.78074646",
"0.77338487",
"0.7696018",
"0.76687634",
"0.76586175",
"0.7633325",
"0.76286393",
"0.742231",
"0.73506427",
"0.7315717",
"0.73031425",
"0.72236985",
"0.7163746",
"0.7160865",
"0.71571016",
"0.7... | 0.70693445 | 25 |
Create or update the configuration property | def set_system_config_property(connection, config_key, value):
body = {
'key': config_key,
'value': value,
}
response = connection.post_obj_as_json('system/config', body).json()
config_value = response.get('result')
if config_value is None:
raise SAPCliError("gCTS response does not contain 'result'")
return config_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_set_existing_property():\n\n value = 'new'\n\n contents = (\"[Info]\\n\"\n \"sdk = old\")\n\n testutils.deploy_config_raw(contents)\n\n prop.set_prop('info', 'sdk', value)\n assert prop.get_prop('info', 'sdk') == value\n\n testutils.undeploy()\n\n return 0",
"def test... | [
"0.6991356",
"0.68301314",
"0.64680314",
"0.63569725",
"0.63561064",
"0.6272596",
"0.6241467",
"0.6150869",
"0.6149671",
"0.61463547",
"0.610089",
"0.6067047",
"0.6049001",
"0.60469306",
"0.6039595",
"0.59342664",
"0.59069026",
"0.58782035",
"0.5872062",
"0.58575135",
"0.5849... | 0.5456461 | 78 |
fully connected layers or dense layer | def fclayer(in_features, out_features):
fc = nn.Linear(in_features, out_features)
nn.init.kaiming_normal_(fc.weight)
return fc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_fully_connected_layer(input_layer,\n layer_size,\n activation=tf.nn.relu,\n layer_name='',\n logs=False):\n if not layer_name:\n layer_name = ''.join(str(x) for x in np.random.... | [
"0.71426284",
"0.6833023",
"0.6805999",
"0.67833257",
"0.67681617",
"0.6711874",
"0.6682316",
"0.6651481",
"0.6631076",
"0.6611241",
"0.65508956",
"0.65147924",
"0.6511002",
"0.64513654",
"0.64409477",
"0.63658357",
"0.63640463",
"0.6321559",
"0.62621194",
"0.6261182",
"0.623... | 0.58284247 | 94 |
Get the statistics for the all builders. | def get_buildbot_stats(time_window : datetime.datetime) -> BuildStats:
print('getting list of builders...')
stats = BuildStats()
for builder in requests.get(BASE_URL).json().keys():
# TODO: maybe filter the builds to the ones we care about
stats += get_builder_stats(builder, time_window )
return stats | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_builder_stats(builder: str, time_window: datetime.datetime) -> BuildStats:\n print('Gettings builds for {}...'.format(builder))\n # TODO: can we limit the data we're requesting?\n url = '{}/{}/builds/_all'.format(BASE_URL, builder)\n stats = BuildStats()\n for build, results in requests.get(... | [
"0.70549256",
"0.6995379",
"0.66598487",
"0.6448039",
"0.6427277",
"0.6422584",
"0.6358498",
"0.63564634",
"0.6297995",
"0.62931466",
"0.62858886",
"0.6255862",
"0.6241165",
"0.6240544",
"0.61738175",
"0.61579835",
"0.61428285",
"0.6082591",
"0.60764337",
"0.60596114",
"0.602... | 0.7632881 | 0 |
Get the statistics for one builder. | def get_builder_stats(builder: str, time_window: datetime.datetime) -> BuildStats:
print('Gettings builds for {}...'.format(builder))
# TODO: can we limit the data we're requesting?
url = '{}/{}/builds/_all'.format(BASE_URL, builder)
stats = BuildStats()
for build, results in requests.get(url).json().items():
start_time = datetime.datetime.fromtimestamp(float(results['times'][0]))
if start_time < time_window:
continue
successful = results['text'] == ['build', 'successful']
stats.add(successful)
return stats | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_buildbot_stats(time_window : datetime.datetime) -> BuildStats:\n print('getting list of builders...')\n stats = BuildStats()\n for builder in requests.get(BASE_URL).json().keys():\n # TODO: maybe filter the builds to the ones we care about\n stats += get_builder_stats(builder, time_w... | [
"0.7178298",
"0.6534593",
"0.64914143",
"0.6488856",
"0.63973767",
"0.63478684",
"0.6330162",
"0.62668484",
"0.6216657",
"0.61736965",
"0.615647",
"0.6031543",
"0.6031311",
"0.6029025",
"0.5993337",
"0.59911054",
"0.5989218",
"0.5979158",
"0.59560424",
"0.5946391",
"0.5927121... | 0.7503165 | 0 |
Create metric descriptors on Stackdriver. Recreating these with every call is fine. | def gcp_create_metric_descriptor(project_id: str):
client = monitoring_v3.MetricServiceClient()
project_name = client.project_path(project_id)
for desc_type, desc_desc in [
["buildbots_percent_failed", "Percentage of failed builds"],
["buildbots_builds_successful", "Number of successful builds in the last 24h."],
["buildbots_builds_failed", "Number of failed builds in the last 24h."],
["buildbots_builds_total", "Total number of builds in the last 24h."],
]:
descriptor = monitoring_v3.types.MetricDescriptor()
descriptor.type = 'custom.googleapis.com/buildbots_{}'.format(desc_type)
descriptor.metric_kind = (
monitoring_v3.enums.MetricDescriptor.MetricKind.GAUGE)
descriptor.value_type = (
monitoring_v3.enums.MetricDescriptor.ValueType.DOUBLE)
descriptor.description = desc_desc
descriptor = client.create_metric_descriptor(project_name, descriptor)
print('Created {}.'.format(descriptor.name)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recreate_metrics():\n all = monitor_client.list_metric_descriptors(\n project_path, filter_='metric.type=starts_with(\"custom.\")'\n )\n for a in all:\n if \"accumulator\" in str(a) or \"biquery\" in str(a):\n metric_name = monitor_client.metric_descriptor_path(\n ... | [
"0.70970815",
"0.6102869",
"0.5952238",
"0.5923666",
"0.58200157",
"0.5791009",
"0.5774546",
"0.575687",
"0.57353896",
"0.5720316",
"0.5650112",
"0.5590122",
"0.5529896",
"0.54889554",
"0.54316115",
"0.54202217",
"0.5382546",
"0.5348047",
"0.53211987",
"0.5313823",
"0.530327"... | 0.66897804 | 1 |
Upload metrics to Stackdriver. | def gcp_write_data(project_id: str, stats: BuildStats):
client = monitoring_v3.MetricServiceClient()
project_name = client.project_path(project_id)
now = datetime.datetime.now()
for desc_type, value in [
["buildbots_percent_failed", stats.percent_failed],
["buildbots_builds_successful", stats.successful],
["buildbots_builds_failed", stats.failed],
["buildbots_builds_total", stats.total],
]:
series = monitoring_v3.types.TimeSeries()
series.metric.type = 'custom.googleapis.com/buildbots_{}'.format(desc_type)
series.resource.type = 'global'
point = series.points.add()
point.value.double_value = value
point.interval.end_time.seconds = int(now.timestamp())
client.create_time_series(project_name, [series]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upload_metrics(metrics_dict, project, dataset, table):\n # Credentials will be loaded from envvar $GOOGLE_APPLICATION_CREDENTIALS.\n bq_client = bigquery.Client(project=project)\n table_ref = bq_client.dataset(dataset).table(table)\n errors = bq_client.insert_rows_json(table_ref, metrics_dict)\n return er... | [
"0.6587916",
"0.650881",
"0.6472843",
"0.6468111",
"0.6410721",
"0.6152306",
"0.6033505",
"0.5933085",
"0.58030564",
"0.5773362",
"0.5758092",
"0.57214624",
"0.56050664",
"0.55261976",
"0.5523498",
"0.5457035",
"0.54216254",
"0.5412076",
"0.54043615",
"0.5381582",
"0.5369474"... | 0.5305429 | 24 |
initialize a receptor library by setting the number of receptors, the number of substrates it can respond to, and optional additional parameters in the parameter dictionary | def __init__(self, num_substrates, num_receptors, parameters=None):
# the call to the inherited method also sets the default parameters from
# this class
super(LibraryBinaryNumeric, self).__init__(num_substrates,
num_receptors, parameters)
# prevent integer overflow in collecting activity patterns
assert num_receptors <= self.parameters['max_num_receptors'] <= 63
# check fixed_mixture_size parameter
fixed_mixture_size = self.parameters['fixed_mixture_size']
if fixed_mixture_size is False:
# special case where we accept False and silently convert to None
self.parameters['fixed_mixture_size'] = None
elif fixed_mixture_size is not None:
# if the value is not None it better is an integer
try:
fixed_mixture_size = int(fixed_mixture_size)
if 0 <= fixed_mixture_size <= self.Ns:
self.parameters['fixed_mixture_size'] = fixed_mixture_size
else:
raise ValueError
except (TypeError, ValueError):
raise ValueError('`fixed_mixture_size` must either be None or '
'an integer between 0 and Ns.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, num_params):\r\n self.num_params = num_params",
"def __init__(self, num_params):\r\n self.num_params = num_params",
"def __init__(self, *args, **kwargs):\n self.specGenerator = WMSpecGenerator()\n self.count = 0\n self.maxWmSpec = kwargs.setdefault('numOfSp... | [
"0.624694",
"0.624694",
"0.59270716",
"0.58812773",
"0.5859252",
"0.5857603",
"0.5856646",
"0.5854381",
"0.5844939",
"0.58047056",
"0.5773737",
"0.57722926",
"0.57650805",
"0.57243747",
"0.5716238",
"0.56949776",
"0.5688408",
"0.56387156",
"0.5638388",
"0.5597038",
"0.5542545... | 0.7083537 | 0 |
create random arguments for creating test instances | def get_random_arguments(cls, fixed_mixture_size=None, **kwargs):
args = super(LibraryBinaryNumeric, cls).get_random_arguments(**kwargs)
if fixed_mixture_size is not None:
args['parameters']['fixed_mixture_size'] = fixed_mixture_size
return args | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_scenarios(self, params, num_scenarios, random_seed):\n return None",
"def generate_params(self, randomize=True):\n pass",
"def fixture_wrapper_arguments():\n n_features = 9\n classes = [\"a\", \"b\", \"c\"]\n\n return n_features, classes",
"def seed(*args, **kwargs): # real sign... | [
"0.6887592",
"0.6532512",
"0.65300083",
"0.649554",
"0.6424966",
"0.6268241",
"0.6204779",
"0.61991894",
"0.6059095",
"0.6022314",
"0.5994968",
"0.5982778",
"0.59304875",
"0.5911756",
"0.588763",
"0.5865559",
"0.5842821",
"0.5842821",
"0.5842703",
"0.58391935",
"0.5827592",
... | 0.56847954 | 31 |
creates a test instance used for consistency tests | def create_test_instance(cls, **kwargs):
# create a instance with random parameters
obj = super(LibraryBinaryNumeric, cls).create_test_instance(**kwargs)
# choose an optimal interaction matrix
obj.choose_sensitivity_matrix('auto')
return obj | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_test_object(self):\n return self.orm_cls.testing_create()",
"def create_instance(test_id, config, args):\n return TestT1Detail(test_id, config, args)",
"def test_new(self):",
"def test_new(self):",
"def test_constructor(self):\n pass",
"def test_create(self):\n pass",
"... | [
"0.73254544",
"0.70019776",
"0.6976491",
"0.6976491",
"0.6886069",
"0.6675423",
"0.6637996",
"0.65213585",
"0.65042526",
"0.64920676",
"0.64536",
"0.6413658",
"0.6351893",
"0.6320265",
"0.62997496",
"0.62697804",
"0.6266391",
"0.62615484",
"0.6233441",
"0.6232256",
"0.6212402... | 0.6345531 | 13 |
calculate the number of steps to do for `scheme` | def get_steps(self, scheme):
if scheme == 'monte_carlo':
# calculate the number of steps for a monte-carlo scheme
if self.parameters['monte_carlo_steps'] == 'auto':
steps_min = self.parameters['monte_carlo_steps_min']
steps_max = self.parameters['monte_carlo_steps_max']
steps = np.clip(10 * 2**self.Nr, steps_min, steps_max)
# Here, the factor 10 is an arbitrary scaling factor
else:
steps = self.parameters['monte_carlo_steps']
elif scheme == 'metropolis':
# calculate the number of steps for a metropolis scheme
if self.parameters['metropolis_steps'] == 'auto':
steps_min = self.parameters['metropolis_steps_min']
steps_max = self.parameters['metropolis_steps_max']
steps = np.clip(10 * 2**self.Nr, steps_min, steps_max)
# Here, the factor 10 is an arbitrary scaling factor
else:
steps = self.parameters['metropolis_steps']
else:
raise ValueError('Unknown stepping scheme `%s`' % scheme)
return int(steps) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_steps_num():\n return 0",
"def decode_step_count(self, board=None):\n # TODO decide which one is better.. not crucial\n # steps = 0\n # for key_pow, val_coor in self.read_bits.items():\n # steps += (self.matrix_board[val_coor] * 2) ** key_pow\n # return step... | [
"0.65601104",
"0.65067685",
"0.6441884",
"0.64148223",
"0.6364415",
"0.62706876",
"0.6186873",
"0.61510324",
"0.6133444",
"0.60866106",
"0.60067546",
"0.60036564",
"0.5896404",
"0.58475363",
"0.58371323",
"0.5806053",
"0.5803067",
"0.58011645",
"0.57761735",
"0.5773252",
"0.5... | 0.7198185 | 0 |
creates a interaction matrix with the given properties | def choose_sensitivity_matrix(self, density=0, avoid_correlations=False):
shape = (self.Nr, self.Ns)
if density == 'auto':
# determine optimal parameters for the interaction matrix
from .lib_bin_theory import LibraryBinaryUniform
theory = LibraryBinaryUniform.from_other(self)
density = theory.get_optimal_library()['density']
if density == 0:
# simple case of empty matrix
self.sens_mat = np.zeros(shape, np.uint8)
elif density >= 1:
# simple case of full matrix
self.sens_mat = np.ones(shape, np.uint8)
elif avoid_correlations:
# choose receptor substrate interaction randomly but try to avoid
# correlations between the receptors
self.sens_mat = np.zeros(shape, np.uint8)
num_entries = int(round(density * self.Nr * self.Ns))
empty_sens_mat = True
while num_entries > 0:
# specify the substrates that we want to detect
if num_entries >= self.Ns:
i_ids = np.arange(self.Ns)
num_entries -= self.Ns
else:
i_ids = np.random.choice(np.arange(self.Ns), num_entries,
replace=False)
num_entries = 0
if empty_sens_mat:
# set the receptors for the substrates
a_ids = np.random.randint(0, self.Nr, len(i_ids))
for i, a in zip(i_ids, a_ids):
self.sens_mat[a, i] = 1
empty_sens_mat = False
else:
# choose receptors for each substrate from the ones that
# are not activated, yet
for i in i_ids:
a_ids = np.flatnonzero(self.sens_mat[:, i] == 0)
self.sens_mat[random.choice(a_ids), i] = 1
else: # not avoid_correlations:
# choose receptor substrate interaction randomly and don't worry
# about correlations
self.sens_mat = (np.random.random(shape) < density).astype(np.uint8)
# save the parameters determining this matrix
self.parameters['sensitivity_matrix_params'] = {
'density': density,
'avoid_correlations': avoid_correlations
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def interaction_matrix(self):\n\n self.int_M_called = True\n int_M = np.zeros((self.n, self.n))\n for k in range(self.n):\n for j in range(k+1):\n o = self.attribute_interactions(k, j)\n int_M[k, j] = o.rel_total_ig_ab # Store total information gain\n ... | [
"0.6194615",
"0.56910884",
"0.56631625",
"0.5550948",
"0.55139613",
"0.549342",
"0.5372611",
"0.5372611",
"0.52580357",
"0.5247446",
"0.5166129",
"0.5157592",
"0.5156394",
"0.514412",
"0.51274884",
"0.51019424",
"0.5082754",
"0.50743306",
"0.5064459",
"0.5027708",
"0.49512535... | 0.0 | -1 |
return the sorted `sensitivity_matrix` or sorts the internal sensitivity_matrix in place. This function rearranges receptors such that receptors reacting to an equal number of substrates and to similar substrates are close together. | def sort_sensitivity_matrix(self, sensitivity_matrix=None):
if sensitivity_matrix is None:
sens_mat = self.sens_mat
else:
sens_mat = sensitivity_matrix
data = [(sum(item), list(item)) for item in sens_mat]
sens_mat = np.array([item[1] for item in sorted(data)])
if sensitivity_matrix is None:
self.sens_mat = sens_mat
else:
return sens_mat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SortAndFilterSuspects(self, suspects):\n if not suspects or len(suspects) == 1:\n return suspects\n\n suspects.sort(key=lambda suspect: -suspect.confidence)\n max_score = suspects[0].confidence\n min_score = max(suspects[-1].confidence, 0.0)\n if max_score == min_score:\n return []\n\n... | [
"0.54372156",
"0.5328664",
"0.5222484",
"0.4775966",
"0.47067013",
"0.46552995",
"0.46477485",
"0.46280968",
"0.4625397",
"0.46188542",
"0.46107998",
"0.45985577",
"0.45515847",
"0.45426014",
"0.45174512",
"0.45159692",
"0.4500111",
"0.44911516",
"0.44894326",
"0.44743133",
"... | 0.73758173 | 0 |
return the number of steps we iterate over | def _iterate_steps(self):
mixture_size = self.parameters['fixed_mixture_size']
if mixture_size is None:
return 2 ** self.Ns
else:
return scipy.special.comb(self.Ns, mixture_size, exact=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def number_of_steps(self) -> int:\n return len(self.step_points)",
"def num_steps(self):\n return self.torsoStepCount() + 1",
"def num_steps(self) -> int:\n return self._num_steps",
"def number_of_iterations(self) -> int:\n return self._solution.info.iter",
"def n_steps(self) ->... | [
"0.8299782",
"0.814433",
"0.8137605",
"0.79739",
"0.79542035",
"0.7865278",
"0.77747107",
"0.74807376",
"0.74784815",
"0.74234825",
"0.7367897",
"0.7363563",
"0.7347694",
"0.7343244",
"0.73042005",
"0.7163757",
"0.7137122",
"0.71312535",
"0.7065494",
"0.7043801",
"0.70322317"... | 0.6790382 | 29 |
iterate over all mixtures and yield the mixture with probability | def _iterate_mixtures(self):
if self._iterate_steps > self.parameters['max_steps']:
raise RuntimeError('The iteration would take more than %g steps'
% self.parameters['max_steps'])
hi = self.commonness
Jij = self.correlations
mixture_size = self.parameters['fixed_mixture_size']
if mixture_size is None:
# iterate over all mixtures
for c in itertools.product((0, 1), repeat=self.Ns):
c = np.array(c, np.uint8)
weight_c = np.exp(np.dot(np.dot(Jij, c) + hi, c))
yield c, weight_c
elif mixture_size == 0:
# special case which is not covered by the iteration below
yield np.zeros(self.Ns, np.uint8), 1
elif mixture_size == self.Ns:
# special case which is not covered by the iteration below
yield np.ones(self.Ns, np.uint8), 1
else:
# iterate over all mixtures with constant number of substrates
c = np.zeros(self.Ns, np.uint8)
for nz in itertools.combinations(range(self.Ns), mixture_size):
c[:] = 0
c[np.array(nz)] = 1
weight_c = np.exp(np.dot(np.dot(Jij, c) + hi, c))
yield c, weight_c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sample_binary_mixtures(model, steps, dtype=np.uint):\n mixture_size = model.parameters['fixed_mixture_size']\n \n if not model.is_correlated_mixture and mixture_size is None:\n # use simple monte carlo algorithm\n prob_s = model.substrate_probabilities\n \n for _ i... | [
"0.6160292",
"0.6110729",
"0.59938663",
"0.59472424",
"0.58536416",
"0.58510166",
"0.58116955",
"0.5767724",
"0.57352465",
"0.5675324",
"0.5663256",
"0.5660493",
"0.56528705",
"0.55985093",
"0.5573837",
"0.55732846",
"0.5572714",
"0.55721015",
"0.55552113",
"0.55295265",
"0.5... | 0.73259944 | 0 |
returns the number of steps that are sampled | def _sample_steps(self):
mixture_size = self.parameters['fixed_mixture_size']
if not self.is_correlated_mixture and mixture_size is None:
return self.get_steps('monte_carlo')
else:
return self.get_steps('metropolis') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sampled_timesteps(self) -> int:\n return self.sampled_timesteps",
"def number_of_sample_loops(self) -> int:\n return self.__number_of_sample_loops",
"def number_of_steps(self) -> int:\n return len(self.step_points)",
"def num_trials(self):",
"def get_steps_num():\n retur... | [
"0.75682855",
"0.75195956",
"0.73266625",
"0.72938573",
"0.7275451",
"0.72581595",
"0.71938956",
"0.7193268",
"0.7035799",
"0.70202214",
"0.69543606",
"0.6949648",
"0.69149685",
"0.6895572",
"0.68642855",
"0.68349636",
"0.6822851",
"0.6780394",
"0.6769589",
"0.6767999",
"0.67... | 0.65237594 | 28 |
sample mixtures with uniform probability yielding single mixtures | def _sample_mixtures(self, steps=None, dtype=np.uint):
if steps is None:
steps = self._sample_steps
return _sample_binary_mixtures(self, steps, dtype) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample(probs):\n\n probs = probs / probs.sum()\n return np.random.choice(np.arange(len(probs)), p=probs.flatten())",
"def _sample_binary_mixtures(model, steps, dtype=np.uint):\n mixture_size = model.parameters['fixed_mixture_size']\n \n if not model.is_correlated_mixture and mixture_si... | [
"0.7214203",
"0.70885044",
"0.7082292",
"0.6908264",
"0.68251544",
"0.668024",
"0.66489446",
"0.66139346",
"0.6609883",
"0.6569002",
"0.6538509",
"0.6538509",
"0.6516518",
"0.64834464",
"0.64289886",
"0.64258486",
"0.6417512",
"0.6410464",
"0.63893205",
"0.63742346",
"0.63742... | 0.7010635 | 3 |
calculates statistics of mixtures. Returns a vector with the frequencies at which substrates are present in mixtures and a matrix of correlations among substrates | def mixture_statistics(self, method='auto'):
if method == 'auto':
fixed_mixture_size = self.parameters['fixed_mixture_size']
if self.is_correlated_mixture or fixed_mixture_size is not None:
# mixture has correlations => we do Metropolis sampling
if self.Ns <= self.parameters['brute_force_threshold_Ns']:
method = 'brute-force'
else:
method = 'monte-carlo'
else:
# the estimate is exact for mixtures without correlations
method = 'estimate'
if method == 'brute-force' or method == 'brute_force':
return self.mixture_statistics_brute_force()
elif method == 'monte-carlo' or method == 'monte_carlo':
return self.mixture_statistics_monte_carlo()
elif method == 'estimate':
return self.mixture_statistics_estimate()
else:
raise ValueError('Unknown method `%s` for mixture statistics'
% method) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mixture_statistics_brute_force(self):\n \n Z = 0\n hist1d = np.zeros(self.Ns)\n hist2d = np.zeros((self.Ns, self.Ns))\n \n # iterate over all mixtures\n for c, weight_c in self._iterate_mixtures():\n Z += weight_c \n hist1d += c * we... | [
"0.74882096",
"0.6869365",
"0.63603956",
"0.5688248",
"0.5665906",
"0.54986227",
"0.5472821",
"0.546352",
"0.54602647",
"0.54511094",
"0.5444543",
"0.54376626",
"0.5413902",
"0.53850305",
"0.53826225",
"0.5331185",
"0.53221416",
"0.52429974",
"0.52369267",
"0.5235607",
"0.522... | 0.5727949 | 3 |
calculates mixture statistics using a brute force algorithm | def mixture_statistics_brute_force(self):
Z = 0
hist1d = np.zeros(self.Ns)
hist2d = np.zeros((self.Ns, self.Ns))
# iterate over all mixtures
for c, weight_c in self._iterate_mixtures():
Z += weight_c
hist1d += c * weight_c
hist2d += np.outer(c, c) * weight_c
# calculate the frequency and the correlations
ci_mean = hist1d / Z
cij = hist2d / Z
cij_corr = cij - np.outer(ci_mean, ci_mean)
ci_var = np.diag(cij_corr)
return {'mean': ci_mean, 'std': np.sqrt(ci_var), 'var': ci_var,
'cov': cij_corr} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_mixture_features(args):\n workspace = args.workspace\n speech_dir = args.speech_dir\n noise_dir = args.noise_dir\n data_type = args.data_type\n fs = cfg.sample_rate\n dir_name = args.dir_name\n\n fid_clean = open(speech_dir, 'r')\n lines_clean = fid_clean.readlines()\n fid_... | [
"0.603266",
"0.6025553",
"0.5984378",
"0.59416246",
"0.58981115",
"0.5829733",
"0.5794666",
"0.5727615",
"0.57198894",
"0.5643767",
"0.5639376",
"0.56325966",
"0.5592785",
"0.55927706",
"0.55848724",
"0.5584382",
"0.5581739",
"0.55519193",
"0.5520184",
"0.55121636",
"0.551020... | 0.70597595 | 0 |
calculates mixture statistics using a metropolis algorithm | def mixture_statistics_monte_carlo(self):
return self.concentration_statistics_monte_carlo() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mixture_statistics_brute_force(self):\n \n Z = 0\n hist1d = np.zeros(self.Ns)\n hist2d = np.zeros((self.Ns, self.Ns))\n \n # iterate over all mixtures\n for c, weight_c in self._iterate_mixtures():\n Z += weight_c \n hist1d += c * we... | [
"0.7127375",
"0.65244097",
"0.64762837",
"0.62966573",
"0.6231615",
"0.62085813",
"0.6098288",
"0.6089708",
"0.6025141",
"0.6018902",
"0.595598",
"0.58740145",
"0.5856431",
"0.584514",
"0.5828641",
"0.58285016",
"0.5824226",
"0.5790562",
"0.5787351",
"0.5778131",
"0.57633173"... | 0.6240846 | 4 |
estimates the mixture statistics | def mixture_statistics_estimate(self):
ci_mean = self.substrate_probabilities
if self.is_correlated_mixture:
J_ij = self.correlations
pi_s = ci_mean
bar_pi_s = 1 - pi_s
ci_mean = pi_s * (1 + 2*bar_pi_s*np.dot(J_ij, pi_s))
ci_var = ci_mean * (1 - ci_mean)
cij_cov = (
np.diag(ci_var)
+ 2*np.einsum('ij,i,j->ij', J_ij, ci_var, ci_var)
)
else:
# uncorrelated mixtures
ci_var = ci_mean * (1 - ci_mean)
cij_cov = np.diag(ci_var)
return {'mean': ci_mean, 'std': np.sqrt(ci_var), 'var': ci_var,
'cov': cij_cov} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mixture_statistics_brute_force(self):\n \n Z = 0\n hist1d = np.zeros(self.Ns)\n hist2d = np.zeros((self.Ns, self.Ns))\n \n # iterate over all mixtures\n for c, weight_c in self._iterate_mixtures():\n Z += weight_c \n hist1d += c * we... | [
"0.7492281",
"0.6477891",
"0.639532",
"0.63856214",
"0.62459314",
"0.6159641",
"0.6154703",
"0.6007116",
"0.5989447",
"0.5913637",
"0.58870196",
"0.5853389",
"0.58513975",
"0.5809787",
"0.57763517",
"0.5753387",
"0.57354677",
"0.5716687",
"0.570656",
"0.56891644",
"0.56604356... | 0.6841529 | 1 |
return the entropy in the mixture distribution | def mixture_entropy(self):
mixture_size = self.parameters['fixed_mixture_size']
if self.is_correlated_mixture or mixture_size is not None:
# complicated case => run brute force or monte carlo
if self.Ns <= self.parameters['brute_force_threshold_Ns']:
return self.mixture_entropy_brute_force()
else:
return self.mixture_entropy_monte_carlo()
else:
# simple case => calculate explicitly
return super(LibraryBinaryNumeric, self).mixture_entropy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mixture_entropy_monte_carlo(self):\n if self.Ns > 63:\n raise ValueError('Mixture entropy estimation only works for fewer '\n 'than 64 substrates.')\n \n # sample mixtures\n base = 2 ** np.arange(0, self.Ns)\n observations = collections.... | [
"0.77932525",
"0.7712108",
"0.7700953",
"0.76825845",
"0.765476",
"0.76226604",
"0.7404143",
"0.7329493",
"0.7265178",
"0.72088486",
"0.72088397",
"0.71819735",
"0.7174679",
"0.71286225",
"0.7125953",
"0.70846903",
"0.7073766",
"0.70677555",
"0.70629066",
"0.70614755",
"0.705... | 0.75569916 | 6 |
gets the entropy in the mixture distribution using brute force | def mixture_entropy_brute_force(self):
Z, sum_wlogw = 0, 0
# Naive implementation of measuring the entropy is
# p(c) = w(c) / Z with Z = sum_c w(c)
# H_c = -sum_c p(c) * log2(p(c))
# This can be transformed to a more stable implementation:
# H_c = log2(Z) - 1/Z * sum_c w(c) * log2(w(c))
for _, weight_c in self._iterate_mixtures():
if weight_c > 0:
Z += weight_c
sum_wlogw += weight_c * np.log2(weight_c)
if Z == 0:
return 0
else:
return np.log2(Z) - sum_wlogw / Z | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entropy(temp,pres):\n g_t = liq_g(1,0,temp,pres)\n s = -g_t\n return s",
"def calc_entropy(data_set): #calculates total entropy of the dataset\r\n republicans = 0\r\n democrats = 0\r\n total = 0\r\n for data_point in data_set:\r\n party = data_point.dat_party\r\n if party =... | [
"0.69703406",
"0.6953341",
"0.69284886",
"0.69082105",
"0.687003",
"0.6861443",
"0.6851223",
"0.6819869",
"0.6818582",
"0.68088657",
"0.677869",
"0.67508334",
"0.66926396",
"0.66545224",
"0.6642097",
"0.66395456",
"0.6627271",
"0.6620591",
"0.6618552",
"0.66109055",
"0.658740... | 0.7468018 | 0 |
gets the entropy in the mixture distribution using brute force | def mixture_entropy_monte_carlo(self):
if self.Ns > 63:
raise ValueError('Mixture entropy estimation only works for fewer '
'than 64 substrates.')
# sample mixtures
base = 2 ** np.arange(0, self.Ns)
observations = collections.Counter()
for c in self._sample_mixtures():
observations[np.dot(c, base)] += 1
# estimate entropy from the histogram
counts = np.fromiter(observations.values(), np.double,
len(observations))
# Naive implementation of measuring the entropy is
# ps = counts / self._sample_steps
# H = -np.sum(ps * np.log2(ps))
# This can be transformed to a more stable implementation:
log_steps = np.log2(self._sample_steps)
return -np.sum(counts*(np.log2(counts) - log_steps))/self._sample_steps | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mixture_entropy_brute_force(self):\n Z, sum_wlogw = 0, 0\n\n # Naive implementation of measuring the entropy is\n # p(c) = w(c) / Z with Z = sum_c w(c)\n # H_c = -sum_c p(c) * log2(p(c))\n # This can be transformed to a more stable implementation:\n # H_c =... | [
"0.7468018",
"0.69703406",
"0.6953341",
"0.69284886",
"0.69082105",
"0.687003",
"0.6861443",
"0.6851223",
"0.6819869",
"0.6818582",
"0.677869",
"0.67508334",
"0.66926396",
"0.66545224",
"0.6642097",
"0.66395456",
"0.6627271",
"0.6620591",
"0.6618552",
"0.66109055",
"0.6587405... | 0.68088657 | 10 |
calculates the average activity of the receptor as a response to single ligands. `method` can be ['brute_force', 'monte_carlo', 'estimate', 'auto']. If it is 'auto' than the method is chosen automatically based on the problem size. | def receptor_crosstalk(self, method='auto', ret_receptor_activity=False,
**kwargs):
if method == 'auto':
if self.Ns <= self.parameters['brute_force_threshold_Ns']:
method = 'brute_force'
else:
method = 'monte_carlo'
if method == 'estimate':
# estimate receptor crosstalk directly
q_nm = self.receptor_crosstalk_estimate(**kwargs)
if ret_receptor_activity:
q_n = self.receptor_activity_estimate(**kwargs)
else:
# calculate receptor crosstalk from the observed probabilities
r_n, r_nm = self.receptor_activity(method, ret_correlations=True,
**kwargs)
q_n = r_n
q_nm = r_nm - np.outer(r_n, r_n)
if kwargs.get('clip', False):
np.clip(q_nm, 0, 1, q_nm)
if ret_receptor_activity:
return q_n, q_nm
else:
return q_nm | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def receptor_activity(self, method='auto', ret_correlations=False, **kwargs):\n if method == 'auto':\n if self.Ns <= self.parameters['brute_force_threshold_Ns']:\n method = 'brute_force'\n else:\n method = 'monte_carlo'\n \n if method... | [
"0.61769646",
"0.59880954",
"0.58919096",
"0.51603234",
"0.49008435",
"0.48851067",
"0.48679084",
"0.48065102",
"0.47901058",
"0.47881097",
"0.47419894",
"0.47048995",
"0.4704445",
"0.4698729",
"0.46906117",
"0.46540016",
"0.45315513",
"0.45278776",
"0.45257092",
"0.4525169",
... | 0.503741 | 4 |
estimates the average activity of the receptor as a response to single ligands. `ret_receptor_activity` determines whether the mean receptor activity will also be returned. `approx_prob` determines whether the probabilities of encountering ligands in mixtures are calculated exactly or only approximative, which should work for small probabilities. `clip` determines whether the estimates will be forced to be in [0, 1]. `ignore_correlations` determines whether correlations in the mixtures will be ignored or not. | def receptor_crosstalk_estimate(self, ret_receptor_activity=False,
approx_prob=False, clip=False,
ignore_correlations=False):
if not ignore_correlations and self.is_correlated_mixture:
r_n, r_nm = self.receptor_activity_estimate(ret_correlations=True,
approx_prob=approx_prob,
clip=clip)
q_nm = r_nm - np.outer(r_n, r_n)
if clip:
np.clip(q_nm, 0, 1, q_nm)
if ret_receptor_activity:
return r_n, q_nm
else:
return q_nm
raise NotImplementedError('Not implemented for correlated mixtures')
S_ni = self.sens_mat
p_i = self.substrate_probabilities
if approx_prob:
# approximate calculation for small p_i
q_nm = np.einsum('ni,mi,i->nm', S_ni, S_ni, p_i)
if clip:
np.clip(q_nm, 0, 1, q_nm)
else:
# proper calculation of the probabilities
S_ni_mask = S_ni.astype(np.bool)
q_nm = np.zeros((self.Nr, self.Nr))
for n in range(self.Nr):
for m in range(self.Nr):
mask = S_ni_mask[n, :] * S_ni_mask[m, :]
q_nm[n, m] = 1 - np.product(1 - p_i[mask])
if ret_receptor_activity:
q_n = self.receptor_activity_estimate(approx_prob=approx_prob,
clip=clip)
return q_n, q_nm
else:
return q_nm | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def receptor_activity_estimate(self, ret_correlations=False,\n approx_prob=False, clip=False):\n S_ni = self.sens_mat\n p_i = self.substrate_probabilities\n\n # calculate receptor activity assuming uncorrelated mixtures \n if approx_prob:\n ... | [
"0.64386016",
"0.49481305",
"0.48385146",
"0.4779224",
"0.46856108",
"0.46765503",
"0.4662905",
"0.46267968",
"0.45856437",
"0.45664948",
"0.43939775",
"0.43856367",
"0.43828163",
"0.436443",
"0.43603247",
"0.43355826",
"0.43281123",
"0.43260527",
"0.43019044",
"0.42894408",
... | 0.5905821 | 1 |
calculates the average activity of each receptor `method` can be ['brute_force', 'monte_carlo', 'estimate', 'auto']. If it is 'auto' than the method is chosen automatically based on the problem size. | def receptor_activity(self, method='auto', ret_correlations=False, **kwargs):
if method == 'auto':
if self.Ns <= self.parameters['brute_force_threshold_Ns']:
method = 'brute_force'
else:
method = 'monte_carlo'
if method == 'brute_force' or method == 'brute-force':
return self.receptor_activity_brute_force(ret_correlations, **kwargs)
elif method == 'monte_carlo' or method == 'monte-carlo':
return self.receptor_activity_monte_carlo(ret_correlations, **kwargs)
elif method == 'estimate':
return self.receptor_activity_estimate(ret_correlations, **kwargs)
else:
raise ValueError('Unknown method `%s`.' % method) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def receptor_score(self, method='auto', multiprocessing=False):\n init_arguments = self.init_arguments\n init_arguments['parameters']['initialize_state']['sensitivity'] = 'exact'\n init_arguments['parameters']['sensitivity_matrix'] = self.sens_mat\n joblist = [(copy.deepcopy(self.init_a... | [
"0.62602246",
"0.5744438",
"0.531374",
"0.5277215",
"0.50603354",
"0.50047123",
"0.49545625",
"0.491439",
"0.4823283",
"0.48020002",
"0.47525263",
"0.47253197",
"0.47229403",
"0.46382526",
"0.46355662",
"0.4616571",
"0.45886013",
"0.45580858",
"0.45328122",
"0.45287707",
"0.4... | 0.6362825 | 0 |
calculates the average activity of each receptor | def receptor_activity_brute_force(self, ret_correlations=False):
S_ni = self.sens_mat
Z = 0
r_n = np.zeros(self.Nr)
if ret_correlations:
r_nm = np.zeros((self.Nr, self.Nr))
# iterate over all mixtures
for c, prob_c in self._iterate_mixtures():
# get the activity vector associated with m
a_n = (np.dot(S_ni, c) >= 1)
Z += prob_c
r_n[a_n] += prob_c
if ret_correlations:
r_nm[np.outer(a_n, a_n)] += prob_c
# return the normalized output
r_n /= Z
if ret_correlations:
r_nm /= Z
return r_n, r_nm
else:
return r_n | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def avg_num_visits_patient(self):\n pass",
"def average(self):\n return self.summation() / self.count()",
"def avg_act(self) -> float:\n return torch.mean(self.units.act)",
"def averageTime(self):\n \n pass",
"def average_reward(self):\n T = len(self)\n return n... | [
"0.6337728",
"0.6317526",
"0.6239112",
"0.6218929",
"0.6072164",
"0.6055115",
"0.60446227",
"0.60446227",
"0.60446227",
"0.6001991",
"0.5984581",
"0.59661394",
"0.5950102",
"0.59168255",
"0.5873765",
"0.58574045",
"0.5838681",
"0.58351356",
"0.58133924",
"0.5779711",
"0.57638... | 0.0 | -1 |
estimates the average activity of each receptor. `ret_correlations` determines whether the correlations between receptors are returned in addition to the mean activations. `approx_prob` determines whether the probabilities of encountering substrates in mixtures are calculated exactly or only approximative, which should work for small probabilities. `clip` determines whether the estimates will be forced to be in [0, 1]. | def receptor_activity_estimate(self, ret_correlations=False,
approx_prob=False, clip=False):
S_ni = self.sens_mat
p_i = self.substrate_probabilities
# calculate receptor activity assuming uncorrelated mixtures
if approx_prob:
# approximate calculation for small p_i
r_n = np.dot(S_ni, p_i)
if clip:
np.clip(r_n, 0, 1, r_n)
else:
# proper calculation of the probabilities
r_n = np.zeros(self.Nr)
S_ni_mask = S_ni.astype(np.bool)
for n in range(self.Nr):
r_n[n] = 1 - np.product(1 - p_i[S_ni_mask[n, :]])
if self.is_correlated_mixture:
# add linear correction term for correlated mixtures
J_ij = self.correlations
p_ni = p_i[None, :] * (1 - S_ni)
corr1 = 1 + np.einsum('ij,ni,nj->n', J_ij, p_ni, p_ni)
corr2 = 1 + np.einsum('ij,i,j->', J_ij, p_i, p_i)
barr_n_0 = 1 - r_n
barr_n = barr_n_0 * (1 + corr1 - corr2)
r_n = 1 - barr_n
if clip:
np.clip(r_n, 0, 1, r_n)
if ret_correlations:
# estimate the correlations from the estimated crosstalk
q_nm = self.receptor_crosstalk_estimate(approx_prob=approx_prob,
ignore_correlations=True)
if approx_prob:
r_nm = np.outer(r_n, r_n) + q_nm
else:
r_nm = 1 - (1 - q_nm)*(1 - np.outer(r_n, r_n))
if self.is_correlated_mixture:
# add one correction term for correlated mixtures
p_nmi = np.einsum('i,ni,mi->nmi', p_i, 1 - S_ni, 1 - S_ni)
corr1 = 1 + np.einsum('ij,nmi,nmj->nm', J_ij, p_nmi, p_nmi)
# corr2 = 1 + np.einsum('ij,i,j->', J_ij, p_i, p_i)
# this term has already been calculated above and can be reused
# convert r_nm_0 (here given as r_nm) into barr_nm_0
barr_nm_0 = 1 - barr_n_0[:, None] - barr_n_0[None, :] + r_nm
# correct barr_nm for the correlations J_ij
barr_nm = barr_nm_0 * (1 + corr1 - corr2)
# convert barr_nm into r_nm
r_nm = 1 - barr_n[:, None] - barr_n[None, :] + barr_nm
if clip:
np.clip(r_nm, 0, 1, r_nm)
return r_n, r_nm
else:
return r_n | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def receptor_crosstalk_estimate(self, ret_receptor_activity=False,\n approx_prob=False, clip=False,\n ignore_correlations=False):\n if not ignore_correlations and self.is_correlated_mixture:\n r_n, r_nm = self.receptor_activity... | [
"0.59837115",
"0.57311416",
"0.5284991",
"0.5281454",
"0.5232522",
"0.5206169",
"0.5147281",
"0.5128546",
"0.50398403",
"0.50333416",
"0.4890107",
"0.4862184",
"0.48607644",
"0.48548672",
"0.4842955",
"0.48234457",
"0.47857088",
"0.47831595",
"0.47778708",
"0.47652474",
"0.47... | 0.7158738 | 0 |
calculate the mutual information. `excitation_method` can be ['brute_force', 'monte_carlo', 'estimate', 'auto'] If it is 'auto' than the excitation_method is chosen automatically based on the problem size. `ret_prob_activity` determines whether the probabilities of the different outputs are returned or not | def mutual_information(self, excitation_method='auto', **kwargs):
if excitation_method == 'auto':
if self.Ns <= self.parameters['brute_force_threshold_Ns']:
excitation_method = 'brute_force'
else:
excitation_method = 'monte_carlo'
if excitation_method == 'brute_force' or excitation_method == 'brute-force':
return self.mutual_information_brute_force(**kwargs)
elif excitation_method == 'monte_carlo' or excitation_method == 'monte-carlo':
return self.mutual_information_monte_carlo(**kwargs)
elif excitation_method == 'estimate':
return self.mutual_information_estimate(**kwargs)
else:
raise ValueError('Unknown excitation_method `%s`.' % excitation_method) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mutual_information_brute_force(self, ret_prob_activity=False):\n base = 2 ** np.arange(0, self.Nr)\n\n # prob_a contains the probability of finding activity a as an output.\n prob_a = np.zeros(2**self.Nr)\n for c, prob_c in self._iterate_mixtures():\n # get the associated... | [
"0.7677321",
"0.6729323",
"0.6610971",
"0.62965286",
"0.5475816",
"0.54467",
"0.53803253",
"0.53383917",
"0.5304403",
"0.52832675",
"0.5273865",
"0.52435094",
"0.5235883",
"0.52353334",
"0.51856315",
"0.5179638",
"0.516652",
"0.51329374",
"0.5128437",
"0.5115408",
"0.50964516... | 0.78565335 | 0 |
calculate the mutual information by constructing all possible mixtures | def mutual_information_brute_force(self, ret_prob_activity=False):
base = 2 ** np.arange(0, self.Nr)
# prob_a contains the probability of finding activity a as an output.
prob_a = np.zeros(2**self.Nr)
for c, prob_c in self._iterate_mixtures():
# get the associated output ...
a = np.dot(self.sens_mat, c).astype(np.bool)
# ... and represent it as a single integer
a = np.dot(base, a)
prob_a[a] += prob_c
# normalize the output to make it a probability distribution
prob_a /= prob_a.sum()
# calculate the mutual information
MI = -sum(pa*np.log2(pa) for pa in prob_a if pa != 0)
if ret_prob_activity:
return MI, prob_a
else:
return MI | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_mixture(self) -> None:\n for mu, sigma in zip(self.mus, self.sigmas):\n self.pdfs.append(norm(mu, sigma))",
"def mixture_statistics_brute_force(self):\n \n Z = 0\n hist1d = np.zeros(self.Ns)\n hist2d = np.zeros((self.Ns, self.Ns))\n \n # iter... | [
"0.68045783",
"0.6167079",
"0.61281043",
"0.61196005",
"0.60409695",
"0.5897231",
"0.5874367",
"0.5874367",
"0.58720165",
"0.58610725",
"0.5851441",
"0.5790839",
"0.5739831",
"0.57007676",
"0.56505895",
"0.5636512",
"0.56320953",
"0.56164134",
"0.5601524",
"0.5584634",
"0.556... | 0.6359313 | 1 |
calculate the mutual information using a Monte Carlo strategy. | def mutual_information_monte_carlo_extrapolate(self, ret_prob_activity=False):
if self.is_correlated_mixture:
raise NotImplementedError('Not implemented for correlated mixtures')
base = 2 ** np.arange(0, self.Nr)
prob_s = self.substrate_probabilities
max_steps = self._sample_steps
steps, MIs = [], []
# sample mixtures according to the probabilities of finding
# substrates
count_a = np.zeros(2**self.Nr)
step_check = 10000
for step in range(max_steps):
# choose a mixture vector according to substrate probabilities
m = (np.random.random(self.Ns) < prob_s)
# get the associated output ...
a = np.dot(self.sens_mat, m).astype(np.bool)
# ... and represent it as a single integer
a = np.dot(base, a)
# increment counter for this output
count_a[a] += 1
if step == step_check - 1:
# do an extrapolation step
# calculate the mutual information from the result pattern
prob_a = count_a / step
MI = -sum(pa*np.log2(pa) for pa in prob_a if pa != 0)
# save the data
steps.append(step)
MIs.append(MI)
# do the extrapolation
if len(steps) >= 3:
a2, a1, a0 = MIs[-3:]
MI_ext = (a0*a2 - a1*a1)/(a0 - 2*a1 + a2)
# MI_ext = self._get_extrapolated_mutual_information(steps, MIs)
print((step, MIs[-1], MI_ext))
step_check += 10000
else:
# count_a contains the number of times output pattern a was observed.
# We can thus construct P_a(a) from count_a.
# calculate the mutual information from the result pattern
prob_a = count_a / step
MI = -sum(pa*np.log2(pa) for pa in prob_a if pa != 0)
if ret_prob_activity:
return MI, prob_a
else:
return MI | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_metropolis(self):\n\n # Initialize the posistions for each new Monte Carlo run\n positions = np.random.rand(self.num_p, self.num_d)\n # Initialize the distance matrix\n self.s.positions_distances(positions)\n # check if the wave function is zero\n while True:\n ... | [
"0.67239577",
"0.66396886",
"0.6380537",
"0.6209045",
"0.6204946",
"0.6074391",
"0.6021523",
"0.5984577",
"0.5833803",
"0.58061093",
"0.58041483",
"0.58038014",
"0.58038014",
"0.57740736",
"0.5725444",
"0.57176656",
"0.5682403",
"0.5668028",
"0.5640045",
"0.5637014",
"0.56200... | 0.581717 | 9 |
returns a simple estimate of the mutual information. `approx_prob` determines whether the probabilities of encountering substrates in mixtures are calculated exactly or only approximative, which should work for small probabilities. | def mutual_information_estimate(self, approx_prob=False):
# this might be not the right approach
q_n = self.receptor_activity_estimate(approx_prob=approx_prob)
q_nm = self.receptor_crosstalk_estimate(approx_prob=approx_prob)
# calculate the approximate mutual information
return self._estimate_MI_from_q_values(q_n, q_nm) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mutual_information_monte_carlo_extrapolate(self, ret_prob_activity=False):\n if self.is_correlated_mixture:\n raise NotImplementedError('Not implemented for correlated mixtures')\n \n base = 2 ** np.arange(0, self.Nr)\n prob_s = self.substrate_probabilities\n\n ... | [
"0.5583002",
"0.5569024",
"0.55195194",
"0.54732513",
"0.5439062",
"0.5311237",
"0.5172197",
"0.5165276",
"0.51317364",
"0.50231713",
"0.48275942",
"0.4811054",
"0.48098183",
"0.48028716",
"0.4798505",
"0.47701705",
"0.47494784",
"0.47418514",
"0.4734358",
"0.47275934",
"0.47... | 0.75532436 | 0 |
calculates the usefulness of each receptor, measured by how much information it adds to the total mutual information. `method` determines which method is used to determine the mutual information. `multiprocessing` determines whether multiprocessing is used for determining the mutual informations of all subsystems. | def receptor_score(self, method='auto', multiprocessing=False):
init_arguments = self.init_arguments
init_arguments['parameters']['initialize_state']['sensitivity'] = 'exact'
init_arguments['parameters']['sensitivity_matrix'] = self.sens_mat
joblist = [(copy.deepcopy(self.init_arguments), 'mutual_information',
{'method': method})]
# add one job for each receptor
for n in range(self.Nr):
init_arguments = self.init_arguments
init_arguments['num_receptors'] -= 1
# modify the current state and add it to the job list
sens_mat = np.delete(self.sens_mat, n, axis=0)
init_arguments['parameters']['sensitivity_matrix'] = sens_mat
joblist.append((copy.deepcopy(init_arguments), 'mutual_information',
{'method': method}))
if multiprocessing:
# calculate all results in parallel
pool = mp.Pool(processes=self.get_number_of_cores())
results = pool.map(_run_job, joblist)
else:
# create a generator over which we iterate later
results = [_run_job(job) for job in joblist]
# find the scores of all receptors
scores = results[0] - np.array(results[1:])
return scores | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mutual_information(self, excitation_method='auto', **kwargs):\n if excitation_method == 'auto':\n if self.Ns <= self.parameters['brute_force_threshold_Ns']:\n excitation_method = 'brute_force'\n else:\n excitation_method = 'monte_carlo'\n ... | [
"0.6172455",
"0.5696483",
"0.55845743",
"0.5454974",
"0.5411215",
"0.5398892",
"0.53274125",
"0.5234939",
"0.5197039",
"0.5172683",
"0.51339173",
"0.50398976",
"0.4996997",
"0.4983228",
"0.49595007",
"0.49515915",
"0.49353585",
"0.49350932",
"0.49265435",
"0.49167734",
"0.488... | 0.72649634 | 0 |
optimizes the current library to maximize the result of the target function. By default, the function returns the best value and the associated interaction matrix as result. `direction` is either 'min' or 'max' and determines whether a minimum or a maximum is sought. `steps` determines how many optimization steps we try `ret_info` determines whether extra information is returned from the optimization `args` is a dictionary of additional arguments that is passed to the target function `method` determines the method used for optimization. Supported are | def optimize_library(self, target, method='descent', direction='max',
**kwargs):
if method == 'descent':
return self.optimize_library_descent(target, direction, **kwargs)
elif method == 'descent_multiple' or method == 'descent-multiple':
return self.optimize_library_descent_multiple(target, direction,
**kwargs)
elif method == 'anneal':
return self.optimize_library_anneal(target, direction, **kwargs)
else:
raise ValueError('Unknown optimization method `%s`' % method) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimize_library_descent(self, target, direction='max', steps=100,\n multiprocessing=False, ret_info=False,\n args=None):\n # get the target function to call\n target_function = getattr(self, target)\n if args is not None:\n ... | [
"0.7191519",
"0.6706924",
"0.62114525",
"0.5192495",
"0.513346",
"0.5125227",
"0.5031708",
"0.5031085",
"0.49857607",
"0.4900932",
"0.4900832",
"0.48536816",
"0.48484892",
"0.48352584",
"0.47795326",
"0.4738466",
"0.47372732",
"0.4712714",
"0.47082347",
"0.46975875",
"0.46776... | 0.63557446 | 2 |
optimizes the current library to maximize the result of the target function using gradient descent. By default, the function returns the best value and the associated interaction matrix as result. `direction` is either 'min' or 'max' and determines whether a minimum or a maximum is sought. `steps` determines how many optimization steps we try `multiprocessing` is a flag deciding whether multiple processes are used to calculate the result. Note that this has an overhead and might actually decrease overall performance for small problems `ret_info` determines whether extra information is returned from the optimization `args` is a dictionary of additional arguments that is passed to the target function | def optimize_library_descent(self, target, direction='max', steps=100,
multiprocessing=False, ret_info=False,
args=None):
# get the target function to call
target_function = getattr(self, target)
if args is not None:
target_function = functools.partial(target_function, **args)
# initialize the optimizer
value = target_function()
value_best, state_best = value, self.sens_mat.copy()
if ret_info:
# store extra information
start_time = time.time()
info = {'values': {}}
values_count = self.parameters['optimizer_values_count']
values_step = max(1, steps // values_count)
if multiprocessing:
# run the calculations in multiple processes
pool_size = self.get_number_of_cores()
pool = mp.Pool(processes=pool_size)
if ret_info:
values_step = max(1, values_step // pool_size)
# iterate for given number of steps
for step in range(int(steps) // pool_size):
joblist = []
init_arguments = self.init_arguments
for _ in range(pool_size):
# modify the current state and add it to the job list
i = random.randrange(self.sens_mat.size)
self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]
params = init_arguments['parameters']
params['sensitivity_matrix'] = self.sens_mat
params['initialize_state']['sensitivity'] = 'exact'
joblist.append((copy.deepcopy(init_arguments), target))
self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]
# run all the jobs
results = pool.map(_run_job, joblist)
# find the best result
if direction == 'max':
res_best = np.argmax(results)
if results[res_best] > value_best:
value_best = results[res_best]
state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']
# use the best state as a basis for the next iteration
self.sens_mat = state_best
elif direction == 'min':
res_best = np.argmin(results)
if results[res_best] < value_best:
value_best = results[res_best]
state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']
# use the best state as a basis for the next iteration
self.sens_mat = state_best
else:
raise ValueError('Unsupported direction `%s`' % direction)
if ret_info and step % values_step == 0:
info['values'][step * pool_size] = results[res_best]
else:
# run the calculations in this process
for step in range(int(steps)):
# modify the current state
i = random.randrange(self.sens_mat.size)
self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]
# get the value of the new state
value = target_function()
improved = ((direction == 'max' and value > value_best) or
(direction == 'min' and value < value_best))
if improved:
# save the state as the new best value
value_best, state_best = value, self.sens_mat.copy()
else:
# undo last change
self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]
if ret_info and step % values_step == 0:
info['values'][step] = value_best
# sort the best state and store it in the current object
state_best = self.sort_sensitivity_matrix(state_best)
self.sens_mat = state_best.copy()
if ret_info:
info['total_time'] = time.time() - start_time
info['states_considered'] = steps
info['performance'] = steps / info['total_time']
return value_best, state_best, info
else:
return value_best, state_best | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimize_library_descent_multiple(self, target, direction='max',\n trials=4, multiprocessing=False,\n ret_error=False, **kwargs):\n \n # pass some parameters down to the optimization function to call\n kwargs... | [
"0.651425",
"0.60995185",
"0.59783125",
"0.5357869",
"0.5349476",
"0.53483707",
"0.5300958",
"0.5280729",
"0.5255571",
"0.51577455",
"0.51000774",
"0.50822264",
"0.5080444",
"0.50465363",
"0.50355375",
"0.50104886",
"0.4993036",
"0.49904832",
"0.49328518",
"0.49109367",
"0.49... | 0.77414405 | 0 |
optimizes the current library to maximize the result of the target function using gradient descent from `trials` different staring positions. Only the result from the best run will be returned | def optimize_library_descent_multiple(self, target, direction='max',
trials=4, multiprocessing=False,
ret_error=False, **kwargs):
# pass some parameters down to the optimization function to call
kwargs['target'] = target
kwargs['direction'] = direction
# initialize the list of jobs with an optimization job starting from the
# current interaction matrix
joblist = [(self.init_arguments, 'optimize_library_descent', kwargs)]
sens_mat = self.sens_mat #< store matrix to restore it later
# set the ensemble of sensitivity matrices to try
self.choose_sensitivity_matrix(density='auto')
self.parameters['initialize_state']['sensitivity'] = 'ensemble'
# add additional jobs with random initial interaction matrices
init_arguments = self.init_arguments
for _ in range(trials - 1):
joblist.append((copy.deepcopy(init_arguments),
'optimize_library_descent', kwargs))
# restore interaction matrix of this object
self.sens_mat = sens_mat
if multiprocessing:
# calculate all results in parallel
pool = mp.Pool(processes=self.get_number_of_cores())
result_iter = pool.imap_unordered(_run_job, joblist)
else:
# create a generator over which we iterate later
result_iter = (_run_job(job) for job in joblist)
# find the best result by iterating over all results
result_best, values = None, []
for result in result_iter:
values.append(result[0])
# check whether this run improved the result
if result_best is None:
result_best = result
elif ((direction == 'max' and result[0] > result_best[0]) or
(direction == 'min' and result[0] < result_best[0])):
result_best = result
# sort the best state and store it in the current object
state = self.sort_sensitivity_matrix(result_best[1])
self.sens_mat = state.copy()
if ret_error:
# replace the best value by a tuple of the best value and its error
value_best = result_best[0]
value_err = np.abs(value_best - np.median(values))
result_best = ((value_best, value_err), ) + result_best[1:]
return result_best | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimize(\n # trials,\n random_state=SEED):\n\n space = {\n 'max_depth': scope.int(hp.uniform('max_depth', 5, 15)),\n 'subsample': hp.uniform('subsample', 0.03, 1),\n 'learning_rate' : hp.loguniform('learning_rate', np.log(0.005), np.log(0.5)) - 0.0001,... | [
"0.6879043",
"0.6779472",
"0.6599153",
"0.6580296",
"0.6474444",
"0.6437695",
"0.6382017",
"0.6354665",
"0.62422895",
"0.62376463",
"0.62362105",
"0.6233735",
"0.6200726",
"0.6200518",
"0.61941844",
"0.6183736",
"0.61756665",
"0.61680037",
"0.6155385",
"0.61435944",
"0.614115... | 0.6747765 | 2 |
optimizes the current library to maximize the result of the target function using simulated annealing. By default, the function returns the best value and the associated interaction matrix as result. `direction` is either 'min' or 'max' and determines whether a minimum or a maximum is sought. `steps` determines how many optimization steps we try `ret_info` determines whether extra information is returned from the optimization `args` is a dictionary of additional arguments that is passed to the target function | def optimize_library_anneal(self, target, direction='max', steps=100,
ret_info=False, args=None):
# lazy import
from .optimizer import ReceptorOptimizerAnnealer # @UnresolvedImport
# prepare the class that manages the simulated annealing
annealer = ReceptorOptimizerAnnealer(self, target, direction, args,
ret_info=ret_info)
annealer.steps = int(steps)
annealer.Tmax = self.parameters['anneal_Tmax']
annealer.Tmin = self.parameters['anneal_Tmin']
if self.parameters['verbosity'] == 0:
annealer.updates = 0
# do the optimization
MI, state = annealer.optimize()
# sort the best state and store it in the current object
state = self.sort_sensitivity_matrix(state)
self.sens_mat = state.copy()
if ret_info:
return MI, state, annealer.info
else:
return MI, state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimize_library_descent(self, target, direction='max', steps=100,\n multiprocessing=False, ret_info=False,\n args=None):\n # get the target function to call\n target_function = getattr(self, target)\n if args is not None:\n ... | [
"0.70528316",
"0.59501183",
"0.5642754",
"0.5085643",
"0.50599",
"0.5013388",
"0.5011954",
"0.5007961",
"0.5003236",
"0.49108404",
"0.48720664",
"0.48720354",
"0.48174542",
"0.4795054",
"0.47906741",
"0.47627977",
"0.47517008",
"0.46950796",
"0.46797842",
"0.46576664",
"0.464... | 0.72034293 | 0 |
generator function that samples mixtures according to the `model`. `steps` determines how many mixtures are sampled `dtype` determines the dtype of the resulting concentration vector | def _sample_binary_mixtures(model, steps, dtype=np.uint):
mixture_size = model.parameters['fixed_mixture_size']
if not model.is_correlated_mixture and mixture_size is None:
# use simple monte carlo algorithm
prob_s = model.substrate_probabilities
for _ in range(int(steps)):
# choose a mixture vector according to substrate probabilities
yield (np.random.random(model.Ns) < prob_s).astype(dtype)
elif mixture_size is None:
# go through all mixtures and don't keep the size constant
# use metropolis algorithm
hi = model.commonness
Jij = model.correlations
# start with a random concentration vector
c = np.random.randint(0, 2, model.Ns).astype(dtype)
E_last = -np.dot(np.dot(Jij, c) + hi, c)
for _ in range(int(steps)):
i = random.randrange(model.Ns)
c[i] = 1 - c[i] #< switch the entry
Ei = -np.dot(np.dot(Jij, c) + hi, c)
if Ei < E_last or random.random() < np.exp(E_last - Ei):
# accept the new state
E_last = Ei
else:
# reject the new state and revert to the last one
c[i] = 1 - c[i]
yield c
elif mixture_size == 0:
# special case which is not covered by the iteration below
c_zero = np.zeros(model.Ns, dtype)
for _ in range(model._sample_steps):
yield c_zero
elif mixture_size == model.Ns:
# special case which is not covered by the iteration below
c_ones = np.ones(model.Ns, dtype)
for _ in range(steps):
yield c_ones
else:
# go through mixtures with keeping their size constant
# use metropolis algorithm
hi = model.commonness
Jij = model.correlations
# create random concentration vector with fixed substrate count
c = np.r_[np.ones(mixture_size, dtype),
np.zeros(model.Ns - mixture_size, dtype)]
np.random.shuffle(c)
E_last = -np.dot(np.dot(Jij, c) + hi, c)
for _ in range(int(steps)):
# find the next mixture by swapping two items
i0 = random.choice(np.flatnonzero(c == 0)) #< find 0
i1 = random.choice(np.flatnonzero(c)) #< find 1
c[i0], c[i1] = 1, 0 #< swap entries
Ei = -np.dot(np.dot(Jij, c) + hi, c)
if Ei < E_last or random.random() < np.exp(E_last - Ei):
# accept the new state
E_last = Ei
else:
# reject the new state and revert to the last one
c[i0], c[i1] = 0, 1
yield c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sample_mixtures(self, steps=None, dtype=np.uint):\n if steps is None:\n steps = self._sample_steps\n \n return _sample_binary_mixtures(self, steps, dtype)",
"def _iterate_mixtures(self):\n \n if self._iterate_steps > self.parameters['max_steps']:\n ra... | [
"0.7261067",
"0.6262869",
"0.5684544",
"0.56400836",
"0.55678874",
"0.5419031",
"0.5419031",
"0.5378836",
"0.53703797",
"0.5349273",
"0.5279914",
"0.52595407",
"0.5239342",
"0.52295643",
"0.5188037",
"0.51616156",
"0.515846",
"0.5093254",
"0.50914216",
"0.5061559",
"0.5050774... | 0.7653979 | 0 |
helper function for optimizing the receptor library using multiprocessing | def _run_job(args):
# Note that we do not set the seed of the random number generator because
# we already modified the interaction matrix before calling this function
# and it does not harm us when all sub processes have the same sequence of
# random numbers.
# create the object ...
obj = LibraryBinaryNumeric(**args[0])
# ... get the method to evaluate ...
method = getattr(obj, args[1])
# ... and evaluate it
if len(args) > 2:
return method(**args[2])
else:
return method() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _optimise(self):\n pass",
"def computeIntercepts():\n pass",
"def propose_optimize():\n pass",
"def process():",
"def reduce_run():",
"def test_3():\n \n\n # Functions wrapped by agents\n def f(in_streams, out_streams):\n multiply_and_add(in_streams[0], out_streams[0],\n ... | [
"0.63033754",
"0.59346247",
"0.5667658",
"0.5634969",
"0.5632718",
"0.5520529",
"0.5416026",
"0.5395593",
"0.5282536",
"0.5226786",
"0.52209985",
"0.5219927",
"0.52054894",
"0.5177828",
"0.51697385",
"0.51571566",
"0.51315176",
"0.51257294",
"0.51191217",
"0.5107856",
"0.5104... | 0.0 | -1 |
test the performance of the brute force and the Monte Carlo method | def performance_test(Ns=15, Nr=3):
num = 2**Ns
hs = np.random.random(Ns)
model = LibraryBinaryNumeric(Ns, Nr, hs)
start = time.time()
model.mutual_information_brute_force()
time_brute_force = time.time() - start
print('Brute force: %g sec' % time_brute_force)
start = time.time()
model.mutual_information_monte_carlo(num)
time_monte_carlo = time.time() - start
print('Monte carlo: %g sec' % time_monte_carlo) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n hash_str = '5411ba21c470e12d49f351a2d240e43618032950'\n salt = '0d71906d0f735e6196c80d0a7cb1748e'\n encrypted_code = 'Ul5SR0ISYFxUXl8OOxITFBFWVlIRQVtRXV4bHQs4ExQREhMUERJDRlhcRxwWZltdQhJaRxFTE0BUQUcUXF1XQV1XFB07EhMUE' \\\n 'RITFBFCQV1fRhsTZVdAQBFhRldSV0BHV0dfGhYbOQ=='\n ... | [
"0.6661952",
"0.6618818",
"0.64001924",
"0.63427407",
"0.6263836",
"0.6232404",
"0.6223552",
"0.59330684",
"0.59220713",
"0.59127235",
"0.58657014",
"0.58575463",
"0.5836921",
"0.58361584",
"0.58269995",
"0.5803118",
"0.5761818",
"0.573099",
"0.57286465",
"0.57004774",
"0.568... | 0.6652606 | 1 |
Returns Classroom in good representation for user | def __str__(self):
return 'Classroom {} has a capacity of {} persons and ' \
'has the following equipment: {}.'.format(
self.number, str(self.capacity), ', '.join(self.equipment)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self):\n return \"Classroom('{}', {}, {})\".format(self.number, self.capacity,\n str(self.equipment))",
"def __str__(self):\n return self.room_name",
"def __str__(self):\n return self.room.name",
"def json(self):\n return... | [
"0.6388747",
"0.58620846",
"0.5832608",
"0.55203956",
"0.5508624",
"0.5427314",
"0.54227597",
"0.5291813",
"0.5283396",
"0.52249587",
"0.5194744",
"0.5179897",
"0.51505965",
"0.51442033",
"0.5131981",
"0.5128399",
"0.51204616",
"0.5106739",
"0.5105534",
"0.5094171",
"0.507423... | 0.5878091 | 1 |
Classroom, Classroom > bool Returns True if first room have bigger capacity then second room | def is_larger(self, room2):
return self.capacity > room2.capacity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __gt__(self, other: Card) -> bool:\n return not self.__le__(other)",
"def pareto_better(self, other: \"EvalItem\") -> bool:\n return self.size <= other.size and other.result <= self.result",
"def __gt__(self, other):\n return self.weight() > other.weight()",
"def __gt__(self, other):... | [
"0.61225253",
"0.5890521",
"0.5887941",
"0.58851635",
"0.5883985",
"0.5871",
"0.5871",
"0.58323383",
"0.57970667",
"0.57674",
"0.57477105",
"0.57477105",
"0.5667831",
"0.5658871",
"0.56532055",
"0.5647148",
"0.56317246",
"0.56295174",
"0.5624304",
"0.55907315",
"0.5584328",
... | 0.73677325 | 0 |
Classroom, Classroom > list Returns the equipment in first room which is missing in second | def equipment_differences(self, room2):
return sorted(list(set(self.equipment).difference(room2.equipment))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_rooms(self, exclude=[]):\n stmt = Session.query(Lesson.room, Lesson.day, Lesson.order,\n Lesson.schedule_id)\n stmt = stmt.group_by(Lesson.room, Lesson.order, Lesson.day, Lesson.schedule_id)\n stmt = stmt.having(func.count(Lesson.room)>1)\n stmt = stmt.filter(not_(L... | [
"0.6358367",
"0.6313788",
"0.6150663",
"0.60647494",
"0.5886441",
"0.5728688",
"0.5633727",
"0.5608109",
"0.55511093",
"0.53285015",
"0.5248454",
"0.523609",
"0.5177248",
"0.5149604",
"0.51473695",
"0.5124947",
"0.5094668",
"0.50736094",
"0.50731784",
"0.50704306",
"0.5062421... | 0.6854201 | 0 |
Returns beautiful representation for programmer | def __repr__(self):
return "Classroom('{}', {}, {})".format(self.number, self.capacity,
str(self.equipment)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n astr = '[\\n name: [ ' + self.name + ' ]\\n'\n astr += ' variables: [ '\n for var, init in self.variables:\n astr += '(' + var + ' := ' + init + '), '\n astr = astr[:-2] + ' ]\\n assumptions: [ '\n for assumption in self.assumptions:\n ... | [
"0.7089211",
"0.68339634",
"0.6794942",
"0.67740595",
"0.6765707",
"0.66930324",
"0.66878825",
"0.6668747",
"0.6645762",
"0.6644278",
"0.6640405",
"0.660601",
"0.6604529",
"0.657811",
"0.6575636",
"0.65749127",
"0.6557521",
"0.65515167",
"0.65472",
"0.6546359",
"0.65233105",
... | 0.0 | -1 |
Get arguments from command line | def getArgumentParser():
parser = argparse.ArgumentParser(description="Script for running optimization for the ZH dark photon SR")
parser.add_argument('-i',
'--infile',
dest='infile',
help='Input CSV file',
default = '/afs/cern.ch/work/s/ssevova/public/dark-photon-atlas/zhdarkphotonml/samples/v09/mc16d_v09_samples.csv')
parser.add_argument('-o',
'--output',
dest='outdir',
help='Output directory for plots, selection lists, etc',
default='outdir')
parser.add_argument('--plotInputs',action='store_true', help='Plot scaled train & test inputs')
parser.add_argument('--plotOutputs',action='store_true', help='Plot scaled test outputs for given probability range')
parser.add_argument('--lower',help='Lower limit for conditional filtering')
parser.add_argument('--upper',help='Upper limit for conditional filtering')
return parser | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cli_arguments(self):\n pass",
"def get_command_line_args():\n \n parser = argparse.ArgumentParser()\n parser.add_argument('-s', '--symbol', help='symbol query')\n\n # no limit should be input as 'max'\n parser.add_argument('-l',\n '--li... | [
"0.77721745",
"0.76546174",
"0.7628115",
"0.75778574",
"0.75472254",
"0.7456921",
"0.74439055",
"0.7440344",
"0.74382585",
"0.7389421",
"0.7364026",
"0.73364145",
"0.73019594",
"0.7261001",
"0.72259796",
"0.722258",
"0.71752733",
"0.7173149",
"0.7171823",
"0.71440315",
"0.713... | 0.0 | -1 |
Calculate pairwise correlation between features. Extra arguments are passed on to DataFrame.corr() | def correlations(data,data_type, **kwds):
# simply call df.corr() to get a table of
# correlation values if you do not need
# the fancy plotting
corrmat = data.corr(**kwds)
fig, ax1 = plt.subplots(ncols=1, figsize=(6,5))
opts = {'cmap': plt.get_cmap("RdBu"),
'vmin': -1, 'vmax': +1}
heatmap1 = ax1.pcolor(corrmat, **opts)
plt.colorbar(heatmap1, ax=ax1)
ax1.set_title("Correlations "+data_type)
labels = corrmat.columns.values
for ax in (ax1,):
# shift location of ticks to center of the bins
ax.set_xticks(np.arange(len(labels))+0.5, minor=False)
ax.set_yticks(np.arange(len(labels))+0.5, minor=False)
ax.set_xticklabels(labels, minor=False, ha='right', rotation=70)
ax.set_yticklabels(labels, minor=False)
plt.tight_layout()
plt.savefig("Correlations_"+data_type+".pdf") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pairwise_corr(df1, df2):\n res = []\n for i in range(df2.shape[1]):\n res.append(df1.corrwith(df2.ix[:, i]))\n res = pd.concat(res, axis=1)\n res.columns = df2.columns\n return res",
"def calculate_feature_corr(self):\n \n return self.train_data.astype(float).corr(method='... | [
"0.74171937",
"0.71074754",
"0.6666765",
"0.66659594",
"0.6619614",
"0.6587562",
"0.6580525",
"0.6578581",
"0.65783983",
"0.65568876",
"0.6511679",
"0.6491773",
"0.6461151",
"0.6446981",
"0.64354914",
"0.63979685",
"0.6396546",
"0.6372075",
"0.6297028",
"0.6269612",
"0.623975... | 0.0 | -1 |
Parse one access line. | def ParseLine(line):
fields = line.split()
ip = fields[0]
datestr = ' '.join(fields[3:5])[1:-1]
timestamp = datetime.strptime(
datestr, '%d/%b/%Y:%H:%M:%S %z'
).timestamp()
command = fields[5][1:]
uri = fields[6]
protocol = fields[7][:-1]
status = int(fields[8])
size = int(fields[9])
meta = [var.strip('"') for var in fields[11:-1]]
return {
'timestamp': timestamp,
'ip': ip,
'command': command,
'uri': uri,
'protocol': protocol,
'status': status,
'size': size,
'meta': meta
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_line(self, line):\n raise NotImplementedError",
"def parse(cls, line):\r\n raise NotImplementedError",
"def parse_line(self, line, time_shift=0.0):\n # The local variables are rather simple.\n # pylint: disable=too-many-locals\n try:\n (\n mode... | [
"0.6672727",
"0.62225854",
"0.613628",
"0.61219925",
"0.59706",
"0.5941891",
"0.5929608",
"0.5854193",
"0.5786448",
"0.577579",
"0.5775706",
"0.576628",
"0.5740041",
"0.5700446",
"0.56839246",
"0.56678885",
"0.56678885",
"0.56678885",
"0.56678885",
"0.56296605",
"0.5623283",
... | 0.5084293 | 75 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.